root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/ve6300.cpp
guy 1ba069822a Patch level : 2.2 
Files correlati     : ve0 ve6
Ricompilazione Demo : [ ]
Commento            :

Tolte commesse dalla elaborazione di contabilizzazione ed aggiunta
contabilizzazione analitica


git-svn-id: svn://10.65.10.50/trunk@13059 c028cbd2-c16b-5b4b-a496-9718f37d4682
2005-05-06 10:58:49 +00:00

598 lines
20 KiB
C++
Executable File
Raw Blame History

// ve6300.cpp: programma di generazione effetti
// Muliebrica parodia...
// Il cavo delirante che irrompe nel silenzio dell'apogeo
// * * * * * * *
// *
// _ _______ _____________ ___================
// _I_I___oo_____ii__| |_|| | | \ | |O| |_| |_|
// | | - - | I | | | L M S | | | |
// _|___|________|____ I____|_|=|_____________|=II=|__|_|_____________
// I=| o (_)--(_)--(_)--(_) O--O O-O +++++ O-O \--/ ()==() ++++
//=======================================================================
//
//
// ____||____============____||___ ___===============================
// /__| OOOOOOOOOOOOO [_] | | |[]| [_] [_] [_] [_]
// / S N C F | | | |
// \________________________________|_ii_|__|__|___________________________
// ()==() === ++++ === ()==() ()==() +++ +++ ++++++++
//=========================================================================
//
// Have you ever heard MK ?
#include <applicat.h>
#include <modaut.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <urldefid.h>
#include "velib04.h"
#include "ve6300a.h"
#include <doc.h>
// TGenerazioneEffetti_app
// Applicazione di generazione effetti
class TGenerazioneEffetti_app : public TSkeleton_application
{
TString16 _cod_el; // codice elaborazione immesso
bool _raggruppa; // se TRUE raggruppa gli effetti secondo i criteri
TMask *_msk; // maschera di selezione dati
TBit_array _valid_array; // array dei tipi di pagamento validi per la generazione di effetti
TArray_sheet *_num_sheet; // Array sheet selezionabile dei codici numerazione
TAssoc_array _group_array; // Assoc_array dei documenti da raggruppare. La chiave di ogni elemento
TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare
char _final_doc_status; // Valore per lo stato finale del documento
// Flags di raggruppamento opzionali (%ELD->S1):
bool _group_by_date, // raggruppa per data di scadenza
_group_by_sosp, // raggruppa per flag sosp. d'imposta
_group_by_change, // raggruppa per cambio
_group_by_pag, // raggruppa per cond. di pagamento
_group_by_bank, // raggruppa per banca (ABI-CAB)
_group_by_type, // raggruppa per tipo di documento
_group_by_num, // raggruppa per cod. numerazione
_group_by_agent; // raggruppa per agente
TArray _file;
protected: // TApplication
// Le 4 seguenti non hanno bisogno di commenti
virtual void main_loop();
virtual bool create();
virtual bool destroy();
// Cambia lo stato del documento
int change_doc_status(TDocumento*);
// Coontrolla se lo stato ed il tipo del documento sono validi e rispettano la selezione
bool doc_tipo_stato_ok(TDocumento*);
// Handler del codice elaborazione differita
static bool handle_cod_eld(TMask_field& f, KEY k);
// Handler dell'intervallo di date
static bool handle_data_range(TMask_field& f, KEY k);
// Handler del pulsante di selezione codici numerazione
static bool handle_select(TMask_field& f, KEY k);
// Handler del campo numerazione
static bool handle_codnum(TMask_field& f, KEY k);
// Ritorna il TArray_sheet contenente le selezioni sui codici numerazione
TArray_sheet* get_num_sheet() const { return _num_sheet; }
// Costruisce lo sheet dei codici numerazione
void build_num_sheet();
// Aggiunge il documento corrente alla lista dei documenti raggruppabili
void add_to_group_list(TDocumento* doc);
// Costruisce la stringa chiave per raggruppamento
void build_group_key(TString& key, TDocumento* doc);
// Costruisce la stringa chiave per documento
void build_doc_key(TToken_string& key, TDocumento* doc);
// Setta i flags di raggruppamento opzionali in base alla tabella
void set_options();
void generate();
public:
TGenerazioneEffetti_app() {_msk = NULL; _num_sheet = NULL;}
virtual ~TGenerazioneEffetti_app() { }
};
inline TGenerazioneEffetti_app& app() { return (TGenerazioneEffetti_app&) main_app(); }
bool TGenerazioneEffetti_app::handle_data_range(TMask_field& f, KEY k)
{
if (k==K_ENTER && f.dirty())
{
TMask& m = f.mask();
TDate da(m.get_date(F_DATA_INI));
TDate a(m.get_date(F_DATA_FIN));
//m.field(F_DATA_REG).set_dirty();
//if (a == botime || da == botime) return TRUE;
if (a < da)
{
f.error_box("La data di inizio deve essere minore della data di fine.");
return FALSE;
}
//if ((a - da) > 15)
//{
// f.error_box("L'intervallo tra le date non puo' eccedere i 15 giorni.");
// return FALSE;
//}
}
return TRUE;
}
bool TGenerazioneEffetti_app::handle_cod_eld(TMask_field& f, KEY k)
{
TMask& m = f.mask();
if (k == K_TAB && !m.is_running())
{
TEdit_field& e = (TEdit_field&)f;
TCursor& cur = *e.browse()->cursor();
if (cur.items() > 0)
{
cur = 0L;
const TRectype& eld = cur.curr();
app()._cod_el = eld.get("CODTAB");
f.set(app()._cod_el);
m.set(F_DESC_ELAB, eld.get("S0"));
app().build_num_sheet();
}
}
if (f.to_check(k) && k == K_TAB) // se e' cambiato ricostruisce anche lo sheet dei codici numerazione
{
app()._cod_el = f.get(); // aggiorna il codice elaborazione per la build_num_sheet()
app().build_num_sheet();
m.disable(DLG_OK);
}
return TRUE;
}
bool TGenerazioneEffetti_app::handle_select(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TArray_sheet& s = *app().get_num_sheet();
if (s.run())
{
TMask& m = f.mask();
if (s.checked() > 0) // Hai selezionato qualcosa ?
{
// Cerca di proporre la prima numerazione possibile
for (long i = 0; i < s.items(); i++) if (s.checked(i))
{
TToken_string& row = s.row(i);
m.set(F_CODNUM, row.get(1));
m.set(F_DESCNUM, row.get());
break;
}
m.enable(DLG_OK); // allora abilita il pulsante di conferma
}
else
m.disable(DLG_OK);
}
}
return TRUE;
}
bool TGenerazioneEffetti_app::handle_codnum(TMask_field& f, KEY k)
{
TMask& m = f.mask();
if (k == K_F9)
return handle_select(m.field(DLG_USER), K_SPACE);
if (k == K_TAB && f.focusdirty() && !f.empty())
{
m.set(F_DESCNUM, cache().get("%NUM", f.get(), "S0"));
k = K_ENTER;
}
if (k == K_ENTER)
{
TArray_sheet& s = *app().get_num_sheet();
for (long i = 0; i < s.items(); i++) if (s.row_enabled(i))
{
TToken_string& row = s.row(i);
if (f.get() == row.get(1))
return TRUE;
}
return error_box("Numerazione non valida");
}
return TRUE;
}
void TGenerazioneEffetti_app::build_num_sheet()
{
_num_sheet->destroy();
_tipi_doc.destroy();
if (_cod_el.not_empty())
{
TContabilizzazione* cont = new TContabilizzazione(_cod_el);
if (!cont->empty())
{
TToken_string t;
TString16 tipo;
_final_doc_status = cont->stato_finale()[0];
for (int i=0;i<TElaborazione::_max_tipi_doc_elab;i++)
{
tipo = cont->tipo_iniziale(i);
if (tipo.not_empty())
{
t = tipo;
t.add(cont->stato_iniziale(i)); // Stato iniziale
_tipi_doc.add(t); // Aggiunge questo tipo documento alla lista
}
}
long pos = 0l;
TTable num("%NUM");
for (num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
{
TToken_string t,z;
t.add(" ");
t.add(num.get("CODTAB"));
t.add(num.get("S0"));
_num_sheet->add(t);
const TString& s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
for (int x = 0; x <= s2.len(); x += 4)
z.add(s2.mid(x,4));
bool found = FALSE;
for (int i = _tipi_doc.last(); !found && i >= 0; i--)
found |= (z.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0);
if (found)
_num_sheet->enable_row(pos);
else
_num_sheet->disable_row(pos);
}
// Applica un filtro ai documenti da elaborare
TString filter;
for (int td = _tipi_doc.last(); td >= 0; td--)
{
TToken_string& row = _tipi_doc.row(td);
if (filter.not_empty())
filter << "||";
filter << "((" << DOC_TIPODOC << "==\"" << row.get(0) << "\")&&(";
filter << DOC_STATO << "==\"" << row.get(1) << "\"))" ;
}
_msk->efield(F_NDOC_INI).browse()->set_filter(filter);
_msk->efield(F_NDOC_FIN).browse()->set_filter(filter);
}
delete cont;
}
}
bool TGenerazioneEffetti_app::create()
{
if (!has_module(EFAUT))
{
error_box("Impossibile eseguire il programma se il modulo Effetti non e' abilitato");
return FALSE;
}
open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN,
LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_CONDV,
LF_SVRIEP, LF_AGENTI, LF_PERCPROV, LF_CESS, LF_CAUSALI, 0);
_msk = new TMask("ve6300a");
_msk->set_handler(F_CODICE_ELAB, handle_cod_eld);
_msk->set_handler(F_DATA_INI, handle_data_range);
_msk->set_handler(F_DATA_FIN, handle_data_range);
_msk->set_handler(F_CODNUM, handle_codnum);
_msk->set_handler(DLG_USER, handle_select);
_num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione",
"@1|Cod. numerazione|Descrizione@50");
return TSkeleton_application::create();
}
bool TGenerazioneEffetti_app::destroy()
{
if (_msk) delete _msk;
if (_num_sheet) delete _num_sheet;
return TSkeleton_application::destroy();
}
void TGenerazioneEffetti_app::main_loop()
{
while (_msk->run() == K_ENTER)
{
_cod_el = _msk->get(F_CODICE_ELAB);
_raggruppa = _msk->get_bool(F_RAGGRUPPA);
generate();
}
}
bool TGenerazioneEffetti_app::doc_tipo_stato_ok(TDocumento* doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
const int items = _tipi_doc.items();
bool found = FALSE;
const TString16 tipo(doc->tipo().codice());
const char stato = doc->stato();
for (int i=0;i<items && !found;i++)
{
TToken_string& t = _tipi_doc.row(i);
const TString16 tipox(t.get(0));
const char statox = t.get(1)[0];
if (tipo == tipox && stato == statox)
found = TRUE;
}
return found;
}
int TGenerazioneEffetti_app::change_doc_status(TDocumento* doc)
// Cambia lo stato del documento
{
doc->stato(_final_doc_status);
return doc->rewrite();
}
// Criteri di raggruppamento effetti.
// Un documento puo' essere raggruppato con i seguenti criteri:
// - flag di raggruppamento effetti a TRUE (obbligatorio)
// - cliente (obbligatorio)
// - valuta (obbligatorio)
// - data scadenza (opzionale)
// - flag di sosp. d'imposta (opzionale)
// - cambio valuta (opzionale)
// - cond di pagamento (opzionale)
// - banca (opzionale)
// - tipo doc. (opzionale)
// - cod. numerazione (opzionale)
// - agente (opzionale)
// I parametri opzionali sono decisi nella tabella elaborazioni
// Spiegazione del raggruppamento:
// Il raggruppamento di documenti diversi in uno stesso effetto consiste nella creazione
// di piu' righe dello stesso effetto.
// Ad esempio supponiamo di avere il cliente 10 con 4 fatture ognuna con condizioni di pagamento diverse
// la fattura 1 e' suddivisa in 2 rate (10.000 + 30.000)
// la fattura 2 e' suddivisa in 4 rate (15.000 + 20.000 + 25.000 + 30.000)
// la fattura 3 e' suddivisa in 5 rate (20.000 + 40.000 + 80.000 + 160.000 + 320.000)
// la fattura 4 e' suddivisa in 3 rate (50.000 + 100.000 + 150.000)
// Il numero di effetti generati equivale al massimo numero di rate (5 in questo caso)
// quindi avremo 5 effetti:
// il primo avra' 4 righe (prima rata di tutte le fatture)
// il secondo avra' 4 righe (seconda rata di tutte le fatture)
// il terzo avra' 3 righe (terza rata delle fatture 2,3,4)
// il quarto avra' 2 righe (quarta rata delle fatture 2 e 3)
// il quinto avra' 1 riga (quinta rata della fattura 3)
// La testata di ogni effetto conterra' il totale (somma) dei singoli importi delle righe
// ovvero:
// tot. primo effetto: 95.000
// tot. secondo effetto: 190.000
// tot. terzo effetto: 255.000
// tot. quarto effetto: 190.000
// tot. quinto effetto: 320.000
// I dati della testata (soprattutto la data di scadenza) di ogni effetto vengono presi dal
// primo documento valido per la generazione dell'effetto corrente:
// per i primi due effetti vale la fattura 1
// per gli effetti 3 e 4 vale la fattura 2
// per l'effetto 5 vale la fattura 3.
// Questo e' quanto ho appreso (Hope I'm right...) ;-)
void TGenerazioneEffetti_app::add_to_group_list(TDocumento* doc)
{
TString key;
TToken_string t("",'$');
build_group_key(key,doc);
build_doc_key(t,doc);
const bool is_key = _group_array.is_key(key);
TToken_string tt(is_key ? (TToken_string&) _group_array[key]: "");
tt.add(t);
_group_array.add(key,tt, is_key ? TRUE : FALSE);
}
void TGenerazioneEffetti_app::build_group_key(TString& key, TDocumento* doc)
{
const long cli = doc->get_long(DOC_CODCF);
TString16 val;
if (doc->in_valuta())
val = doc->get(DOC_CODVAL);
// campi obbligatori
key.format("%7ld%3s",cli,(const char*)val);
// campi opzionali
if (_group_by_date)
{
TString16 d(doc->get(DOC_DATAINSC));
if (d.empty())
d = doc->get(DOC_DATADOC);
key << d;
}
// Qual'e' il flag di sospensione d'imposta del documento ??
// if (_group_by_sosp)
// key << _doc->get(DOC_????);
if (_group_by_change)
key << doc->get(DOC_CAMBIO);
if (_group_by_pag)
key << doc->get(DOC_CODPAG);
if (_group_by_bank)
{
key << doc->get(DOC_CODABIA); // banca cliente
key << doc->get(DOC_CODCABA);
}
if (_group_by_type)
key << doc->get(DOC_TIPODOC);
if (_group_by_num)
key << doc->get(DOC_CODNUM);
if (_group_by_agent)
key << doc->get(DOC_CODAG);
}
void TGenerazioneEffetti_app::build_doc_key(TToken_string& key, TDocumento* doc)
{
key.add(doc->get(DOC_PROVV));
key.add(doc->get(DOC_ANNO));
key.add(doc->get(DOC_CODNUM));
key.add(doc->get(DOC_NDOC));
}
void TGenerazioneEffetti_app::set_options()
{
const TRectype& eld = cache().get("%ELD", _cod_el);
if (!eld.empty())
{
TString s1;
s1.format("%-20s",(const char*)eld.get("S1")); // Forzo la sua lunghezza a 20 per evitare subscript errors
_group_by_date = s1[12] == 'X';
_group_by_sosp = s1[13] == 'X';
_group_by_change = s1[0] == 'X';
_group_by_pag = s1[4] == 'X';
_group_by_bank = s1[5] == 'X';
_group_by_type = s1[2] == 'X';
_group_by_num = s1[3] == 'X';
_group_by_agent = s1[7] == 'X';
}
}
void TGenerazioneEffetti_app::generate()
{
TRelation doc_rel(LF_DOC);
const long items = _num_sheet->items();
long tot = 0L;
TGenerazione_effetti gen_eff(_cod_el);
TDate data;
_group_array.destroy();
set_options();
const bool sort_by_date = _msk->get_int(F_ORDERBY) == 0;
for (long i=0L; i<items;i++) // Scorre per tutte le numerazioni dello sheet
{
const TString8 codnum = _num_sheet->row(i).get(1);
// Controlla se la numerazione corrente e' stata selezionata
bool is_selected = _num_sheet->row_enabled(i);
if (is_selected)
{
if (sort_by_date)
is_selected = _num_sheet->checked(i);
else
is_selected = _msk->get(F_CODNUM) == codnum;
}
if (!is_selected)
continue;
TString filt_expr;
int cursor_key = 0;
TRectype da(LF_DOC), a(LF_DOC);
da.put(DOC_PROVV,"D");
a.put(DOC_PROVV,"D");
if (sort_by_date)
{
cursor_key = 3;
const TDate dataini = _msk->get_date(F_DATA_INI);
da.put(DOC_ANNO,dataini.year());
da.put(DOC_DATADOC,dataini);
const TDate datafin = _msk->get_date(F_DATA_FIN);
a.put(DOC_ANNO,datafin.year());
a.put(DOC_DATADOC,datafin);
filt_expr << DOC_CODNUM << "=\"" << codnum << "\"";
}
else
{
cursor_key = 1;
da.put(DOC_ANNO, _msk->get(F_ANNO));
da.put(DOC_CODNUM, codnum);
da.put(DOC_NDOC, _msk->get(F_NDOC_INI));
a.put(DOC_ANNO, _msk->get(F_ANNO));
a.put(DOC_CODNUM, codnum);
a.put(DOC_NDOC, _msk->get(F_NDOC_FIN));
}
TCursor doc_cur(&doc_rel, filt_expr, cursor_key, &da, &a);
const long cur_items = doc_cur.items(); // Scorre tutti i documenti che rientrano nell'intervallo selezionato
if (cur_items == 0)
{
warning_box("Non vi sono effetti da generare per il codice numerazione %s",(const char*)codnum);
continue;
}
TString msg;
msg << "Selezione documenti " << codnum;
if (sort_by_date)
{
msg << " dal " << _msk->get(F_DATA_INI);
msg << " al " << _msk->get(F_DATA_FIN);
}
else
{
msg << " dal " << _msk->get(F_NDOC_INI);
msg << " al " << _msk->get(F_NDOC_FIN);
}
TProgind p(cur_items,msg,FALSE,TRUE);
long j = 0;
// Comportamento:
// - scorre i documenti della numerazione corrente.
// - se e' possibile generare subito l'effetto (tipo di pagamento valido,
// stato documento valido e non e' abilitato il raggruppamento) lo fa,
// altrimenti compone una lista dei documenti da raggruppare
// - alla fine del ciclo per numerazioni scorre la lista residua e genera gli
// effetti rimasti
for (;j<cur_items;j++)
{
p.setstatus(j+1);
doc_cur = j;
TDocumento* doc = new TDocumento;
if (doc->read(doc_cur.curr()) == NOERR && // legge il documento
codnum == doc->get(DOC_CODNUM) && // patch del cazzo
doc_tipo_stato_ok(doc)) // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
{
TPagamento & pag = doc->pagamento();
if (pag.code().not_empty())
{
const bool raggruppabile = doc->get_bool(DOC_RAGGREFF);
if (!_raggruppa || (_raggruppa && !raggruppabile))
{
// Aggiunge alla lista degli effetti da generare singolarmente
TLista_documenti lista_in,lista_out;
lista_in.add(doc);
if (!gen_eff.elabora(lista_in,lista_out,data)) // La data non serve, cosi' come la lista documenti in uscita
gen_eff.set_writeable(FALSE);
tot += gen_eff.bills();
}
else
{
add_to_group_list(doc); // Aggiorna la lista degli effetti da raggruppare
delete doc;
}
}
else
{
int err = change_doc_status(doc); // Cambia lo stato al documento
if (err != NOERR)
warning_box("Errore %d tentando di cambiare lo stato del documento %s/%d",err,(const char*)doc->numerazione(),doc->numero());
delete doc;
}
}
else
delete doc;
}
}
// Ogni elemento di _group_array <20> una TToken_string. Ogni elemento della TToken_string contiene
// la chiave per identificare il documento che fa parte di quel raggruppamento
tot += gen_eff.group_bills(_group_array);// Setta l'elenco dei documenti per generare effetti raggruppati
if (tot > 0L)
message_box("Totale effetti generati: %ld", tot);
xvt_statbar_set("");
}
int ve6300 (int argc, char **argv)
{
TGenerazioneEffetti_app a;
a.run(argc,argv,"Generazione effetti");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink