From a4b9a8e833e47f41777af5b85c92833573a9b787 Mon Sep 17 00:00:00 2001 From: angelo Date: Fri, 23 Aug 1996 07:14:32 +0000 Subject: [PATCH] Terminato lo sviluppo. Ora inizia il debug. git-svn-id: svn://10.65.10.50/trunk@3428 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- ve/ve6100.cpp | 1584 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1582 insertions(+), 2 deletions(-) diff --git a/ve/ve6100.cpp b/ve/ve6100.cpp index fb9313687..bf6a0c672 100755 --- a/ve/ve6100.cpp +++ b/ve/ve6100.cpp @@ -1,7 +1,1587 @@ -// ve6100.cpp: ex-modulo per la gestione della tabella elaborazioni differite. +// ve6100.cpp: programma di contabilizzazione documenti +// Orgiastica visione... +// L'anatra del dubbio dalle labbra di Vermouth. +//****************************************************************************** +// \\\\\\\\ e * +// b \\\\\\\\ b * +// \\\\\\\\ e r d l * +// \\\\\\\\ * +// \\\\\\\\ i V o e h * +// L \\\\\\\\ * +// \\\\\\\\ b d * +// o \\\\\\\\ m a * +// +++++++++++++++++++++++++ b t * +// ++++++++++++++++++++++++++--------------------------------------------------| +// ++++++++++++++++++++++++++--------------------------------------------------| +// ++++++++++++++++++++++++ |---------------------------------------| +// u //////// u |---------------------------------------| +// ' //////// a | /\ /\ | +// //////// i | r / \ r / \ | +// a //////// \|/ / \ / \ l | +// ////////-----------------*---\ a / t \ / a \ /| +// //////// /|\ \ / \ / \ / | +// d //////// n | \ / \ / \ / | +// //////// l d | \/ a \/ l \/ | +//-----------------------------------------------------------------------------| +// +// Scared uh? +#include +#include +#include +#include +#include +#include +#include +#include +#include "../cg/cg2101.h" +#include "../cg/cglib.h" +#include "../cg/saldacon.h" +#include "velib02.h" +#include "ve6100a.h" + +#include +#include +#include +#include +#include +#include + +enum error_type { + no_error, + elaboration_error, + nr_es_error, + nr_reg_error, + nr_doc_error, + chg_stat_error, + clifo_error, + ultprot_error, + datadoc_error, + caus_error, + register_error, + change_error, + codpag_error, + row_type_error, + conto_error, + movement_error, + mov_write_error, + generic_error +}; + +// TMovimentoPN_VE +// Classe derivata da TMovimentoPN per calcolare automaticamente le righe contabili +// una volta settate le righe iva e la riga di totale documento +// Sostanzialmente di tratta di aggiungere un metodo in piu' : +// recalc_cg_rows(), liberamente ispirato alla notify_iva() in cg2102.cpp + +class TMovimentoPN_VE : public TMovimentoPN +{ +protected: + // simula il K_SPACE di iva_notify + void create_row(TCausale& caus, int i); + // simula il K_ENTER di iva_notify + void enter_row(TCausale& caus, int i); + // verifica se si tratta di iva indetraibile + bool detraibile(TCausale& caus, TRectype& rec) const ; + // cerca la prima tra quelle di contabilita' che corrisponde al tipo indicato + int type2pos(char tipo); + // Trova nelle righe contabili un conto nelle righe di tipo prescelto + int bill2pos(const TBill& conto, char tipo); + // trasforma un real in TImporto, in base al tipo riga + TImporto real2imp(TCausale& caus, const real& r, char row_type); + // setta il record delle righe di contabilita' + int set_cg_rec(int n, const TImporto& imp, TBill& conto, const char* desc, char tipo); + // aggiunge l'importo indicato alla n-esima riga di contabilita' + bool add_cg_rec(int n, const TImporto& imp); + // Legge l'importo della riga n e lo ritorna col segno dovuto + TImporto get_cg_imp(int n); + // Setta l'importo della riga n + void set_cg_imp(int n, const TImporto& imp); +public: + // verifica se il movimento e' quadrato oppure ha qualche maledetto sbilancio + // ritorna TRUE, ovviamente, se everything's alright. + bool movement_ok() ; + // ricalcola le righe di contabilita' dalle righe iva presenti + // e verifica la quadratura del movimento. Ritorna TRUE se il movimento e' scrivibile + bool recalc_cg_rows(); +}; + +TImporto TMovimentoPN_VE::real2imp(TCausale& caus, const real& r, char row_type) +{ + bool dare; + if (row_type == 'S') + { + dare = caus.sezione_ritsoc() == 'D'; + } + else + { + dare = caus.sezione_clifo() == 'D'; + if (row_type != 'T' && row_type != 'F') + dare = !dare; + } + + TImporto importo(dare ? 'D' : 'A', r); + return importo; +} + +bool TMovimentoPN_VE::detraibile(TCausale& caus, TRectype& rec) const +{ + if (caus.iva() == iva_vendite) + return TRUE; + + if (rec.get_int(RMI_TIPODET) != 0) + return FALSE; + + const real & p = caus.reg().prorata(); + return p < 100.0; +} + +int TMovimentoPN_VE::bill2pos(const TBill& conto, char tipo) +{ + const int items = cg_items(); + for (int i = 0; i < items; i++) + { + TRectype& s = cg(i); + const char t = s.get_char(RMV_ROWTYPE); + if (t == tipo) + { + TBill c; + const int gr = s.get_int(RMV_GRUPPO); + const int co = s.get_int(RMV_CONTO); + const long so = s.get_long(RMV_SOTTOCONTO); + c.set(gr,co,so); + if (c == conto) + return i; + } + } + return -1; +} + +int TMovimentoPN_VE::type2pos(char tipo) +{ + const int items = cg_items(); + for (int i = 0; i < items; i++) + { + TRectype& s = cg(i); + const char t = s.get_char(RMV_ROWTYPE); + if (t == tipo) + return i; + } + return -1; +} + +void TMovimentoPN_VE::set_cg_imp(int n, const TImporto& imp) +{ + TRectype& rec = cg(n); + rec.put(RMV_SEZIONE,imp.sezione()); + rec.put(RMV_IMPORTO,imp.valore()); +} + +TImporto TMovimentoPN_VE::get_cg_imp(int n) +{ + TRectype& rec = cg(n); + TImporto importo; + const char sez = rec.get_char(RMV_SEZIONE); + const real valore(rec.get_real(RMV_IMPORTO)); + importo.set(sez,valore); + return importo; +} + +bool TMovimentoPN_VE::add_cg_rec(int n, const TImporto& imp) +{ + TImporto tot(get_cg_imp(n)); + tot += imp; + tot.normalize(); + set_cg_imp(n, tot); + return tot.is_zero(); +} + +int TMovimentoPN_VE::set_cg_rec(int n, const TImporto& imp, TBill& conto, + const char* desc, char tipo) +{ + const bool insert = n < 0; + if (insert) n = cg_items(); // Questa e' la prima riga di contabilita' vuota e disponibile + TRectype& rec = cg(n); + + if (insert) + { + TRectype& head = lfile().curr(); + const int annoes = head.get_int(MOV_ANNOES); + const long numreg = head.get_long(MOV_NUMREG); + TDate datareg(head.get_date(MOV_DATAREG)); + rec.put(RMV_ANNOES,annoes); + rec.put(RMV_NUMREG,numreg); + rec.put(RMV_DATAREG,datareg); + } + rec.put(RMV_SEZIONE,imp.sezione()); + rec.put(RMV_IMPORTO,imp.valore()); + rec.put(RMV_TIPOC,conto.tipo()); + rec.put(RMV_GRUPPO,conto.gruppo()); + rec.put(RMV_CONTO,conto.conto()); + rec.put(RMV_SOTTOCONTO,conto.sottoconto()); + rec.put(RMV_DESCR,conto.descrizione()); + + if (tipo == 'T') // Calcolo contropartita + { + TRectype& irec = iva(0); + const char t = irec.get_char(RMI_TIPOC); + const int gr = irec.get_int(RMI_GRUPPO); + const int co = irec.get_int(RMI_CONTO); + const long so = irec.get_long(RMI_SOTTOCONTO); + rec.put(RMV_TIPOCC,t); + rec.put(RMV_GRUPPOC,gr); + rec.put(RMV_CONTOC,co); + rec.put(RMV_SOTTOCONTOC,so); + } + else + { + const int pos = type2pos('T'); + if (pos >= 0) + { + TRectype& crec = cg(pos); + const char t = crec.get_char(RMV_TIPOC); + const int gr = crec.get_int(RMV_GRUPPO); + const int co = crec.get_int(RMV_CONTO); + const long so = crec.get_long(RMV_SOTTOCONTO); + rec.put(RMV_TIPOCC,t); + rec.put(RMV_GRUPPOC,gr); + rec.put(RMV_CONTOC,co); + rec.put(RMV_SOTTOCONTOC,so); + } + } + + rec.put(RMV_ROWTYPE,tipo); + return n; +} + +void TMovimentoPN_VE::create_row(TCausale& caus, int i) +{ + TRectype& cur = iva(i); + real oldimp = cur.get_real(RMI_IMPONIBILE); + real oldiva = cur.get_real(RMI_IMPOSTA); + + if (oldiva.is_zero() && caus.corrispettivi()) // In caso di corrispettivi ... + { + const TString zanicchi(cur.get(RMI_CODIVA)); // Codice IVA + const TCodiceIVA i(zanicchi); + oldiva = i.scorpora(oldimp); // ... scorpora imposta dall'imponibile + } + + const char tipod = detraibile(caus,cur) ? 'D' : 'N'; + + if (type2pos(tipod) < 0 && !oldiva.is_zero()) + { + const int ri = tipod == 'D' ? 3 : 4; // Calcola riga causale per l'IVA + TBill c; caus.bill(ri, c); + if (c.ok()) + { + const TString80 d(caus.desc_agg(ri)); + set_cg_rec(-1, real2imp(caus, ZERO, 'I'), c, d, tipod); + } + else + if (ri == 4) // Se non esiste il conto IVA indetraibile ... + { // ... somma imponibile e imposta + oldimp += oldiva; + oldiva = 0.0; + } + } + + TBill oldconto; + const int gr = cur.get_int(RMI_GRUPPO); + const int co = cur.get_int(RMI_CONTO); + const long so = cur.get_long(RMI_SOTTOCONTO); + oldconto.set(gr,co,so); + if (oldconto.ok()) + { + if (bill2pos(oldconto, 'I') < 0) + { + const TString d(caus.desc_agg(2)); + set_cg_rec(-1, real2imp(caus, ZERO, 'I'), oldconto, d, 'I'); + } + } +} + +void TMovimentoPN_VE::enter_row(TCausale& caus, int i) +{ + TRectype& cur = iva(i); + real imponibile = cur.get_real(RMI_IMPONIBILE); + real imposta = cur.get_real(RMI_IMPOSTA); + + if (imposta.is_zero() && caus.corrispettivi()) // In caso di corrispettivi ... + { + const TString zanicchi(cur.get(RMI_CODIVA)); + const TCodiceIVA i(zanicchi); + imposta = i.scorpora(imponibile); // ... scorpora imposta dall'imponibile + } + + TBill conto; + const char t = cur.get_char(RMI_TIPOC); + const int gr = cur.get_int(RMI_GRUPPO); + const int co = cur.get_int(RMI_CONTO); + const long so = cur.get_long(RMI_SOTTOCONTO); + conto.set(gr,co,so,t); + + int newpos = bill2pos(conto, 'I'); // Riga in cui andra' l'imponibile + + const bool detrarre = detraibile(caus,cur); // Determina se IVA detraibile + + // Calcola riga causale col conto opportuno + const int ri = detrarre ? RIGA_IVA_DETRAIBILE : RIGA_IVA_NON_DETRAIBILE; + TBill contoiva; caus.bill(ri, contoiva); + + if (ri == 4 && !contoiva.ok()) // Se non c'e' il conto IVA indetraibile ... + { // ... somma imponibile e imposta + imponibile += imposta; + imposta = 0.0; + } + + // Aggiorna conto sulla riga contabile + if (newpos < 0) // conto non esistente: da inserire + { + const TImporto val(real2imp(caus,imponibile, 'I')); + if (conto.ok() && !val.is_zero()) // Se c'e' imponibile ... + { // crea una nuova riga contabile + const TString d(caus.desc_agg(2)); + set_cg_rec(-1, val, conto, d, 'I'); + } + } + else + { + TImporto val(real2imp(caus,imponibile, 'I')); + add_cg_rec(newpos, val); + } + + // Aggiorna conto IVA sulla riga contabile + + const char tipod = detrarre ? 'D' : 'N'; + int newposiva = type2pos(tipod); + + if (newposiva < 0) + { + if (!imposta.is_zero()) // Se c'e' imposta ... + { // ... crea nuova riga per l'IVA + const TImporto val(real2imp(caus,imposta, 'I')); + const TString d(caus.desc_agg(ri)); + set_cg_rec(-1, val, contoiva, d, tipod); + } + } + else + { + const TImporto val(real2imp(caus,imposta, 'I')); + add_cg_rec(newposiva, val); + } +} + +bool TMovimentoPN_VE::movement_ok() +{ + TImporto tot_imp; + TImporto imp; + + const int max = cg_items(); + for (int i = 0; i < max; i++) + { + TRectype& r = cg(i); + const char sez = r.get_char(RMV_SEZIONE); + const real val(r.get_real(RMV_IMPORTO)); + imp.set(sez,val); + tot_imp+=imp; + } + + if (!tot_imp.is_zero()) + return FALSE; + return TRUE; +} + +bool TMovimentoPN_VE::recalc_cg_rows() +{ + const int righe = iva_items(); + TRectype& head = lfile().curr(); + TString16 codcau(head.get(MOV_CODCAUS)); + int year = head.get_int(MOV_ANNOIVA); + TCausale caus(codcau,year); + for (int i=0; i 15) + { + f.error_box("L'intervallo tra le date non puo' eccedere i 15 giorni."); + return FALSE; + } + } + return TRUE; +} + +bool TContabilizzazione_app::handle_data_reg(TMask_field& f, KEY k) +{ + if (f.to_check(k)) + { + TMask& m = f.mask(); + + TDate data_reg(f.get()); + if (data_reg == botime) return TRUE; + TDate da(m.get_date(F_DATA_INI)); + if ((data_reg - da) > 15) + { + f.error_box("L'intervallo tra la data di registrazione e la data di inizio non puo' eccedere i 15 giorni."); + return FALSE; + } + if (data_reg < da) + { + f.error_box("La data di registrazione non puo' essere minore della data di inizio."); + return FALSE; + } + } + return TRUE; +} + +bool TContabilizzazione_app::handle_cod_eld(TMask_field& f, KEY k) +{ + 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() + f.mask().disable(DLG_OK); + app().build_num_sheet(); + } + return TRUE; +} + +bool TContabilizzazione_app::handle_select(TMask_field& f, KEY k) +{ + if (k == K_SPACE) + { + TMask& m = f.mask(); + TArray_sheet* s = app().get_num_sheet(); + if (s->run()) + { + if (s->checked() != 0) // Hai selezionato qualcosa ? + m.enable(DLG_OK); // allora abilita il pulsante di conferma + else + m.disable(DLG_OK); + } + } + return TRUE; +} + +void TContabilizzazione_app::build_num_sheet() +{ + _num_sheet->destroy(); + + TTable eld("%ELD"); + TTable num("%NUM"); + TString s1,s2,s3; + TString16 tipon1,tipon2,tipon3,tipon4,tipon5; // tipi documento validi per la numerazione + long pos; + + eld.put("CODTAB",_cod_el); + if (eld.read() == NOERR) + { + TToken_string t; + s1.format("%-20s",(const char*)eld.get("S2")); + s3 = eld.get("S7"); + _final_doc_status = eld.get("S4")[0]; + for (int i=0;i<5;i++) + { + t = s1.mid(i*4,4); // Tipo documento + if (t.trim().empty()) break; + t.add(s3.mid(i,1)); // Stato iniziale + _tipi_doc.add(t); // Aggiunge questo tipo documento alla lista + } + for (pos=0,num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili + { + TToken_string t; + t.add(" "); + t.add(num.get("CODTAB")); + t.add(num.get("S0")); + _num_sheet->add(t); + s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione + tipon1 = s2.mid(0,4); + tipon2 = s2.mid(4,4); + tipon3 = s2.mid(8,4); + tipon4 = s2.mid(12,4); + tipon5 = s2.mid(16,4); + const int n1 = s1.find(tipon1); + const int n2 = s1.find(tipon2); + const int n3 = s1.find(tipon3); + const int n4 = s1.find(tipon4); + const int n5 = s1.find(tipon5); + if ((tipon1.empty() || n1<0) && (tipon2.empty() || n2<0) && + (tipon3.empty() || n3<0) && (tipon4.empty() || n4<0) && + (tipon5.empty() || n5<0)) + _num_sheet->disable_row(pos); + } + } +} + +void TContabilizzazione_app::on_config_change() +{ + TPartita::carica_allineamento(); +} + +bool TContabilizzazione_app::create() +{ + TApplication::create(); + if (!has_module(CGAUT)) + { + error_box("Impossibile eseguire il programma se il modulo Contabilita' Generale non e' abilitato"); + return FALSE; + } + _error = no_error; + _can_write = TRUE; + _caus = NULL; + _pagamento = NULL; + _movimento = NULL; + _msk = new TMask("ve6100a"); + _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_DATA_REG,handle_data_reg); + _msk->set_handler(DLG_USER,handle_select); + _num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione", + "@1|Cod. numerazione|Descrizione@50"); + _doc = new TDocumentoEsteso; + _cpg = new TTable("%CPG"); + _tri = new TTable("%TRI"); + _caa = new TTable("CAA"); + _cra = new TTable("CRA"); + _gmc = new TTable("GMC"); + _rfa = new TTable("RFA"); + _cve = new TTable("CVE"); + _cco = new TTable("CCO"); + _clifo = new TLocalisamfile(LF_CLIFO); + _anamag = new TLocalisamfile(LF_ANAMAG); + TConfig conf(CONFIG_DITTA); + TString val; + + // costruisce la stringa che controlla la ricerca del conto costo/ricavo + // Attenzione! non esegue alcun controllo di consistenza sulla corretta sequenza + // presuppone che il programma di configurazione abbia generato correttamente + // il tutto. + for (int i=0; i<8;i++) + { + val = conf.get("RICERCACR","ve",i+1); + if (val.not_empty()) _search_seq.add(val); + } + + if (_search_seq.items() == 0) + { + error_box("Non e' abilitata alcuna ricerca per il conto di costo/ricavo in configurazione."); + return FALSE; + } + _sc_enabled = conf.get_bool("GesSal","cg"); + _nump_cfg = conf.get_bool("RifPro","cg"); + dispatch_e_menu(BAR_ITEM(1)); + return TRUE; +} + +bool TContabilizzazione_app::destroy() +{ + if (_msk) delete _msk; + if (_num_sheet) delete _num_sheet; + if (_doc) delete _doc; + if (_cpg) delete _cpg; + if (_tri) delete _tri; + if (_gmc) delete _gmc; + if (_rfa) delete _rfa; + if (_cve) delete _cve; + if (_cco) delete _cco; + if (_caa) delete _caa; + if (_cra) delete _cra; + if (_clifo) delete _clifo; + if (_anamag) delete _anamag; + return TApplication::destroy(); +} + +bool TContabilizzazione_app::menu(MENU_TAG mt) +{ + while (_msk->run() == K_ENTER) + { + _cod_el = _msk->get(F_CODICE_ELAB); + _data_ini = _msk->get_date(F_DATA_INI); + _data_fine = _msk->get_date(F_DATA_FIN); + _data_reg = _msk->get_date(F_DATA_REG); + _auto_data = _msk->get_bool(F_DATA_AUTO); + contabilize(); + } + return FALSE; +} + +error_type TContabilizzazione_app::search_costo_ricavo(TBill& conto, const TRiga_documento& r) +{ + const int items = _search_seq.items(); + const TString tipocf(_doc->get("TIPOCF")); + const bool is_cli = tipocf == "C"; + const long codcf = _doc->get_long("CODCF"); + bool skip_art_related = FALSE; + bool skip_clifo = FALSE; + TCodiceIVA codiva(r.get("CODIVA")); + int gr,co; + long so; + + // posiziona l'anagrafica sull'articolo specificato sulla ..iga + _anamag->put("CODART",r.get("CODART")); + if (_anamag->read() != NOERR) // se non trova l'articolo saltera' anche gmc,smc,rfa. + skip_art_related = TRUE; + + _clifo->put(CLI_TIPOCF,tipocf); + _clifo->put(CLI_CODCF,codcf); + if (_clifo->read() != NOERR) + skip_clifo = TRUE; + + // Scorre la stringa di ricerca + for (int i=0;good() && iget_int(CLI_GRUPPORIC); + co = _clifo->get_int(CLI_CONTORIC); + so = _clifo->get_long(CLI_SOTTOCRIC); + conto.set(gr,co,so); + if (conto.ok()) break; // se lo trova esce (tutti != 0) + } + else + if (tok == "CA") + { + CHECK(_caus,"Orgggssbb..._caus pointer is NULL!"); + if (_caus->IVA2bill(codiva,conto)) break; // se lo trova esce + } + else + if (tok == "AR") + { + if (skip_art_related) continue; + gr = _anamag->get_int(is_cli ? "GRUPPOV" : "GRUPPOA"); + co = _anamag->get_int(is_cli ? "CONTOV" : "CONTOA"); + so = _anamag->get_long(is_cli ? "SOTTOCV" : "SOTTOCA"); + conto.set(gr,co,so); + if (!conto.ok()) // se il conto non c'e' guarda la categoria acquisti/vendite + { + TTable *t = is_cli ? _cra : _caa; + + t->put("CODTAB",_anamag->get(is_cli ? "CATCONV" : "CATCONA")); + if (t->read() == NOERR) + { + gr = atoi(t->get("S1")); + co = atoi(t->get("S2")); + so = atol(t->get("S3")); + conto.set(gr,co,so); + } + } + if (conto.ok()) break; + } + else + if (tok == "GM" || tok == "SM" || tok == "RF") + { + if (skip_art_related) continue; + const bool is_fis = tok == "RF"; + TTable * tab = is_fis ? _rfa : _gmc; + TString codtab(_anamag->get(is_fis ? "GRMERC" : "RAGGFIS")); + if (tok == "GM") + codtab.cut(2); // gli ultimi 2 si riferiscono al sottogruppo. + tab->put("CODTAB",codtab); + if (tab->read() == NOERR) + { + gr = tab->get_int(is_cli ? "I3" : "I0"); + co = tab->get_int(is_cli ? "I4" : "I1"); + so = tab->get_long(is_cli ? "I5" : "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) break; + } + else + if (tok == "CV" || tok == "CC") + { + const bool is_cve = tok == "CV"; + if (is_cve && !is_cli) continue; // se e' un fornitore salta questa condizione + TTable* t = is_cve ? _cve : _cco; + TString cod(is_cve ? _doc->get("CATVEN") : "CATCO"); + if (cod.empty()) + { + if (skip_clifo) continue; // se non aveva trovato il cliente salta al prossimo + cod = _clifo->get(is_cve ? CLI_CATVEN : CLI_CODCATC); + } + t->put("CODTAB",cod); + if (t->read() == NOERR) + { + const bool x =(is_cve || is_cli); + gr = t->get_int(x ? "I3" : "I0"); + co = t->get_int(x ? "I4" : "I1"); + so = t->get_long(x ? "I5": "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) break; + } + } + if (good() && !conto.find()) + _error = conto_error; + return _error; +} + +bool TContabilizzazione_app::doc_tipo_stato_ok() +// 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;isaldaconto(); + return rt; +} + +error_type TContabilizzazione_app::compile_head_mov() +// Compila la testata +{ + TEsercizi_contabili esc; + TLocalisamfile& mov = _movimento->lfile(); + TRectype& mov_rec = mov.curr(); + + // Reperisce la data documento + TDate datadoc(_doc->data()); + if (!datadoc.ok()) + { + _error = datadoc_error; + return _error; + } + + // reperisce la data di registrazione, che e' anche la data di competenza ed + // eventualmente la data74ter se nel registro della causale vi e' scritta l'informazione + // sulle agenzie di viaggio. + // se si e' specificata la data automatica prende invece la data del documento + TDate data_reg(_auto_data ? datadoc : _data_reg); + + esc.update(); + // reperisce il codice anno esercizio, + int cod_es = esc.date2esc(data_reg); + if (cod_es <= 0) + { + _error = nr_es_error; + return _error; + } + + // reperisce l'ultimo numero di registrazione disponibile + mov.last(); + int numreg = mov.get_int(MOV_NUMREG) + 1; + if (mov.status() != NOERR || numreg < 1) + { + _error = nr_reg_error; + return _error; + } + + TCodice_numerazione cod_num(_doc->numerazione()); + TString numdoc; + // calcola il numero documento aggiungendo l'eventuale prefisso/postfisso. + numdoc = cod_num.complete_num(_doc->numero()); + if (numdoc.empty() || cod_num.status() != NOERR) + { + _error = nr_doc_error; + return _error; + } + + // Istanzia la causale del documento corrente... + const TTipo_documento& tipo = _doc->tipo(); + _caus = new TCausale(tipo.causale(),data_reg.year()); + if (!_caus->ok()) + { + _error = caus_error; + return _error; + } + // per reperire il tipo documento ed il tipo movimento + + // reperisce la descrizione dal tipo documento e la completa con la data documento ed il + // numero documento + TString descr(tipo.riferimento()); + if (descr.empty()) descr = tipo.descrizione(); + descr << " n. " << _doc->numero(); + descr << " del " << datadoc.string(); + + // Codice registro IVA + TRegistro& registro = _caus->reg(); + if (!registro.ok()) + { + _error = register_error; + return _error; + } + + // Reperisce l'ultimo numero di protocollo + long ult_prot = registro.protocol() +1; + if (ult_prot < 1) + { + _error = ultprot_error; + return _error; + } + + // Reperisce la valuta + TDate datacam(_doc->get_date("DATACAMBIO")); + TString codval(_doc->valuta()); + codval.trim(); + // Reperisce il cambio + real cambio(_doc->cambio()); + if (cambio != 1.0 && codval.empty()) + { + _error = change_error; + return _error; + } + + // Dati del cliente... + TString tipocf(_doc->get("TIPOCF")); + long codcf = _doc->get_long("CODCF"); + TString occas; + { + _clifo->put(CLI_TIPOCF,tipocf); _clifo->put(CLI_CODCF,codcf); + if (_clifo->read() == NOERR) + { + if (_clifo->get_bool(CLI_OCCAS)) + { + occas = _doc->get("OCFPI"); + TLocalisamfile ocf(LF_OCCAS); + ocf.put(OCC_CFPI,occas); + if (ocf.read() != NOERR) + { + _error = clifo_error; + return _error; + } + } + } + else + { + _error = clifo_error; + return _error; + } + } + + // Codice pagamento + TString codpag(_doc->get("CODPAG")); + { + _cpg->put("CODTAB",codpag); + if (_cpg->read() != NOERR) + { + _error = codpag_error; + return _error; + } + } + + // Mo' riempie il record della incornata (testata) + mov_rec.zero(); + mov_rec.put(MOV_ANNOES,cod_es); mov_rec.put(MOV_NUMREG,numreg); + mov_rec.put(MOV_DATAREG,data_reg); mov_rec.put(MOV_DATACOMP,data_reg); + mov_rec.put(MOV_DATADOC,datadoc); + if (registro.agenzia_viaggi()) mov_rec.put(MOV_DATA74TER,data_reg); + mov_rec.put(MOV_NUMDOC,numdoc); mov_rec.put(MOV_TIPODOC,_caus->tipo_doc()); + mov_rec.put(MOV_CODCAUS,_caus->codice()); mov_rec.put(MOV_DESCR,descr); + mov_rec.put(MOV_TIPOMOV,_caus->tipomov()); mov_rec.put(MOV_ANNOIVA,data_reg.year()); + mov_rec.put(MOV_PROTIVA,ult_prot); mov_rec.put(MOV_CODVAL,codval); + mov_rec.put(MOV_CAMBIO,cambio); mov_rec.put(MOV_TIPO,tipocf); + mov_rec.put(MOV_DATACAM,datacam); + mov_rec.put(MOV_CODCF,codcf); mov_rec.put(MOV_OCFPI,occas); + mov_rec.put(MOV_CODPAG,codpag); + if (_caus->intra()) + { + mov_rec.put(MOV_CODVALI,codval);mov_rec.put(MOV_CAMBIOI,cambio); + real corrval(_doc->tot_imponibili(1)); + real corrlire = corrval*cambio; + if (codval.not_empty() && codval != "LIT") + { + mov_rec.put(MOV_CORRLIRE,corrlire); + mov_rec.put(MOV_CORRVALUTA,corrval); + } else + mov_rec.put(MOV_CORRLIRE,corrval); + } + real totdocval(_doc->tot_documento()); + real totdoclit = totdocval * cambio; + if (codval.not_empty() && codval != "LIT") + { + mov_rec.put(MOV_TOTDOC,totdoclit); + mov_rec.put(MOV_TOTDOCVAL,totdocval); + } else + mov_rec.put(MOV_TOTDOC,totdocval); + return _error; +} + +error_type TContabilizzazione_app::add_iva_row(const TBill& conto, TRiepilogo_Iva& ri) +// Aggiunge le righe iva all'assoc_array di raggruppamento +{ + TIVA_element el_tmp; + TString cod(ri.cod()); + const char tipo = conto.tipo(); + const int gr = conto.gruppo(); + const int co = conto.conto(); + const long so = conto.sottoconto(); + TString key; + key.format("%-4s|%c|%3d|%3d|%6ld",(const char*)cod,tipo,gr,co,so); + const bool exists = _righe_iva.is_key(key); + TIVA_element& el = (exists ? (TIVA_element&)_righe_iva[key] : el_tmp); + el += ri; + _righe_iva.add(key,el,exists); + return no_error; +} + +error_type TContabilizzazione_app::create_iva_rows() +{ + const int items = _righe_iva.items(); + const bool in_valuta = _doc->in_valuta(); + TIVA_element* cur = (TIVA_element*)_righe_iva.first_item(); + TRectype& head = _movimento->lfile().curr(); + int gr,co; + long so; + char tipo; + TToken_string key; + TString16 codiva; + TBill conto; + + int annoes = head.get_int(MOV_ANNOES); + long numreg = head.get_long(MOV_NUMREG); + real cambio = 1.0; + real imponibile,imposta; + if (in_valuta) cambio = head.get_real(MOV_CAMBIO); + + for (int i = 0; ikey(); + codiva = key.get(0); + tipo = key.get_char(1); + gr = key.get_int(2); + co = key.get_int(3); + so = atol(key.get(4)); + conto.set(gr,co,so,tipo); + imponibile = cur->imp(); + if (in_valuta) + { + imponibile = cur->imp() * cambio; // imponibile in lire + imposta = (imponibile * cur->ali()) / 100.0; // questa e' l'imposta ricalcolata + } + else + imposta = cur->iva(); + // In contabilita' abbiamo 2 decimali... + imponibile.ceil(2); + imposta.ceil(2); + TRectype& rec_iva = _movimento->iva(i); + rec_iva.put(RMI_ANNOES,annoes); + rec_iva.put(RMI_NUMREG,numreg); + rec_iva.put(RMI_NUMRIG,i); + rec_iva.put(RMI_CODIVA,codiva); + rec_iva.put(RMI_IMPONIBILE,imponibile); + rec_iva.put(RMI_IMPOSTA,imposta); + rec_iva.put(RMI_TIPOCR,conto.tipo_cr()); + rec_iva.put(RMI_INTRA,_caus->intra()); + rec_iva.put(RMI_TIPOC,conto.tipo()); + rec_iva.put(RMI_GRUPPO,conto.gruppo()); + rec_iva.put(RMI_CONTO,conto.conto()); + rec_iva.put(RMI_SOTTOCONTO,conto.sottoconto()); + cur = (TIVA_element*)_righe_iva.succ_item(); + } + return _error; +} + +error_type TContabilizzazione_app::create_total_doc_row() +// Crea la riga contabile di totale documento +{ + TRectype& rec_cg = _movimento->cg(0); + TRectype& head = _movimento->lfile().curr(); + int annoes = head.get_int(MOV_ANNOES); + long numreg = head.get_long(MOV_NUMREG); + TDate datareg(head.get_date(MOV_DATAREG)); + real totdoc(head.get_real(MOV_TOTDOC)); + char rowtype = 'T'; + TString16 tipocf(_doc->get("TIPOCF")); + const long codcf = _doc->get_long("CODCF"); + int gruppo = 0, conto = 0; + + // Trova il mastro del cliente/fornitore + _clifo->put(CLI_TIPOCF,tipocf); + _clifo->put(CLI_CODCF,codcf); + + // cerca prima sul record + if (_clifo->read() == NOERR) + { + gruppo = _clifo->get_int(CLI_GRUPPO); + conto = _clifo->get_int(CLI_CONTO); + } + + // poi sulla categoria di vendita (solo per i clienti) + if ((_clifo->bad() || gruppo == 0 || conto == 0) && tipocf == "C") + { + TString16 cod_cve(_clifo->get(CLI_CATVEN)); + _cve->put("CODTAB",cod_cve); + if (_cve->read() == NOERR) + { + gruppo = _cve->get_int("I3"); + conto = _cve->get_int("I4"); + } + } + + TBill zio; + TString descr; + _caus->bill(1,zio); + descr = zio.descrizione(); + // se ancora non e' stato trovato piglia quello della causale + if (gruppo == 0 || conto == 0) + { + gruppo = zio.gruppo(); + conto = zio.conto(); + } + + if (gruppo == 0 || conto == 0) + _error = conto_error; + + TRectype& first_iva_row = _movimento->iva(0); + const char tc = first_iva_row.get_char(RMI_TIPOC); + const int grc = first_iva_row.get_int(RMI_GRUPPO); + const int coc = first_iva_row.get_int(RMI_CONTO); + const long soc =first_iva_row.get_long(RMI_SOTTOCONTO); + rec_cg.put(RMV_ANNOES,annoes);rec_cg.put(RMV_NUMREG,numreg); + rec_cg.put(RMV_NUMRIG,1); rec_cg.put(RMV_SEZIONE,tipocf == "C" ? "D" : "A"); + rec_cg.put(RMV_DATAREG,datareg); rec_cg.put(RMV_TIPOC,tipocf); + rec_cg.put(RMV_GRUPPO,gruppo);rec_cg.put(RMV_CONTO,conto); + rec_cg.put(RMV_SOTTOCONTO,codcf); rec_cg.put(RMV_DESCR,descr); + rec_cg.put(RMV_TIPOCC,tc); rec_cg.put(RMV_GRUPPOC,grc); + rec_cg.put(RMV_CONTOC,coc);rec_cg.put(RMV_SOTTOCONTOC,soc); + rec_cg.put(RMV_IMPORTO,totdoc); rec_cg.put(RMV_ROWTYPE,rowtype); + + return _error; +} + +error_type TContabilizzazione_app::compile_rows_mov() +// Compila le righe +{ + _doc->compile_summary(); // Calcola imposta/imponibile per riga + const int rows = _doc->rows(); + const TArray& sum_arr = _doc->summary_array(); + + _righe_iva.destroy(); // resetta l'assoc_array delle righe di iva + for (int i=0; good() && iput("CODTAB",tiporiga); + if (_tri->read() == NOERR) // controlla l'esistenza della riga + { + char s4 = _tri->get("S4")[0]; + if (s4 == 'D') continue; // salta le righe descrizione + //TBI: + // righe di (S)pese e s(C)onti + + if (s4 == 'M') // queste sono le righe di merce. (! big elaboration !) + { + TBill conto; + search_costo_ricavo(conto,r); // l'errore eventuale viene settato qui dentro + if (good()) + { + TRiepilogo_Iva& ri = (TRiepilogo_Iva&) sum_arr[i]; + add_iva_row(conto,ri); + } + } + } + else + _error = row_type_error; + } + + // Crea le righe di IVA + if (good()) + create_iva_rows(); + // Crea la riga di totale documento + if (good()) + create_total_doc_row(); + // crea le righe di contabilita' + if (good()) + if (!_movimento->recalc_cg_rows()) _error = movement_error; + return _error; +} + +void TContabilizzazione_app::calc_pagament() +{ + TString16 codpag(_doc->get("CODPAG")); + TString16 data(_doc->get("DATAINSC")); + _pagamento = new TPagamento(codpag, data); + real totspese = _doc->tot_spese(); + real totimposte = _doc->tot_imposte(); + real totimponibili = _doc->tot_documento() - totimposte - totspese; + const bool valuta = _doc->in_valuta(); + if (valuta) + { + const real change(_doc->cambio()); + real val1 = totimponibili * change; + real val2 = totimposte * change; + real val3 = totspese * change; + _pagamento->set_total_valuta( totimponibili, totimposte, totspese, change, val1, val2 ,val3); + } + else + _pagamento->set_total( totimponibili, totimposte, totspese ); + _pagamento->set_rate_auto( ); +} + +error_type TContabilizzazione_app::write_scadenze() +// Scrive le scadenze. Liberamente tratto da cg2104.cpp. +{ + calc_pagament(); + + const TRectype& head = _movimento->lfile().curr(); + const long nreg = head.get_long(MOV_NUMREG); + const int anno = head.get_int(MOV_ANNOIVA); + const TString numpart(_nump_cfg ? MOV_PROTIVA : MOV_NUMDOC); + + //TPartita* oldgame = partite().first(); + TPartita* newgame = NULL; + + int nuova_riga = 0; + + if (anno > 0 && !numpart.blank()) + { + const int tmov = _caus->tipomov(); + const TString desc(head.get(MOV_DESCR)); + const TString codpag(head.get(MOV_CODPAG)); + const TString codcaus(_caus->codice()); + const TString v(head.get(MOV_CODVAL)); + const TDate d(head.get_date(MOV_DATACAM)); + const real c(head.get_real(MOV_CAMBIO)); + const TValuta cambio(v, d, c); + const TString agente(_doc->get("CODAG")); + const char sezione = _movimento->cg(0).get_char(RMV_SEZIONE); // Dare/Avere + + TBill clifo; + const char tipocf = head.get_char(MOV_TIPO); + const long codcf = head.get_long(MOV_CODCF); + clifo.set(0,0,codcf,tipocf); + newgame = new TPartita(clifo, anno, numpart); + + const int row = newgame->prima_fattura(nreg); // Riga fattura di questo movimento + TRiga_partite& partita = row <= 0 ? newgame->new_row() : newgame->riga(row); + nuova_riga = partita.get_int(PART_NRIGA); + + CHECK(_pagamento,"E che diavolo! Ti avevo detto di calcolare prima _pagamento"); + TPagamento& pag = *_pagamento; + + // put data on partita + partita.put(PART_TIPOMOV, tmov); + partita.put(PART_NREG, nreg); + partita.put(PART_NUMRIG, 1); + partita.put(PART_DATAREG, head.get_date(MOV_DATAREG)); + partita.put(PART_DATADOC, head.get_date(MOV_DATADOC)); + partita.put(PART_NUMDOC, head.get(MOV_NUMDOC)); + partita.put(PART_DESCR, desc); + partita.put(PART_CODCAUS, codcaus); + partita.put(PART_REG, _caus->reg().name()); + partita.put(PART_PROTIVA, head.get_long(MOV_PROTIVA)); + partita.put(PART_SEZ, sezione); + + const real totdoc(head.get_real(MOV_TOTDOC)); + partita.put(PART_IMPTOTDOC, totdoc); + + cambio.put(partita); + const bool in_valuta = cambio.in_valuta(); + + real imponibile, imponibile_val; + for (int i = pag.n_rate()-1; i >= 0; i--) + { + if (in_valuta) + imponibile_val += pag.tval_rata(i); + imponibile += pag.tlit_rata(i); + } + + partita.put(PART_IMPORTO, imponibile); + partita.put(PART_IMPORTOVAL, imponibile_val); + partita.put(PART_IMPOSTA, pag.imposta()); + partita.put(PART_SPESE, pag.spese()); + + const TString abipr(_doc->get("CODABIP")), + cabpr(_doc->get("CODCABP")), + abi(_doc->get("CODABIA")), + cab(_doc->get("CODCABP")); + + + partita.elimina_rata(-1); // Elimina tutte le rate eventuali + const int nr = pag.n_rate(); + for (i = 0; i < nr; i++) + { + TRiga_scadenze& scadenza = partita.new_row(); + + scadenza.put(SCAD_CODPAG, codpag); // Codice pagamento + scadenza.put(SCAD_CODAG, agente); // Codice agente + + scadenza.put(SCAD_DATASCAD, pag.data_rata(i)); // Data scadenza + scadenza.put(SCAD_IMPORTO, pag.tlit_rata(i)); // Importo + if (in_valuta) + scadenza.put(SCAD_IMPORTOVAL, pag.tval_rata(i)); // Importo in valuta + scadenza.put(SCAD_TIPOPAG, pag.tipo_rata(i)); // Tipo pagamento + scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i)); // Ulteriore classificazione + scadenza.put(SCAD_CODABIPR, abipr); // Ns ABI + scadenza.put(SCAD_CODCABPR, cabpr); // Ns CAB + scadenza.put(SCAD_CODABI, abi); // Vs ABI + scadenza.put(SCAD_CODCAB, cab); // Vs CAB +// scadenza.put(SCAD_DESCR, ????); // Note + } + } + + if (newgame != NULL) // Se non ho cancellato il numero partita ... + { + if (!newgame->write()) // Salva nuova partita + error_box("Si e' verificato un errore scrivendo le scadenze del documento."); + delete newgame; + } + + if (_pagamento) + { + delete _pagamento; + _pagamento = NULL; + } + return _error; +} + +error_type TContabilizzazione_app::write_all() +// Scrive il movimento e le scadenze, gestendo la rinumerazione se il movimento e' gia presente +{ + // N.B: _error non viene settato, per non stampare il messaggio di errore 2 volte, + // basta solo ritornare qualcosa di != da no_error, per evitare le operazioni successive + // a write_all + TRectype& head = _movimento->lfile().curr(); + long numreg = head.get_long(MOV_NUMREG); + while (_movimento->write() == _isreinsert) + numreg++; + if (_movimento->status() != NOERR) + { + error_box("Errore %d scrivendo il movimento %ld.",_movimento->status(),numreg); + return generic_error; + } + if (sc_enabled()) write_scadenze(); + return no_error; +} + +error_type TContabilizzazione_app::change_doc_status() +// Cambia lo stato del documento +{ + TLocalisamfile d(LF_DOC); + _doc->stato(_final_doc_status); + if (_doc->head().rewrite(d) != NOERR) + _error = chg_stat_error; + return _error; +} + +void TContabilizzazione_app::display_error() +{ + TString msg; + + switch (_error) + { + case elaboration_error: + msg.format("Il documento %s/%ld non rientra tra i tipi documento validi per l'elaborazione." + "Verificare i tipi documento ed il loro stato iniziale sul codice elaborazione inserito.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case nr_es_error: + msg.format("Rilevato un codice esercizio errato contabilizzando il documento %s/%ld." + "Verificare l'esistenza e la correttezza della tabella esercizi e della data del documento.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case nr_reg_error: + msg.format("Rilevato un numero di registrazione errato contabilizzando il documento %s/%ld." + "Verificare l'integrita' del file movimenti.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case nr_doc_error: + msg.format("Rilevato un numero di documento errato contabilizzando il documento %s/%ld." + "Verificare il numero documento e il codice numerazione inseriti in tabella.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case chg_stat_error: + msg.format("Rilevato un errore cambiando lo stato al documento %s/%ld." + "Verificare l'integrita' del file documenti.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case clifo_error: + msg.format("Rilevato un errore caricando le informazioni del Cli/Fo sul documento %s/%ld." + "Verificare l'esistenza delle informazioni inserite sul file documenti e Cli/Fo.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case ultprot_error: + msg.format("Rilevato un numero di protocollo IVA errato relativamente al documento %s/%ld." + "Verificare le informazioni inserite sul registro %s/%d.",(const char*)_doc->numerazione(),_doc->numero(), + (const char*) _caus->reg().name(),_caus->reg().year()); + break; + case datadoc_error: + msg.format("Rilevato una data documento vuota relativamente al documento %s/%ld." + "Verificare l'informazione inserita.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case caus_error: + msg.format("Rilevato un errore caricando la causale relativamente al documento %s/%ld." + "Verificare l'esistenza del codice causale inserito.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case register_error: + msg.format("Rilevato un errore caricando il registro relativamente al documento %s/%ld." + "Verificare l'esistenza del codice causale/registro inseriti.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case change_error: + msg.format("Rilevato un cambio senza valuta relativamente al documento %s/%ld." + "Verificare la correttezza delle informazioni inserite.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case codpag_error: + msg.format("Rilevato un codice pagamento non esistente relativamente al documento %s/%ld." + "Verificare l'esistenza del codice pagamento inserito.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case row_type_error: + msg.format("Rilevato un codice tipo riga non esistente relativamente al documento %s/%ld." + "Verificare l'esistenza dei vari codici riga inseriti.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case conto_error: + msg.format("Rilevato un conto di costo/ricavo inesistente relativamente al documento %s/%ld." + "Verificare l'esistenza dei conti associati.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case movement_error: + msg.format("Rilevato uno sbilancio nel movimento relativamente al documento %s/%ld." + "Verificare la correttezza degli importi.",(const char*)_doc->numerazione(),_doc->numero()); + break; + case mov_write_error: + msg.format("Rilevato un errore in scrittura movimento relativamente al documento %s/%ld." + "Verificare la consistenza dei files.",(const char*)_doc->numerazione(),_doc->numero()); + break; + default: + msg.format("E' stato rilevato un errore generico contabilizzando il documento %s/%ld.", + (const char*)_doc->numerazione(),_doc->numero()); + break; + } + warning_box(msg); + _error = no_error; // reset error, as any other one would do, so you can show me the other ones. + _can_write = FALSE; // But from now on u cannot write anymore. U must exit this program and repair errors occurred. +} + +void TContabilizzazione_app::contabilize_document() +{ + _movimento = new TMovimentoPN_VE; + + compile_head_mov(); + if (good()) compile_rows_mov(); + + if (good() && _can_write) + if (write_all() == no_error) // Se la scrittura e' andata ok... + { + _total_docs++; + change_doc_status(); + } + delete _caus; + delete _movimento; +} + +void TContabilizzazione_app::contabilize() +{ + TRelation doc_rel(LF_DOC); + TLocalisamfile righe_doc(LF_RIGHEDOC); + TRectype da(LF_DOC),a(LF_DOC); + const long items = _num_sheet->items(); + + _total_docs = 0; + for (long i=0L; ichecked(i)) // Se la numerazione corrente e' stata selezionata + { // istanzia un cursore per la numerazione corrente, con i limiti di data + TString16 codnum(_num_sheet->row(i).get(1)); + da.put("DATADOC",_data_ini); + da.put("CODNUM",codnum); + a.put("DATADOC",_data_fine); + da.put("CODNUM",codnum); + TCursor doc_cur(&doc_rel,"",3,&da,&a); + const long cur_items = doc_cur.items(); // Scorre tutti i documenti che rientrano nell'intervallo selezionato + TString msg; + msg.format("Contabilizzazione documenti %s dal %s al %s",(const char*)codnum,(const char*) _data_ini, (const char*) _data_fine); +#ifdef DBG + TProgind p(cur_items,msg,TRUE,TRUE,1); +#else + TProgind p(cur_items,msg,FALSE,TRUE,1); +#endif + long j = 0; +#ifdef DBG + for (;jread(doc_cur.curr()); // istanzia il documento + if (doc_tipo_stato_ok()) // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata + contabilize_document(); + else + _error = elaboration_error; + if (!good()) + display_error(); + } +#ifdef DBG + if (p.iscancelled()) break; +#endif + } + if (_total_docs > 0) + message_box("Totale documenti contabilizzati: %ld",_total_docs); + +} int ve6100 (int argc, char **argv) { - return 1; + TContabilizzazione_app a; + a.run(argc,argv,"Contabilizzazione documenti"); + return TRUE; }