From 1ba75cc8f2652c1f50418d203e16e378d722f24d Mon Sep 17 00:00:00 2001 From: AlexBonazzi Date: Mon, 26 Nov 2018 01:50:39 +0100 Subject: [PATCH] Patch level : 12.0 642 Files correlati : cg1.exe cg2.exe cg4.exe cg5.exe np0.exe Commento : MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Aggiunto il conto utile IV direttiva ai parametri ditta (se non indicato vale 9 E 22) e gestito in stampa bilancio IV direttiva. Impostato il valore della riga di saldaconto all importo se non indicato. Contabilità separata letto correttamente dalla maschera il codice di contabilità separata. Non stampava il riepigolo fatture per cassa nella stampa definitiva. --- src/cg/cg1600.cpp | 210 ++-- src/cg/cg2102.h | 4 +- src/cg/cg2104.cpp | 9 +- src/cg/cg3100.cpp | 2 +- src/cg/cg3100a.uml | 2 +- src/cg/cg3100b.uml | 2 +- src/cg/cg4400.cpp | 2 - src/cg/cg5100a.h | 7 + src/cg/cg5100a.uml | 105 +- src/cg/cglib02.cpp | 2301 ++++++++++++++++++++++---------------------- 10 files changed, 1356 insertions(+), 1288 deletions(-) diff --git a/src/cg/cg1600.cpp b/src/cg/cg1600.cpp index 6a6486673..de68600a2 100755 --- a/src/cg/cg1600.cpp +++ b/src/cg/cg1600.cpp @@ -173,6 +173,8 @@ class TStampa_IVdirettiva : public TPrintapp TString _classe_stampata, _classe_da_stampare,_numr_tot,_num_tot,_numr,_num; char _sez_da_stamp,_let_da_stamp,_sez_stamp,_let_stamp,_sez_tot,_let_tot,_let,_sez_saldo,_sez,_tot_sez_saldo; TString _numr_da_stamp,_num_da_stamp,_numr_stamp,_num_stamp,_descr_sez; + char _sez_utile, _lett_utile; + TString _classe_utile, _num_utile; int _tipo_bilancio, _tipo_stampa; int _cont_let,_cont_numr,_cont_num,_cont_gcs; int _stampa_mov_prov; @@ -381,10 +383,7 @@ bool TStampa_IVdirettiva::data_limite (TMask_field& f, KEY key) a()._datalimite = a()._data_fine_ese; else if ((datalim < in)||(datalim > fin)) - { - f.error_box(TR("La data limite non appartiene all'esercizio indicato")); - return false; - } + return f.error_box(TR("La data limite non appartiene all'esercizio indicato")); else a()._datalimite = datalim; } @@ -392,19 +391,11 @@ bool TStampa_IVdirettiva::data_limite (TMask_field& f, KEY key) if (annoese == 0) { if (datalim == botime) - { - f.error_box(TR("La data limite deve essere indicata obbligatoriamente")); - return false; - } - + return f.error_box(TR("La data limite deve essere indicata obbligatoriamente")); int anno = a().date2esc(datalim); if (anno == 0) - { - f.error_box(TR("La data limite indicata non appartiene ad alcun esercizio attivo della ditta")); - return false; - } - + return f.error_box(TR("La data limite indicata non appartiene ad alcun esercizio attivo della ditta")); a()._data_ini_ese = a()._inizioEs; a()._data_fine_ese = a()._fineEs; @@ -463,16 +454,10 @@ bool TStampa_IVdirettiva::data_bil_raff (TMask_field& f, KEY key) else anno = 1; if (dataraf > in) - { - f.error_box(TR("La data bilancio da raffrontare non puo' essere maggiore o uguale alla data inizio esercizio in corso")); - return false; - } - + return f.error_box(TR("La data bilancio da raffrontare non puo' essere maggiore o uguale alla data inizio esercizio in corso")); if (anno == 0) - { - f.error_box(TR("La data bilancio da raffrontare indicata non appartiene ad alcun esercizio attivo della ditta")); - return false; - } + return f.error_box(TR("La data bilancio da raffrontare indicata non appartiene ad alcun esercizio attivo della ditta")); + a()._databilrafr = dataraf; a()._data_ini_raf = in_raf; @@ -490,10 +475,7 @@ bool TStampa_IVdirettiva::data_bil_raff (TMask_field& f, KEY key) else if (dataraf < in_raf || dataraf > fin_raf) - { - f.error_box(TR("La data bilancio da raffrontare deve appartenere all' esercizio da raffrontare")); - return false; - } + return f.error_box(TR("La data bilancio da raffrontare deve appartenere all' esercizio da raffrontare")); else a()._databilrafr = dataraf; a()._anno_esercizio_raf = annoraf; @@ -519,33 +501,28 @@ bool anno_ese_raff (TMask_field& f, KEY key) annoese = f.mask().get_int(F_ANNOESE); annoraf = f.mask().get_int(F_ANNORAFFR); - if (annoraf != 0) - { - if (annoese != 0) - { - if (annoraf >= annoese) - { - f.error_box(TR("L' anno esercizio da raffrontare deve essere inferiore all' anno esercizio in corso")); - return false; - } - } - else - if (annoese == 0) - { - datalim = f.mask().get(F_DATALIM); + if (annoraf != 0) + { + if (annoese != 0) + { + if (annoraf >= annoese) + return f.error_box(TR("L' anno esercizio da raffrontare deve essere inferiore all' anno esercizio in corso")); - if (datalim != botime) - { - anno = a().date2esc(datalim); + } + else + if (annoese == 0) + { + datalim = f.mask().get(F_DATALIM); - if (annoraf >= anno) - { - f.error_box(TR("L' anno esercizio da raffrontare deve essere inferiore all' anno di esercizio di appartenenza della data limite")); - return false; - } - } - } - } + if (datalim != botime) + { + anno = a().date2esc(datalim); + + if (annoraf >= anno) + return f.error_box(TR("L' anno esercizio da raffrontare deve essere inferiore all' anno di esercizio di appartenenza della data limite")); + } + } + } } return true; } @@ -771,31 +748,23 @@ bool TStampa_IVdirettiva::data_inizio(TMask_field& f, KEY k) if (data == botime) a()._dataini = in; - else - if (data < in || data > fin) - { - f.error_box(TR("La data non appartiene all' esercizio indicato")); - return false; - } - else - a()._dataini = data; + else + { + if (data < in || data > fin) + return f.error_box(TR("La data non appartiene all' esercizio indicato")); + else + a()._dataini = data; + } } else { if (data == botime) - { - f.error_box(TR("La data deve essere obbligatoriamente indicata")); - return false; - } + return f.error_box(TR("La data deve essere obbligatoriamente indicata")); - int anno = a().date2esc(data); + int anno = a().date2esc(data); if (anno == 0) - { - f.error_box(TR("La data limite indicata non appartiene ad alcun esercizio attivo della ditta")); - return false; - } - + return f.error_box(TR("La data limite indicata non appartiene ad alcun esercizio attivo della ditta")); a()._anno_esercizio = anno; a()._dataini = data; a()._data_ini_ese = a()._inizioEs; @@ -842,38 +811,22 @@ bool TStampa_IVdirettiva::data_fine(TMask_field& f, KEY k) if (data == botime) a()._datafine = fin; else - if (data < in || data > fin) - { - f.error_box(TR("La data non appartiene all' esercizio indicato")); - return false; - } - else - a()._datafine = data; + if (data < in || data > fin) + return f.error_box(TR("La data non appartiene all' esercizio indicato")); + else + a()._datafine = data; } else { if (data == botime) - { - f.error_box(TR("La data deve essere obbligatoriamente indicata")); - return false; - } - + return f.error_box(TR("La data deve essere obbligatoriamente indicata")); a().date2esc(data_ini); - if (data < a()._inizioEs || data > a()._fineEs) - { - f.error_box(TR("La data non appartiene all' esercizio indicato")); - return false; - } - else - a()._datafine = data; - } - - if (data < data_ini) - { - f.error_box(TR("La data finale non puo' essere inferiore alla data di partenza")); - return false; + return f.error_box(TR("La data non appartiene all' esercizio indicato")); + a()._datafine = data; } + if (data < data_ini) + return f.error_box(TR("La data finale non puo' essere inferiore alla data di partenza")); } return true; @@ -890,6 +843,8 @@ void TStampa_IVdirettiva::scrivi_record(const TString& sez, //Forzo la lettera della classe a Z, per ottenere, grazie //all'ordinamento del sort, i record dei conti d'ordine per ultimi + if (sez == "9" && let == "E") + int i = 1; set_bil_key(_bil, sez[0], let[0], numerorom, numero, true, g, c, s, tipocf); set_bil_val(_bil, saldo, saldorafr, sld_dare, sld_avere, mov_dare, mov_avere,conto_dettagliato); _sort->sort ((const char*) _bil); @@ -903,7 +858,9 @@ void TStampa_IVdirettiva::riempi_record(const TString& sez, { if (!(_stampamov && saldo.is_zero() && saldorafr.is_zero())) { - set_bil_key(_bil, sez[0], let[0], numerorom, numero, false, g, c, s, tipocf); + if (sez == "9" && let == "E") + int i = 1; + set_bil_key(_bil, sez[0], let[0], numerorom, numero, false, g, c, s, tipocf); set_bil_val(_bil, saldo, saldorafr, sld_dare, sld_avere, mov_dare, mov_avere,conto_dettagliato); _sort->sort ((const char*) _bil); _items_sort++; @@ -2057,7 +2014,7 @@ bool TStampa_IVdirettiva::set_print(int) _totale_passivita_gia_stampato = false; _statopatr_no_stamp = true; _diffprod_fatto = true; - _risimp_fatto = true; + _risimp_fatto = false; _sbilancio_ordine = false; _sbilancio_patr_gia_stampato = false; _attivo_o_passivo = false; @@ -2124,24 +2081,23 @@ bool TStampa_IVdirettiva::set_print(int) // Lo so, fa schifo: ma mi sono adeguato (Guy) bool TStampa_IVdirettiva::devo_stampare_risultato_prima_delle_imposte() const { - if (!_risimp_fatto) - return false; - - if (_sez_da_stamp != '9') - return false; - - if (_let_da_stamp != 'E') - return false; - - if (atoi(_num_da_stamp) < 22) - return false; + if (_risimp_fatto) + return false; + if (_sez_da_stamp > _sez_utile) + return true; + if (_sez_da_stamp == _sez_utile && _let_da_stamp >= _lett_utile && _classe_da_stampare >= _classe_utile && atoi(_num_da_stamp) >= atoi(_num_utile)) + return true; + if (_sez_da_stamp == _sez_utile && _let_da_stamp == _lett_utile && _classe_da_stampare >= _classe_utile && atoi(_num_da_stamp) >= atoi(_num_utile)) + return true; + if (_sez_da_stamp == _sez_utile && _let_da_stamp == _lett_utile && _classe_da_stampare == _classe_utile && atoi(_num_da_stamp) >= atoi(_num_utile)) + return true; + return false; - return true; } void TStampa_IVdirettiva::stampa_risultato_prima_delle_imposte() { - if (_risimp_fatto) // Ottimo flag che significa esattamente l'opposto! Grazie PRASSI! + if (!_risimp_fatto) { const bool raff = _annoeserafr > 0 || _databilrafr.ok(); @@ -2167,7 +2123,7 @@ void TStampa_IVdirettiva::stampa_risultato_prima_delle_imposte() set_row (_i,"@111g%r", &te); } _i++; - _risimp_fatto = false; + _risimp_fatto = true; } } @@ -2346,9 +2302,9 @@ void TStampa_IVdirettiva::stampa_totali() if ((_sez_stamp == '1')&&(_let_da_stamp == 'Z')) { - char app = ' '; - set_row (_i++,"@0g%c", app); - set_row (_i,TR("TOTALE ATTIVO")); + char app = ' '; + set_row(_i++, "@0g%c", app); + set_row (_i,TR("TOTALE ATTIVO")); set_row (_i++,"@81g%r", &_totale_sezione); _totale_attivita = _totale_sezione; _totale_sezione = ZERO; @@ -2357,9 +2313,9 @@ void TStampa_IVdirettiva::stampa_totali() if ((_sez_stamp == '2')&&(_let_da_stamp == 'Z')) { - char app = ' '; - set_row (_i++,"@0g%c", app); - set_row (_i,TR("TOTALE PASSIVO")); + char app = ' '; + set_row(_i++, "@0g%c", app); + set_row (_i,TR("TOTALE PASSIVO")); set_row (_i++,"@81g%r", &_totale_sezione); _totale_passivita = _totale_sezione; _totale_sezione = ZERO; @@ -2461,8 +2417,8 @@ void TStampa_IVdirettiva::stampa_totali() if (!_totale_passivita_gia_stampato) if ((_sez_stamp == '2') && (_let_stamp != 'Z')) { - char app = ' '; - set_row (_i++,"@0g%c", app); + char app = ' '; + set_row(_i++, "@0g%c", app); set_row (_i,TR("TOTALE PASSIVO")); set_row (_i++,"@81g%r", &_totale_sezione); _totale_passivita = _totale_sezione; @@ -2792,8 +2748,8 @@ void TStampa_IVdirettiva::stampa_totali_con_raffronto() if ((_sez_stamp == '2')&&(_let_da_stamp == 'Z')) { - char app = ' '; - set_row (_i++,"@0g%c", app); + char app = ' '; + set_row(_i++, "@0g%c", app); set_row (_i,TR("TOTALE PASSIVO")); set_row (_i,"@81g%r", &_totale_sezione); set_row (_i++,"@111g%r", &_totale_sez_raf); @@ -2922,8 +2878,8 @@ void TStampa_IVdirettiva::stampa_totali_con_raffronto() if (!_totale_passivita_gia_stampato) if ((_sez_stamp == '2') && (_let_stamp != 'Z')) { - char app = ' '; - set_row (_i++,"@0g%c", app); + char app = ' '; + set_row(_i++, "@0g%c", app); set_row (_i,TR("TOTALE PASSIVO")); set_row (_i,"@81g%r", &_totale_sezione); set_row (_i++,"@111g%r", &_totale_sez_raf); @@ -3128,7 +3084,7 @@ void TStampa_IVdirettiva::stampa_totali_verifica() classe.format("%c%c%8s%s", _sez_da_stamp,_let_da_stamp,(const char*)_numr_da_stamp,(const char*)_num_da_stamp); - if (classe > ris_imp && _risimp_fatto) + if (classe > ris_imp && !_risimp_fatto) { if (_num_tot == "20" || _num_tot == "21") { @@ -3139,7 +3095,7 @@ void TStampa_IVdirettiva::stampa_totali_verifica() set_row (_i,"@64g%r", &_tot_parz_prg_a); set_row (_i,"@81g%r", &_tot_parz_mov_d); set_row (_i,"@98g%r", &_tot_parz_mov_a); - _risimp_fatto = false; + _risimp_fatto = true; if (_num.not_empty()) { if (!_stampa_modulo) @@ -4699,6 +4655,10 @@ bool TStampa_IVdirettiva::user_create() _msk->set_handler(F_DATAFINE, data_fine); _msk->set_handler(F_DATABILRAF, data_bil_raff); _msk->set_handler(F_ANNORAFFR, anno_ese_raff); + _sez_utile = ini_get_string(CONFIG_DITTA, "CG", "SezIVDUtile", "9")[0]; + _lett_utile = ini_get_string(CONFIG_DITTA, "CG", "LettIVDUtile", "E")[0]; + _classe_utile = ini_get_string(CONFIG_DITTA, "CG", "ClasseIVDUtile", ""); + _num_utile = ini_get_string(CONFIG_DITTA, "CG", "NumIVDUtile", "22"); return true; } diff --git a/src/cg/cg2102.h b/src/cg/cg2102.h index 89be80413..8ac9a2461 100755 --- a/src/cg/cg2102.h +++ b/src/cg/cg2102.h @@ -348,7 +348,9 @@ public: virtual ~TPrimanota_application() { } }; +#ifndef __EXTRA__ inline TPrimanota_application& app() -{ return (TPrimanota_application&)main_app(); } +{ return (TPrimanota_application&)main_app(); } +#endif #endif diff --git a/src/cg/cg2104.cpp b/src/cg/cg2104.cpp index 66cd3e9d9..a1e786925 100755 --- a/src/cg/cg2104.cpp +++ b/src/cg/cg2104.cpp @@ -1169,10 +1169,17 @@ bool TPrimanota_application::showpartite_handler(TMask_field& f, KEY k) { TString msg(128); const TCurrency curr(speso.valore()); + + if (importo.is_zero()) + { + a.set_cgs_imp(riga, speso); + a.calcola_saldo(); + return true; + } msg.format(FR("L'importo sul saldaconto della riga %d è %s"), (riga+1), (const char*)curr.string(true)); if (!speso.is_zero()) msg << (speso.sezione() == 'A' ? TR(" Avere") : TR(" Dare")); - msg << ". Si desidera correggere l'importo dela riga ?"; + msg << ". Si desidera correggere l'importo della riga ?"; const bool ok = f.yesno_box(msg); if (ok) { diff --git a/src/cg/cg3100.cpp b/src/cg/cg3100.cpp index 6410da46e..98bb99f6e 100755 --- a/src/cg/cg3100.cpp +++ b/src/cg/cg3100.cpp @@ -2014,7 +2014,7 @@ void TListaMov_application::imposta_parametri_stampa(const TMask& msk) _provvis = msk.get_int(F_STAMPAMOVP); _competence_only = msk.get_bool(F_COMPETENZA); #ifdef CONT_SEP - _cont_sep = msk.get_bool(F_CONTSEP); + _cont_sep = msk.get(F_CONTSEP); #endif TRectype da (LF_MOV), a(LF_MOV); diff --git a/src/cg/cg3100a.uml b/src/cg/cg3100a.uml index 17882ea6a..8c2cac9d5 100755 --- a/src/cg/cg3100a.uml +++ b/src/cg/cg3100a.uml @@ -235,7 +235,7 @@ BEGIN DISPLAY "Codice@6" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CONTSEP CODTAB - CHECKTYPE REQUIRED + CHECKTYPE NORMAL MODULE NP END #endif diff --git a/src/cg/cg3100b.uml b/src/cg/cg3100b.uml index b673ba6fa..b352f5f18 100755 --- a/src/cg/cg3100b.uml +++ b/src/cg/cg3100b.uml @@ -315,7 +315,7 @@ BEGIN DISPLAY "Codice@6" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CONTSEP CODTAB - CHECKTYPE REQUIRED + CHECKTYPE NORMAL MODULE NP END #endif diff --git a/src/cg/cg4400.cpp b/src/cg/cg4400.cpp index 694023e84..70b6ed5b6 100755 --- a/src/cg/cg4400.cpp +++ b/src/cg/cg4400.cpp @@ -1633,10 +1633,8 @@ void TStampa_registri_app::set_page_tot_reg() } // for } if (printed) - { flush(); fine_mese(); - } if (_stampa_plafonds) stampa_plafonds(rr); } diff --git a/src/cg/cg5100a.h b/src/cg/cg5100a.h index 012c95e83..1b5a12567 100755 --- a/src/cg/cg5100a.h +++ b/src/cg/cg5100a.h @@ -84,6 +84,13 @@ #define FLD_RISCO_S 378 #define FLD_RISCO_D 379 +#define FLD_SEZ 380 +#define FLD_LETT 381 +#define FLD_CLASSE 382 +#define FLD_NUM 383 +#define FLD_SUB 384 +#define FLD_SOTSUB 385 + // gruppi #define GROUP_SALDACONTO 1 #define GROUP_CONTABILITA 2 diff --git a/src/cg/cg5100a.uml b/src/cg/cg5100a.uml index 6c9a6f92b..7484265d3 100755 --- a/src/cg/cg5100a.uml +++ b/src/cg/cg5100a.uml @@ -828,7 +828,7 @@ END ENDPAGE -PAGE "Ratei/Risconti" -1 -1 77 8 +PAGE "Ratei/Risconti/IV Direttiva" -1 -1 77 8 GROUPBOX DLG_NULL 78 4 BEGIN @@ -1022,6 +1022,109 @@ BEGIN GROUP GROUP_CONTABILITA END +GROUPBOX DLG_NULL 77 6 +BEGIN + PROMPT 1 15 "@bConto Utile IV direttiva" +END + +LIST FLD_SEZ 1 18 +BEGIN + PROMPT 2 16 "Sezione " + ITEM "1|Attivita'" + ITEM "2|Passivita'" + ITEM "9|Conto economico" + KEY 1 + FIELD SezIVDUtile + HELP "Sezione utile IV dir. CEE" + GROUP GROUP_CONTABILITA +END + +STRING FLD_LETT 1 +BEGIN + PROMPT 2 17 "Lettera " + FLAGS "U" + KEY 1 + USE %IVD SELECT CODTAB?="??" + INPUT CODTAB[1,1] FLD_SEZ + INPUT CODTAB[2,2] FLD_LETT + DISPLAY "Sezione" CODTAB[1,1] + DISPLAY "Lettera" CODTAB[2,2] + DISPLAY "Descrizione@50" S0 + OUTPUT FLD_SEZ CODTAB[1,1] + OUTPUT FLD_LETT CODTAB[2,2] + CHECKTYPE NORMAL + FIELD LettIVDUtile + HELP "Lettera utile IV dir. CEE" + GROUP GROUP_CONTABILITA + END + +NUMBER FLD_CLASSE 8 4 +BEGIN + PROMPT 2 18 "Classe " + FLAGS "MZ" + KEY 1 + USE %IVD SELECT CODTAB[7,10]=="" + COPY INPUT FLD_LETT + INPUT CODTAB[3,6] FLD_CLASSE + DISPLAY "Sezione" CODTAB[1,1] + DISPLAY "Lettera" CODTAB[2,2] + DISPLAY "Classe @M" CODTAB[3,6] + DISPLAY "Descrizione@50" S0 + OUTPUT FLD_SEZ CODTAB[1,1] + OUTPUT FLD_LETT CODTAB[2,2] + OUTPUT FLD_CLASSE CODTAB[3,6] + CHECKTYPE NORMAL + FIELD ClasseIVDUtile + HELP "Classe utile IV dir. CEE (numero romano)" + GROUP GROUP_CONTABILITA +END + +STRING FLD_NUM 2 +BEGIN + PROMPT 2 19 "Numero " + KEY 1 + USE %IVD + COPY INPUT FLD_CLASSE + INPUT CODTAB[7,8] FLD_NUM + INPUT CODTAB[9,10] FLD_SUB + DISPLAY "Sezione" CODTAB[1,1] + DISPLAY "Lettera" CODTAB[2,2] + DISPLAY "Classe @M" CODTAB[3,6] + DISPLAY "Numero" CODTAB[7,12] + DISPLAY "Descrizione@50" S0 + OUTPUT FLD_SEZ CODTAB[1,1] + OUTPUT FLD_LETT CODTAB[2,2] + OUTPUT FLD_CLASSE CODTAB[3,6] + OUTPUT FLD_NUM CODTAB[7,8] + OUTPUT FLD_SUB CODTAB[9,10] + OUTPUT FLD_SOTSUB CODTAB[11,12] + MESSAGE EMPTY CLEAR,FLD_SUB + MESSAGE ENABLE,FLD_SUB + FIELD NumIVDUtile + HELP "Numero (arabo) secondo la IV dir. CEE" + GROUP GROUP_CONTABILITA +END + +LIST FLD_SUB 2 9 +BEGIN + PROMPT 15 19 "" + ITEM " |" + ITEM "02|Bis" + ITEM "03|Ter" + ITEM "04|Quater" + ITEM "05|Quinquies" + ITEM "06|Sexies" + FIELD SubIVDUtile + GROUP GROUP_CONTABILITA +END + +STRING FLD_SOTSUB 2 +BEGIN + PROMPT 30 19 "" + FIELD SotSubIVDUtile + GROUP GROUP_CONTABILITA +END + ENDPAGE ENDMASK diff --git a/src/cg/cglib02.cpp b/src/cg/cglib02.cpp index ff6027379..3a7d89915 100755 --- a/src/cg/cglib02.cpp +++ b/src/cg/cglib02.cpp @@ -1,632 +1,632 @@ -///////////////////////////////////////////////////////////////////////////// -// cglib02.cpp -// -// Aggiornamento saldi -// -///////////////////////////////////////////////////////////////////////////// - -#include "cglib01.h" -#include "cglib02.h" - -#include -#include -#include - -#include -#include -#include -#include -#include - -/////////////////////////////////////////////////////////// -// TSaldi_list -/////////////////////////////////////////////////////////// - -// -// Cerca l'esercizio precedente di EseCorr -// Se EseCorr e' già il primo ritorna 0 -// -HIDDEN int EsePre(const int EseCorr) -{ - TEsercizi_contabili esc; - return esc.pred(EseCorr); -} - -// aep e' l'esercizio precedente -TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par) -{ - TString16 key; - int aep = aep_par; - - destroy(); - - // Se non passo l'anno precedente lo devo comunque calcolare - if (aep_par == 0) - aep = EsePre(aec); - - TLocalisamfile cf(LF_SALDI); - cf.setkey(2); - cf.put(SLD_GRUPPO,gr); - cf.put(SLD_CONTO,co); - - for (cf.read(_isgteq);!cf.eof();cf.next()) - { - if (!cf.get_bool(SLD_FLSCA)) - { - const int ae = cf.get_int(SLD_ANNOES); - const int g = cf.get_int(SLD_GRUPPO); - const int c = cf.get_int(SLD_CONTO); - const long s = cf.get_long(SLD_SOTTOCONTO); - - if (g != gr || c != co) break; - if (ae != aec && ae != aep) continue; - - const TRectype& r = cf.curr(); - key.format("%3d%3d%6ld", g, c, s); - - // Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia già trovato - bool force = !aep_par; - add(key, r, force); - } - } -} - -TRectype* TSaldi_list::saldi() const -{ - TObject* o = ((TAssoc_array*)this)->get(); - return (TRectype*)o; -} - -/////////////////////////////////////////////////////////// -// TSaldo -/////////////////////////////////////////////////////////// - -TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO), - _prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0), - _indbil(0), _prec(false), _movimentato(false), _significativo(false), - _rec_presente_ec(false), _rec_presente_ep(false), - _causali_apertura(LF_CAUSALI, CAU_MOVAP) - -{ - for (int i = 0; i < 12; i++) - { - _prg_dare_mese[i] = ZERO; - _prg_avere_mese[i] = ZERO; - } -} - -real TSaldo::saldofin_esprec(int annoes, int g, int c, long s, bool saldo_chiusura, bool provvis) -{ - _significativo = false; - - const int annoesprec = EsePre(annoes); - if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo - return ZERO; - - const char flag = _saldi.get(SLD_FLAGSALINI)[0]; - const real saldo = _saldi.get_real(SLD_SALDO); - const real pdare = _saldi.get_real(SLD_PDARE); - const real pavere = _saldi.get_real(SLD_PAVERE); - const real pdarepro = _saldi.get_real(SLD_PDAREPRO); - const real paverepro = _saldi.get_real(SLD_PAVEREPRO); - const char flagsf = _saldi.get_char(SLD_FLAGSALFIN); - const real saldosf = _saldi.get_real(SLD_SALDOFIN); - - real tot = pdare-pavere; - - if (flag == 'D') tot += saldo; - else tot -= saldo; - - if (saldo_chiusura) // W96SALDI del 18-07-96 - { // Ho aggiunto il flag saldo_chiusura con valore di - if (flagsf == 'D') // default a false, perche' il saldo finale dell' esercizio - tot += saldosf; // precedente va considerato solamente nel calcolo dei - else // progressivi precedenti nella stampa mastrini, - tot -= saldosf; // che e' l'unico programma ad usare la funzione - } // passandogli come flag saldo_chiusura il valore true. - - if (provvis) - { - tot += pdarepro; - tot -= paverepro; - } - - _significativo = !tot.is_zero(); - return tot; -} - -//richiamata nel bilancio a sez.contr per data limite -//in realtà calcola il saldo finale es.prec -real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil, bool provvis) -{ - real saldoini; - _significativo = true; - - _saldi.zero(); - _saldi.put(SLD_GRUPPO,g); - _saldi.put(SLD_CONTO,c); - _saldi.put(SLD_SOTTOCONTO,s); - _saldi.put(SLD_ANNOES,_annoes); - _saldi.put(SLD_FLSCA,""); - - if (_rec_presente_ec = (_saldi.read() == NOERR)) - saldoini = _saldi.get_real(SLD_SALDO); - - _significativo = _rec_presente_ec && saldoini != ZERO; - - if (saldoini != ZERO) //non va considerato!!! Vedi appunti - _saldo_iniziale = ZERO; - - if (saldoini == ZERO) - { - if (indbil == 1 || indbil == 2 || indbil == 5) - { - _prec = true; - saldoini = saldofin_esprec(_annoes, g, c, s, false, provvis); - } - _saldo_iniziale = saldoini; - } - return _saldo_iniziale; -} - -bool TSaldo::leggi_mov(long nr) -{ - const TRectype& mov = cache().get(LF_MOV, nr); - const bool ok = !mov.empty(); - if (ok) - { - _codcaus = mov.get(MOV_CODCAUS); - _datareg = mov.get(MOV_DATAREG); - _provv = mov.get(MOV_PROVVIS); // _provv.trim(); - _datacomp = mov.get(MOV_DATACOMP); - } - else - NFCHECK("Testata assente: %ld", nr); - return ok; -} - -//per bilancio scalare (ovvero a sezioni contrapposte) per data limite -bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf, - const TDate& data_sup, int indbil, int stp_prov, const char* filter) -{ - _saldo_iniziale = ZERO; - _saldo = ZERO; - _movimentato = false; - _rec_presente_ep = false; - _rec_presente_ec = false; - _prec = false; - - TRelation rel(LF_RMOV); - TRectype& rmov = rel.curr(); - - rmov.put(RMV_GRUPPO,g); - rmov.put(RMV_CONTO,c); - rmov.put(RMV_SOTTOCONTO,s); - - TCursor cur(&rel, filter, 2, &rmov, &rmov); - const TRecnotype items = cur.items(); - cur.freeze(); - - // Anche se non movimentato vado a vedere il saldo - if (stp_prov != 3 && (filter == NULL || *filter == '\0')) - _saldo = calcola_saldo_iniziale(g,c,s,indbil,stp_prov == 2); - - for (cur = 0L; cur.pos() < items; ++cur) - { - const long num_reg = rmov.get_long(RMV_NUMREG); - - if (!leggi_mov(num_reg)) // Leggo la testata - continue; // Evita righe orfane! - - TDate data_mov; - if (bilancio == DataLimite) - data_mov = _datacomp; - else - { - if (_annoes == 0) - data_mov = _datareg; - else - data_mov = _datacomp; - } - - if (data_mov < data_inf || data_mov > data_sup) - continue; - - // "Se la causale del movimento e' di chiusura, - // o di apertura il movimento non va considerato" - if (_codcaus.not_empty()) - { - const TString& movap = _causali_apertura.decode(_codcaus); - if (movap == "C") - continue; - } - - //bilancio normale (non comprende i provvisori) ? - if (stp_prov == 1 && _provv.not_empty()) - continue; - - //bilancio dei soli provvisori ? - if (stp_prov == 3 && _provv.empty()) - continue; - - const char sezione = rmov.get_char(RMV_SEZIONE); - const real importo = rmov.get_real(RMV_IMPORTO); - - // I mov. di puro riferimento (= con importo = 0) vanno scartati - if (importo.is_zero()) - continue; - - _movimentato = true; - - if (sezione == 'D') - _saldo += importo; - else - _saldo -= importo; - } - -#ifdef DBG - xvtil_statbar_refresh(); -#endif - - return _movimentato; -} - - -//per bilancio di verifica all'ultima immissione -bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil,int stp_prov) -{ - //Si considerano i saldi e non piu' i movimenti - char sezione; - real pdarepro, paverepro; - bool esito = false; - - _saldo_iniziale = ZERO; - _saldoiniziale = ZERO; - _prg_dare = ZERO; - _prg_avere = ZERO; - _saldo = ZERO; - _saldofin = ZERO; - _sezsf = ' '; - - for (int i = 0; i < 12; i++) - { - _prg_dare_mese[i] = ZERO; - _prg_avere_mese[i] = ZERO; - } - - _saldi.zero(); - _saldi.put(SLD_ANNOES,annoes); - _saldi.put(SLD_GRUPPO,g); - _saldi.put(SLD_CONTO,c); - _saldi.put(SLD_SOTTOCONTO,s); - _saldi.put(SLD_FLSCA, ""); - - if (_saldi.read() == NOERR) - { -// int annoe = _saldi.get_int(SLD_ANNOES); -// int gruppo = _saldi.get_int(SLD_GRUPPO); -// int conto = _saldi.get_int(SLD_CONTO); -// long sottoconto = _saldi.get_long(SLD_SOTTOCONTO); - _saldo_iniziale = _saldi.get_real(SLD_SALDO); - _prg_dare = _saldi.get_real(SLD_PDARE); - _prg_avere = _saldi.get_real(SLD_PAVERE); - pdarepro = _saldi.get_real(SLD_PDAREPRO); - paverepro = _saldi.get_real(SLD_PAVEREPRO); - sezione = _saldi.get_char(SLD_FLAGSALINI); - _sezsf = _saldi.get_char(SLD_FLAGSALFIN); // W96SALDI del 19-06-96 modifica richiesta - _saldofin = _saldi.get_real(SLD_SALDOFIN); // da PATRIZIA - - if (stp_prov == 1) //bilancio normale (senza provvisori) - if (_saldo_iniziale.is_zero() && _prg_dare.is_zero() && _prg_avere.is_zero()) - return esito; -// if (stp_prov == 0 && paverepro == ZERO) - if (stp_prov == 3 && paverepro.is_zero() && pdarepro.is_zero()) // Modifica del 24-09-96 errore MI0890. - { - _saldo = _prg_dare = _prg_avere = ZERO; // N.B. Non e' detto che funzioni sempre!!!!!! - return esito; - } - if (sezione == 'A') - _saldo_iniziale = -_saldo_iniziale; - if (_sezsf == 'A') - _saldofin = -_saldofin; // W96SALDI del 19-06-96 - - _saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi - //non comprensivo del saldo finale es.precedente - - if (_saldo_iniziale.is_zero() && stp_prov != 3) - { - if (indbil == 1 || indbil == 2 || indbil == 5) - _saldo_iniziale += saldofin_esprec(annoes,g,c,s, false, stp_prov == 2); - } - - esito = true; - - switch (stp_prov) - { - case 1: - _saldo = _saldo_iniziale + _prg_dare - _prg_avere + _saldofin; // W96SALDI del 19-06-96 - break; - case 2: - _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro + _saldofin; // W96SALDI del 19-06-96 - if (pdarepro != ZERO) // Modifica del 24-09-96 errore MI0890: nel caso in cui i progressivi - _prg_dare = pdarepro; // pdarepro o paverepro sono compilati sono in presenza di un movimento - if (paverepro != ZERO) // provvisorio, dunque li trasferisco nei progressivi che poi uso nel - _prg_avere = paverepro; // CG1500 per la stampa. - break; - case 3: - _saldo = pdarepro - paverepro; - _prg_dare = pdarepro; // Idem come sopra. - _prg_avere = paverepro; // N.B. Non e' detto che funzioni sempre!!!!!! - break; - default: - break; - } - } - return esito; -} - -//per bilancio a sezioni contrapposte all'ultima immissione -// W96SALDI in questa funzione e' stato aggiunto il parametro saldo_chiusura che di default -// e' true. A cosa serve ? Serve per includere nel calcolo del saldo all' ultima immissione -// anche il saldo finale compilato nei movimenti di chiusura (se non venisse considerato i conti -// risulterebbero aperti); siccome alcuni programmi (esempio il bilancio IV dir. CEE) non ne -// devono tenere conto, si e' data la possibilità di usare la funzione passandogli il parametro a false. -// Modifica del 09-07-96 -bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil,int stp_prov,bool saldo_chiusura) -{ - //Si considerano i saldi e non piu' i movimenti - char sezione; -// int gruppo, conto, annoe; -// long sottoconto; - real pdarepro, paverepro; - bool esito = false; - - _saldo_iniziale = ZERO; - _prg_dare = ZERO; - _prg_avere = ZERO; - _saldo = ZERO; - _saldofin = ZERO; - _sezsf = ' '; - _rec_presente_ec = false; - _rec_presente_ep = false; - _prec = false; - - for (int i = 0; i < 12; i++) - { - _prg_dare_mese[i] = ZERO; - _prg_avere_mese[i] = ZERO; - } - - _saldi.zero(); - _saldi.put(SLD_ANNOES,annoes); - _saldi.put(SLD_GRUPPO,g); - _saldi.put(SLD_CONTO,c); - _saldi.put(SLD_SOTTOCONTO,s); - _saldi.put(SLD_FLSCA, ""); - - if (_saldi.read() == NOERR) - { -// annoe = _saldi.get_int(SLD_ANNOES); -// gruppo = _saldi.get_int(SLD_GRUPPO); -// conto = _saldi.get_int(SLD_CONTO); -// sottoconto = _saldi.get_long(SLD_SOTTOCONTO); - _saldo_iniziale = _saldi.get_real(SLD_SALDO); - _prg_dare = _saldi.get_real(SLD_PDARE); - _prg_avere = _saldi.get_real(SLD_PAVERE); - pdarepro = _saldi.get_real(SLD_PDAREPRO); - paverepro = _saldi.get_real(SLD_PAVEREPRO); - sezione = _saldi.get_char(SLD_FLAGSALINI); - _sezsf = _saldi.get_char(SLD_FLAGSALFIN); - _saldofin = _saldi.get_real(SLD_SALDOFIN); - - if (stp_prov == 1) //bilancio normale (senza provvisori) - esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO); - - if (stp_prov == 2) //bilancio globale (con provvisori) - esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO - || pdarepro != ZERO || paverepro != ZERO); - - if (stp_prov == 3) //bilancio dei soli mov. provvisori - esito = (pdarepro != ZERO || paverepro != ZERO); - - if (sezione == 'A') - _saldo_iniziale = -_saldo_iniziale; - - if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure - if (_sezsf == 'A') // no del saldo di chiusura inserita il 09-07-96 - _saldofin = -_saldofin; - - _rec_presente_ec = esito; - } - - if (_saldo_iniziale.is_zero() && stp_prov != 3) - if (indbil == 1 || indbil == 2 || indbil == 5) - { - _prec = true; - _saldo_iniziale += saldofin_esprec(annoes,g,c,s,false,stp_prov==2); - } - - if (stp_prov == 1) - _saldo = _saldo_iniziale + _prg_dare - _prg_avere; - - if (stp_prov == 2) - _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro; - - if (stp_prov == 3) - _saldo = pdarepro - paverepro; - - if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure - _saldo += _saldofin; // no del saldo di chiusura inserita il 09-07-96 - -#ifdef __LONGDOUBLE__ - _saldo.round(TCurrency::get_firm_dec()); -#endif - - return esito; -} - -const real& TSaldo::saldo_periodo(int g, int c, long s, const TDate& dal, const TDate& al, - int indbil, bool provv) - -{ - _saldo_iniziale = ZERO; - _saldo = ZERO; - _prg_dare = ZERO; - _prg_avere = ZERO; - _movimentato = false; - _rec_presente_ep = false; - _rec_presente_ec = false; - _prec = false; - - for (int i = 0; i < 12; i++) - { - _prg_dare_mese[i] = ZERO; - _prg_avere_mese[i] = ZERO; - } - - TEsercizi_contabili es; - const int codes = es.date2esc(dal); - const TDate inizio = es.esercizio(codes).inizio(); - _annoes = codes; - - TString80 key; key.format("%04d| |%d|%d|%ld", _annoes, g, c, s); - const TRectype& saldo = cache().get(LF_SALDI, key); - - _saldo_iniziale = saldo.get_real(SLD_SALDO); - _prec = _saldo_iniziale.is_zero() && (indbil == 1 || indbil == 2 || indbil == 5); - - if (_prec) - { - _saldo_iniziale = saldofin_esprec(codes,g,c,s); - } - else - { - if (saldo.get_char(SLD_FLAGSALINI) == 'A') - _saldo_iniziale = -_saldo_iniziale; - } - - TRelation relrmov(LF_RMOV); - TRectype& rmov = relrmov.curr(); - rmov.put(RMV_GRUPPO,g); - rmov.put(RMV_CONTO,c); - rmov.put(RMV_SOTTOCONTO,s); - - TCursor cur(&relrmov, "", 2, &rmov, &rmov); - const TRecnotype items = cur.items(); - - if (items > 0) - { - cur.freeze(); - - TProgind* p = NULL; - if (items > 100) // E' proprio utile la progind? - { - TString80 prompt; - prompt.format(FR("Calcolo saldo del conto %d.%d.%ld"), g, c, s); - p = new TProgind(items, prompt, false); - } - - for (cur = 0L; cur.pos() < items; ++cur) - { - if (p != NULL) - p->addstatus(1L); - - const long num_reg = rmov.get_long(RMV_NUMREG); - const real importo = rmov.get_real(RMV_IMPORTO); - - if (!importo.is_zero()) - { - const char sezione = rmov.get_char(RMV_SEZIONE); - // "Se la causale del movimento e' di chiusura, - // o di apertura il movimento non va considerato" - leggi_mov(num_reg); - const TString& movap = _causali_apertura.decode(_codcaus); - - if ((provv || _provv.empty()) && movap.blank()) - { - if (_datacomp >= dal && _datacomp <= al) - { - _movimentato = true; - const int m = _datacomp.month() - 1; - - if (sezione == 'D') - { - _prg_dare += importo; - _prg_dare_mese[m] += importo; - } - else - { - _prg_avere += importo; - _prg_avere_mese[m] += importo; - } - } - else - if (_datacomp >= inizio && _datacomp < dal) - { - if (sezione == 'D') - _saldo_iniziale += importo; - else - _saldo_iniziale -= importo; - } - } - } - } - - - if (p != NULL) - delete p; - } - _saldo = _saldo_iniziale + _prg_dare - _prg_avere; - return _saldo; -} - -bool TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s) -{ - if (annoesprec == 0) - _rec_presente_ep = false; - else - { - const int oldkey = _saldi.getkey(); - _saldi.setkey(1); - _saldi.zero(); - _saldi.put(SLD_ANNOES,annoesprec); - _saldi.put(SLD_GRUPPO,g); - _saldi.put(SLD_CONTO,c); - _saldi.put(SLD_SOTTOCONTO,s); - _saldi.put(SLD_FLSCA, ""); - _rec_presente_ep = _saldi.read() == NOERR; - _saldi.setkey(oldkey); - } - return _rec_presente_ep; -} - -//calcolo dei progressivi attuali (normali o eliminati) -bool TSaldo::prg_saldo(int annoes, TConto& conto, real& prgdare, real& prgavere, bool scar) -{ - _saldi.zero(); - _saldi.put(SLD_GRUPPO,conto.gruppo()); - _saldi.put(SLD_CONTO,conto.conto()); - _saldi.put(SLD_SOTTOCONTO,conto.sottoconto()); - _saldi.put(SLD_ANNOES,annoes); - _saldi.put(SLD_FLSCA, scar); - - bool ok = _saldi.read() == NOERR; - - if (ok) - { - const char flagsalini = _saldi.get_char(SLD_FLAGSALINI); - const real saldoini = _saldi.get_real(SLD_SALDO); - prgdare = _saldi.get_real(SLD_PDARE); - prgavere = _saldi.get_real(SLD_PAVERE); - - if (flagsalini == 'D') - prgdare += saldoini ; - else - prgavere += saldoini; - } - return ok; -} - +///////////////////////////////////////////////////////////////////////////// +// cglib02.cpp +// +// Aggiornamento saldi +// +///////////////////////////////////////////////////////////////////////////// + +#include "cglib01.h" +#include "cglib02.h" + +#include +#include +#include + +#include +#include +#include +#include +#include + +/////////////////////////////////////////////////////////// +// TSaldi_list +/////////////////////////////////////////////////////////// + +// +// Cerca l'esercizio precedente di EseCorr +// Se EseCorr e' già il primo ritorna 0 +// +HIDDEN int EsePre(const int EseCorr) +{ + TEsercizi_contabili esc; + return esc.pred(EseCorr); +} + +// aep e' l'esercizio precedente +TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par) +{ + TString16 key; + int aep = aep_par; + + destroy(); + + // Se non passo l'anno precedente lo devo comunque calcolare + if (aep_par == 0) + aep = EsePre(aec); + + TLocalisamfile cf(LF_SALDI); + cf.setkey(2); + cf.put(SLD_GRUPPO,gr); + cf.put(SLD_CONTO,co); + + for (cf.read(_isgteq);!cf.eof();cf.next()) + { + if (!cf.get_bool(SLD_FLSCA)) + { + const int ae = cf.get_int(SLD_ANNOES); + const int g = cf.get_int(SLD_GRUPPO); + const int c = cf.get_int(SLD_CONTO); + const long s = cf.get_long(SLD_SOTTOCONTO); + + if (g != gr || c != co) break; + if (ae != aec && ae != aep) continue; + + const TRectype& r = cf.curr(); + key.format("%3d%3d%6ld", g, c, s); + + // Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia già trovato + bool force = !aep_par; + add(key, r, force); + } + } +} + +TRectype* TSaldi_list::saldi() const +{ + TObject* o = ((TAssoc_array*)this)->get(); + return (TRectype*)o; +} + +/////////////////////////////////////////////////////////// +// TSaldo +/////////////////////////////////////////////////////////// + +TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO), + _prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0), + _indbil(0), _prec(false), _movimentato(false), _significativo(false), + _rec_presente_ec(false), _rec_presente_ep(false), + _causali_apertura(LF_CAUSALI, CAU_MOVAP) + +{ + for (int i = 0; i < 12; i++) + { + _prg_dare_mese[i] = ZERO; + _prg_avere_mese[i] = ZERO; + } +} + +real TSaldo::saldofin_esprec(int annoes, int g, int c, long s, bool saldo_chiusura, bool provvis) +{ + _significativo = false; + + const int annoesprec = EsePre(annoes); + if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo + return ZERO; + + const char flag = _saldi.get(SLD_FLAGSALINI)[0]; + const real saldo = _saldi.get_real(SLD_SALDO); + const real pdare = _saldi.get_real(SLD_PDARE); + const real pavere = _saldi.get_real(SLD_PAVERE); + const real pdarepro = _saldi.get_real(SLD_PDAREPRO); + const real paverepro = _saldi.get_real(SLD_PAVEREPRO); + const char flagsf = _saldi.get_char(SLD_FLAGSALFIN); + const real saldosf = _saldi.get_real(SLD_SALDOFIN); + + real tot = pdare-pavere; + + if (flag == 'D') tot += saldo; + else tot -= saldo; + + if (saldo_chiusura) // W96SALDI del 18-07-96 + { // Ho aggiunto il flag saldo_chiusura con valore di + if (flagsf == 'D') // default a false, perche' il saldo finale dell' esercizio + tot += saldosf; // precedente va considerato solamente nel calcolo dei + else // progressivi precedenti nella stampa mastrini, + tot -= saldosf; // che e' l'unico programma ad usare la funzione + } // passandogli come flag saldo_chiusura il valore true. + + if (provvis) + { + tot += pdarepro; + tot -= paverepro; + } + + _significativo = !tot.is_zero(); + return tot; +} + +//richiamata nel bilancio a sez.contr per data limite +//in realtà calcola il saldo finale es.prec +real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil, bool provvis) +{ + real saldoini; + _significativo = true; + + _saldi.zero(); + _saldi.put(SLD_GRUPPO,g); + _saldi.put(SLD_CONTO,c); + _saldi.put(SLD_SOTTOCONTO,s); + _saldi.put(SLD_ANNOES,_annoes); + _saldi.put(SLD_FLSCA,""); + + if (_rec_presente_ec = (_saldi.read() == NOERR)) + saldoini = _saldi.get_real(SLD_SALDO); + + _significativo = _rec_presente_ec && saldoini != ZERO; + + if (saldoini != ZERO) //non va considerato!!! Vedi appunti + _saldo_iniziale = ZERO; + + if (saldoini == ZERO) + { + if (indbil == 1 || indbil == 2 || indbil == 5) + { + _prec = true; + saldoini = saldofin_esprec(_annoes, g, c, s, false, provvis); + } + _saldo_iniziale = saldoini; + } + return _saldo_iniziale; +} + +bool TSaldo::leggi_mov(long nr) +{ + const TRectype& mov = cache().get(LF_MOV, nr); + const bool ok = !mov.empty(); + if (ok) + { + _codcaus = mov.get(MOV_CODCAUS); + _datareg = mov.get(MOV_DATAREG); + _provv = mov.get(MOV_PROVVIS); // _provv.trim(); + _datacomp = mov.get(MOV_DATACOMP); + } + else + NFCHECK("Testata assente: %ld", nr); + return ok; +} + +//per bilancio scalare (ovvero a sezioni contrapposte) per data limite +bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf, + const TDate& data_sup, int indbil, int stp_prov, const char* filter) +{ + _saldo_iniziale = ZERO; + _saldo = ZERO; + _movimentato = false; + _rec_presente_ep = false; + _rec_presente_ec = false; + _prec = false; + + TRelation rel(LF_RMOV); + TRectype& rmov = rel.curr(); + + rmov.put(RMV_GRUPPO,g); + rmov.put(RMV_CONTO,c); + rmov.put(RMV_SOTTOCONTO,s); + + TCursor cur(&rel, filter, 2, &rmov, &rmov); + const TRecnotype items = cur.items(); + cur.freeze(); + + // Anche se non movimentato vado a vedere il saldo + if (stp_prov != 3 && (filter == NULL || *filter == '\0')) + _saldo = calcola_saldo_iniziale(g,c,s,indbil,stp_prov == 2); + + for (cur = 0L; cur.pos() < items; ++cur) + { + const long num_reg = rmov.get_long(RMV_NUMREG); + + if (!leggi_mov(num_reg)) // Leggo la testata + continue; // Evita righe orfane! + + TDate data_mov; + if (bilancio == DataLimite) + data_mov = _datacomp; + else + { + if (_annoes == 0) + data_mov = _datareg; + else + data_mov = _datacomp; + } + + if (data_mov < data_inf || data_mov > data_sup) + continue; + + // "Se la causale del movimento e' di chiusura, + // o di apertura il movimento non va considerato" + if (_codcaus.not_empty()) + { + const TString& movap = _causali_apertura.decode(_codcaus); + if (movap == "C") + continue; + } + + //bilancio normale (non comprende i provvisori) ? + if (stp_prov == 1 && _provv.not_empty()) + continue; + + //bilancio dei soli provvisori ? + if (stp_prov == 3 && _provv.empty()) + continue; + + const char sezione = rmov.get_char(RMV_SEZIONE); + const real importo = rmov.get_real(RMV_IMPORTO); + + // I mov. di puro riferimento (= con importo = 0) vanno scartati + if (importo.is_zero()) + continue; + + _movimentato = true; + + if (sezione == 'D') + _saldo += importo; + else + _saldo -= importo; + } + +#ifdef DBG + xvtil_statbar_refresh(); +#endif + + return _movimentato; +} + + +//per bilancio di verifica all'ultima immissione +bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil,int stp_prov) +{ + //Si considerano i saldi e non piu' i movimenti + char sezione; + real pdarepro, paverepro; + bool esito = false; + + _saldo_iniziale = ZERO; + _saldoiniziale = ZERO; + _prg_dare = ZERO; + _prg_avere = ZERO; + _saldo = ZERO; + _saldofin = ZERO; + _sezsf = ' '; + + for (int i = 0; i < 12; i++) + { + _prg_dare_mese[i] = ZERO; + _prg_avere_mese[i] = ZERO; + } + + _saldi.zero(); + _saldi.put(SLD_ANNOES,annoes); + _saldi.put(SLD_GRUPPO,g); + _saldi.put(SLD_CONTO,c); + _saldi.put(SLD_SOTTOCONTO,s); + _saldi.put(SLD_FLSCA, ""); + + if (_saldi.read() == NOERR) + { +// int annoe = _saldi.get_int(SLD_ANNOES); +// int gruppo = _saldi.get_int(SLD_GRUPPO); +// int conto = _saldi.get_int(SLD_CONTO); +// long sottoconto = _saldi.get_long(SLD_SOTTOCONTO); + _saldo_iniziale = _saldi.get_real(SLD_SALDO); + _prg_dare = _saldi.get_real(SLD_PDARE); + _prg_avere = _saldi.get_real(SLD_PAVERE); + pdarepro = _saldi.get_real(SLD_PDAREPRO); + paverepro = _saldi.get_real(SLD_PAVEREPRO); + sezione = _saldi.get_char(SLD_FLAGSALINI); + _sezsf = _saldi.get_char(SLD_FLAGSALFIN); // W96SALDI del 19-06-96 modifica richiesta + _saldofin = _saldi.get_real(SLD_SALDOFIN); // da PATRIZIA + + if (stp_prov == 1) //bilancio normale (senza provvisori) + if (_saldo_iniziale.is_zero() && _prg_dare.is_zero() && _prg_avere.is_zero()) + return esito; +// if (stp_prov == 0 && paverepro == ZERO) + if (stp_prov == 3 && paverepro.is_zero() && pdarepro.is_zero()) // Modifica del 24-09-96 errore MI0890. + { + _saldo = _prg_dare = _prg_avere = ZERO; // N.B. Non e' detto che funzioni sempre!!!!!! + return esito; + } + if (sezione == 'A') + _saldo_iniziale = -_saldo_iniziale; + if (_sezsf == 'A') + _saldofin = -_saldofin; // W96SALDI del 19-06-96 + + _saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi + //non comprensivo del saldo finale es.precedente + + if (_saldo_iniziale.is_zero() && stp_prov != 3) + { + if (indbil == 1 || indbil == 2 || indbil == 5) + _saldo_iniziale += saldofin_esprec(annoes,g,c,s, false, stp_prov == 2); + } + + esito = true; + + switch (stp_prov) + { + case 1: + _saldo = _saldo_iniziale + _prg_dare - _prg_avere + _saldofin; // W96SALDI del 19-06-96 + break; + case 2: + _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro + _saldofin; // W96SALDI del 19-06-96 + if (pdarepro != ZERO) // Modifica del 24-09-96 errore MI0890: nel caso in cui i progressivi + _prg_dare = pdarepro; // pdarepro o paverepro sono compilati sono in presenza di un movimento + if (paverepro != ZERO) // provvisorio, dunque li trasferisco nei progressivi che poi uso nel + _prg_avere = paverepro; // CG1500 per la stampa. + break; + case 3: + _saldo = pdarepro - paverepro; + _prg_dare = pdarepro; // Idem come sopra. + _prg_avere = paverepro; // N.B. Non e' detto che funzioni sempre!!!!!! + break; + default: + break; + } + } + return esito; +} + +//per bilancio a sezioni contrapposte all'ultima immissione +// W96SALDI in questa funzione e' stato aggiunto il parametro saldo_chiusura che di default +// e' true. A cosa serve ? Serve per includere nel calcolo del saldo all' ultima immissione +// anche il saldo finale compilato nei movimenti di chiusura (se non venisse considerato i conti +// risulterebbero aperti); siccome alcuni programmi (esempio il bilancio IV dir. CEE) non ne +// devono tenere conto, si e' data la possibilità di usare la funzione passandogli il parametro a false. +// Modifica del 09-07-96 +bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil,int stp_prov,bool saldo_chiusura) +{ + //Si considerano i saldi e non piu' i movimenti + char sezione; +// int gruppo, conto, annoe; +// long sottoconto; + real pdarepro, paverepro; + bool esito = false; + + _saldo_iniziale = ZERO; + _prg_dare = ZERO; + _prg_avere = ZERO; + _saldo = ZERO; + _saldofin = ZERO; + _sezsf = ' '; + _rec_presente_ec = false; + _rec_presente_ep = false; + _prec = false; + + for (int i = 0; i < 12; i++) + { + _prg_dare_mese[i] = ZERO; + _prg_avere_mese[i] = ZERO; + } + + _saldi.zero(); + _saldi.put(SLD_ANNOES,annoes); + _saldi.put(SLD_GRUPPO,g); + _saldi.put(SLD_CONTO,c); + _saldi.put(SLD_SOTTOCONTO,s); + _saldi.put(SLD_FLSCA, ""); + + if (_saldi.read() == NOERR) + { +// annoe = _saldi.get_int(SLD_ANNOES); +// gruppo = _saldi.get_int(SLD_GRUPPO); +// conto = _saldi.get_int(SLD_CONTO); +// sottoconto = _saldi.get_long(SLD_SOTTOCONTO); + _saldo_iniziale = _saldi.get_real(SLD_SALDO); + _prg_dare = _saldi.get_real(SLD_PDARE); + _prg_avere = _saldi.get_real(SLD_PAVERE); + pdarepro = _saldi.get_real(SLD_PDAREPRO); + paverepro = _saldi.get_real(SLD_PAVEREPRO); + sezione = _saldi.get_char(SLD_FLAGSALINI); + _sezsf = _saldi.get_char(SLD_FLAGSALFIN); + _saldofin = _saldi.get_real(SLD_SALDOFIN); + + if (stp_prov == 1) //bilancio normale (senza provvisori) + esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO); + + if (stp_prov == 2) //bilancio globale (con provvisori) + esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO + || pdarepro != ZERO || paverepro != ZERO); + + if (stp_prov == 3) //bilancio dei soli mov. provvisori + esito = (pdarepro != ZERO || paverepro != ZERO); + + if (sezione == 'A') + _saldo_iniziale = -_saldo_iniziale; + + if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure + if (_sezsf == 'A') // no del saldo di chiusura inserita il 09-07-96 + _saldofin = -_saldofin; + + _rec_presente_ec = esito; + } + + if (_saldo_iniziale.is_zero() && stp_prov != 3) + if (indbil == 1 || indbil == 2 || indbil == 5) + { + _prec = true; + _saldo_iniziale += saldofin_esprec(annoes,g,c,s,false,stp_prov==2); + } + + if (stp_prov == 1) + _saldo = _saldo_iniziale + _prg_dare - _prg_avere; + + if (stp_prov == 2) + _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro; + + if (stp_prov == 3) + _saldo = pdarepro - paverepro; + + if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure + _saldo += _saldofin; // no del saldo di chiusura inserita il 09-07-96 + +#ifdef __LONGDOUBLE__ + _saldo.round(TCurrency::get_firm_dec()); +#endif + + return esito; +} + +const real& TSaldo::saldo_periodo(int g, int c, long s, const TDate& dal, const TDate& al, + int indbil, bool provv) + +{ + _saldo_iniziale = ZERO; + _saldo = ZERO; + _prg_dare = ZERO; + _prg_avere = ZERO; + _movimentato = false; + _rec_presente_ep = false; + _rec_presente_ec = false; + _prec = false; + + for (int i = 0; i < 12; i++) + { + _prg_dare_mese[i] = ZERO; + _prg_avere_mese[i] = ZERO; + } + + TEsercizi_contabili es; + const int codes = es.date2esc(dal); + const TDate inizio = es.esercizio(codes).inizio(); + _annoes = codes; + + TString80 key; key.format("%04d| |%d|%d|%ld", _annoes, g, c, s); + const TRectype& saldo = cache().get(LF_SALDI, key); + + _saldo_iniziale = saldo.get_real(SLD_SALDO); + _prec = _saldo_iniziale.is_zero() && (indbil == 1 || indbil == 2 || indbil == 5); + + if (_prec) + { + _saldo_iniziale = saldofin_esprec(codes,g,c,s); + } + else + { + if (saldo.get_char(SLD_FLAGSALINI) == 'A') + _saldo_iniziale = -_saldo_iniziale; + } + + TRelation relrmov(LF_RMOV); + TRectype& rmov = relrmov.curr(); + rmov.put(RMV_GRUPPO,g); + rmov.put(RMV_CONTO,c); + rmov.put(RMV_SOTTOCONTO,s); + + TCursor cur(&relrmov, "", 2, &rmov, &rmov); + const TRecnotype items = cur.items(); + + if (items > 0) + { + cur.freeze(); + + TProgind* p = NULL; + if (items > 100) // E' proprio utile la progind? + { + TString80 prompt; + prompt.format(FR("Calcolo saldo del conto %d.%d.%ld"), g, c, s); + p = new TProgind(items, prompt, false); + } + + for (cur = 0L; cur.pos() < items; ++cur) + { + if (p != NULL) + p->addstatus(1L); + + const long num_reg = rmov.get_long(RMV_NUMREG); + const real importo = rmov.get_real(RMV_IMPORTO); + + if (!importo.is_zero()) + { + const char sezione = rmov.get_char(RMV_SEZIONE); + // "Se la causale del movimento e' di chiusura, + // o di apertura il movimento non va considerato" + leggi_mov(num_reg); + const TString& movap = _causali_apertura.decode(_codcaus); + + if ((provv || _provv.empty()) && movap.blank()) + { + if (_datacomp >= dal && _datacomp <= al) + { + _movimentato = true; + const int m = _datacomp.month() - 1; + + if (sezione == 'D') + { + _prg_dare += importo; + _prg_dare_mese[m] += importo; + } + else + { + _prg_avere += importo; + _prg_avere_mese[m] += importo; + } + } + else + if (_datacomp >= inizio && _datacomp < dal) + { + if (sezione == 'D') + _saldo_iniziale += importo; + else + _saldo_iniziale -= importo; + } + } + } + } + + + if (p != NULL) + delete p; + } + _saldo = _saldo_iniziale + _prg_dare - _prg_avere; + return _saldo; +} + +bool TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s) +{ + if (annoesprec == 0) + _rec_presente_ep = false; + else + { + const int oldkey = _saldi.getkey(); + _saldi.setkey(1); + _saldi.zero(); + _saldi.put(SLD_ANNOES,annoesprec); + _saldi.put(SLD_GRUPPO,g); + _saldi.put(SLD_CONTO,c); + _saldi.put(SLD_SOTTOCONTO,s); + _saldi.put(SLD_FLSCA, ""); + _rec_presente_ep = _saldi.read() == NOERR; + _saldi.setkey(oldkey); + } + return _rec_presente_ep; +} + +//calcolo dei progressivi attuali (normali o eliminati) +bool TSaldo::prg_saldo(int annoes, TConto& conto, real& prgdare, real& prgavere, bool scar) +{ + _saldi.zero(); + _saldi.put(SLD_GRUPPO,conto.gruppo()); + _saldi.put(SLD_CONTO,conto.conto()); + _saldi.put(SLD_SOTTOCONTO,conto.sottoconto()); + _saldi.put(SLD_ANNOES,annoes); + _saldi.put(SLD_FLSCA, scar); + + bool ok = _saldi.read() == NOERR; + + if (ok) + { + const char flagsalini = _saldi.get_char(SLD_FLAGSALINI); + const real saldoini = _saldi.get_real(SLD_SALDO); + prgdare = _saldi.get_real(SLD_PDARE); + prgavere = _saldi.get_real(SLD_PAVERE); + + if (flagsalini == 'D') + prgdare += saldoini ; + else + prgavere += saldoini; + } + return ok; +} + bool TSaldo::saldo_cont_sep(int g, int c, long s, const int codes, TDate al, int indbil, const char * cont_sep, int provv, bool chiusura, bool first) @@ -649,13 +649,6 @@ bool TSaldo::saldo_cont_sep(int g, int c, long s, const int codes, TDate al, if (!al.ok()) al = es[_annoes].fine(); -/* if ((indbil < 3 || indbil == 5) && first) - { - const int codesprec = es.date2prevesc(al); - - saldo_cont_sep(g, c, s, codesprec, es[codesprec].fine(), indbil, cont_sep, provv, chiusura, false); - saldo_ini_prec = _saldo; - } */ _saldo_iniziale = ZERO; _saldo = ZERO; _prg_dare = ZERO; @@ -749,525 +742,523 @@ bool TSaldo::saldo_cont_sep(int g, int c, long s, const int codes, TDate al, if (p != NULL) delete p; } -// if ((indbil < 3 || indbil == 5) && first && _saldo_iniziale == ZERO) -// _saldo_iniziale = saldo_ini_prec; _saldo = _saldo_iniziale + _prg_dare - _prg_avere; return _movimentato; } - - -/////////////////////////////////////////////////////////// -// TContoExt -/////////////////////////////////////////////////////////// - -class TContoExt : public TConto -{ - bool _scaricato; - -public: - - bool scaricato() const { return _scaricato; } - - TContoExt(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL, bool sc = false) - : TConto(g, c, s, t, d), _scaricato(sc) {} - TContoExt(TToken_string& tgcsd, int from, int mode = 0, bool sc = false) - : TConto(tgcsd, from, mode), _scaricato(sc) {} - virtual ~TContoExt() {} -}; - -const TString& TTab_conti::build_key(const TBill& c, int anno, bool scar) const -{ - TString& key = get_tmp_string(23); - key.format("%4d%3d%3d%6ld%c", anno, c.gruppo(), c.conto(), c.sottoconto(), scar ? 'X' : '\0'); - return key; -} - -TConto* TTab_conti::add(const TBill& c, int anno, bool scar) -{ - const TString& key = build_key(c, anno, scar); - TContoExt* tc = new TContoExt(c.gruppo(), c.conto(), c.sottoconto(), - c.tipo(), NULL, scar); - TAssoc_array::add(key, tc); - return tc; -} - -TConto* TTab_conti::find(const TBill& c, int anno, bool scar) -{ - const TString& key = build_key(c, anno, scar); - TContoExt* tc = (TContoExt*)objptr(key); - return tc; -} - -void TTab_conti::remove(const TBill& c, int anno, bool scar) -{ - const TString& key = build_key(c, anno, scar); - TAssoc_array::remove(key); -} - -void TTab_conti::aggiorna_conto(const TBill& tcon, - int anno_es, const TImporto& importo, tiposal movap, - bool provv, bool somma, bool movimentato, bool scaricato) -{ - TContoExt* tc = (TContoExt*)find(tcon, anno_es, scaricato); - if (tc == NULL) - tc = (TContoExt*)add(tcon, anno_es, scaricato); - - const real i(somma ? importo.valore() : -importo.valore()); - - if (provv) - { - if (importo.sezione() == 'D') - tc->darepro() += i; - else - tc->averepro() += i; - } - else - { - if (movap == apertura) - { - if (importo.sezione() == 'D') - tc->saldo() += i; - else - tc->saldo() -= i; - } - else - { - if (movap == chiusura) - { - if (importo.sezione() == 'D') - tc->saldofin() += i; - else - tc->saldofin() -= i; - } - else - { - if (importo.sezione() == 'D') - tc->dare() += i; - else - tc->avere() += i; - } - } - } - - - // rimuovo dalla tabella il conto se dare e avere vanno a zero - if (!movimentato) - if (tc->dare().is_zero() && tc->avere().is_zero() && - tc->saldofin().is_zero() && tc->darepro().is_zero() && - tc->averepro().is_zero() && tc->saldo().is_zero()) - remove(*tc, anno_es, scaricato); -} - -/////////////////////////////////////////////////////////// -// TSaldo_agg -/////////////////////////////////////////////////////////// - -TSaldo_agg::TSaldo_agg() : _anno_es(0), _data_ulmov(""), _num_ulmov(0l), - _movap(normale), _provv(false), _movimentato(false) -{} - -void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma, bool scaricato) -{ - _tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato); -} - -void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione, - bool somma, bool scaricato) -{ - const TBill bill(gruppo, conto, sottoconto); - const TImporto imp(sezione, importo); - _tab_conti.aggiorna_conto(bill, _anno_es, imp, _movap, - _provv, somma, _movimentato, scaricato); -} - -void TSaldo_agg::aggiorna(const TRectype& rmov, bool somma, bool scaricato) -{ - const real imp = rmov.get(RMV_IMPORTO); - if (!imp.is_zero()) - { - const char sez = rmov.get_char(RMV_SEZIONE); - const TImporto importo(sez, imp); - const TBill bill(rmov); - - const long numreg = rmov.get_long(RMV_NUMREG); - if (numreg > _num_ulmov) - { - _num_ulmov = numreg; - _data_ulmov = rmov.get_date(RMV_DATAREG); - _anno_es = rmov.get_int(RMV_ANNOES); - } - aggiorna(bill, importo, somma, scaricato); - } -} - -void TSaldo_agg::reset() -{ - _tab_conti.destroy(); -} - -/////////////////////////////////////////////////////////////////////////////// -// pulizia file saldi -// -// Scorro il file saldi per l' anno year o per tutti gli anni se year = 0 -// e azzero i progressivi. -// -/////////////////////////////////////////////////////////////////////////////// - -void TSaldo_agg::clear_saldi(int year) -{ - TFast_isamfile saldi(LF_SALDI); - - set_anno_es(year); - saldi.zero(); - if (anno_es() != 0) - saldi.put(SLD_ANNOES, anno_es()); - - const TRectype last = saldi.curr(); - - for (saldi.read(_isgteq, _lock); - !saldi.eof() && saldi.curr() <= last; - saldi.next(_lock)) - { - if (!saldi.get_bool(SLD_FLSCA)) - { - saldi.remove(); - } - else - { - saldi.put(SLD_FLSCA, ""); - saldi.write(); - saldi.put(SLD_FLSCA, "X"); - saldi.read(_isequal,_unlock); - } - } - saldi.reread(_unlock); -} - -/////////////////////////////////////////////////////////////////////////////// -// Aggiornamento file saldi -// -// Scorro la tabella dei conti interna _tab_conti. -// Per ogni conto cerco il record su saldi, se non c'e' lo creo. -// Se c'e' già lo aggiorno nel seguente modo: -// GLOP -/////////////////////////////////////////////////////////////////////////////// - -void TSaldo_agg::registra() -{ - real si, r; - char flag_salini; - TDate data_ulmov; - long num_ulmov; - TLocalisamfile saldi(LF_SALDI); - const int conti = _tab_conti.items(); - - _tab_conti.restart(); - for (int i = 0; i < conti; i++) - { - THash_object* hobj = _tab_conti.get_hashobj(); - TContoExt& tcon = (TContoExt&)hobj->obj(); - const int annoes = atoi(hobj->key().left(4)); - CHECK(tcon.ok() && annoes > 2000, "Tentativo di saldare un conto incompleto"); - - saldi.zero(); - saldi.put(SLD_ANNOES, annoes); - saldi.put(SLD_GRUPPO, tcon.gruppo()); - saldi.put(SLD_CONTO, tcon.conto()); - saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); - saldi.put(SLD_FLSCA, tcon.scaricato()); - - bool update = true; - - if (saldi.read(_isequal, _lock) != NOERR) - { - saldi.zero(); - saldi.put(SLD_ANNOES, annoes); - saldi.put(SLD_GRUPPO, tcon.gruppo()); - saldi.put(SLD_CONTO, tcon.conto()); - saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); - saldi.put(SLD_FLSCA, tcon.scaricato()); - - si = tcon.saldo(); - if (si < ZERO) - { flag_salini = 'A'; si = -si; } - else - flag_salini = 'D'; - - saldi.put(SLD_FLAGSALINI, flag_salini); - saldi.put(SLD_SALDO, si); - saldi.put(SLD_PDARE, tcon.dare()); - saldi.put(SLD_PAVERE, tcon.avere()); - saldi.put(SLD_PDAREPRO, tcon.darepro()); - saldi.put(SLD_PAVEREPRO, tcon.averepro()); - - real sf = tcon.saldofin(); - char flag_salfin = sf < ZERO ? 'A' : 'D'; - if (flag_salfin == 'A') sf = -sf; - - saldi.put(SLD_FLAGSALFIN, flag_salfin); - saldi.put(SLD_SALDOFIN, sf); - - if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov); - if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov); - update = saldi.write() == _isreinsert; - if (update) - saldi.read(_isequal, _lock); - } - - if (update) - { - num_ulmov = saldi.get_long(SLD_NUMULTMOV); - data_ulmov = saldi.get_date(SLD_DATAULMOV); - - if ((_num_ulmov != 0L) && (_num_ulmov > num_ulmov)) - saldi.put(SLD_NUMULTMOV, _num_ulmov); - if ((_data_ulmov.ok()) && (_data_ulmov > data_ulmov)) - saldi.put(SLD_DATAULMOV, _data_ulmov); - r = tcon.saldo(); - si = saldi.get_real(SLD_SALDO); - flag_salini = saldi.get_char(SLD_FLAGSALINI); - if (!r.is_zero()) - { - if (flag_salini == 'A') - si = r - si; - else - si += r; - if (si < ZERO) - { - flag_salini = 'A'; - si = -si; - } - else - flag_salini = 'D'; - saldi.put(SLD_FLAGSALINI, flag_salini); - saldi.put(SLD_SALDO, si); - } - - TImporto sf('D', tcon.saldofin()); - char old_flag_sf = saldi.get(SLD_FLAGSALFIN)[0]; - TImporto old_sf(old_flag_sf, saldi.get_real(SLD_SALDOFIN)); - - sf += old_sf; - sf.normalize(); - saldi.put(SLD_FLAGSALFIN, sf.sezione()); - saldi.put(SLD_SALDOFIN, sf.valore()); - - r = saldi.get_real(SLD_PDARE); - r += tcon.dare(); - saldi.put(SLD_PDARE, r); - - r = saldi.get_real(SLD_PAVERE); - r += tcon.avere(); - saldi.put(SLD_PAVERE, r); - - r = saldi.get_real(SLD_PDAREPRO); - r += tcon.darepro(); - saldi.put(SLD_PDAREPRO, r); - - r = saldi.get_real(SLD_PAVEREPRO); - r += tcon.averepro(); - saldi.put(SLD_PAVEREPRO, r); - - const int err = saldi.rewrite(); - if (err != NOERR) - yesnofatal_box(FR("Errore %d nell'aggiornamento del saldo %d %d %ld"), - err, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); - } - - // Calcolo saldo finale per controllo segno in prima nota - if (si.is_zero()) - { - TLocalisamfile pcon(LF_PCON); - TRectype& curr = pcon.curr(); - curr.put(PCN_GRUPPO, tcon.gruppo()); - curr.put(PCN_CONTO, tcon.conto()); - const int err = pcon.read(); - if (err == NOERR) - { - const int indbil = curr.get_int(PCN_INDBIL); - if (indbil == 1 || indbil == 2 || indbil == 5) - { - TSaldo saldo; - si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); - if (si < ZERO) - { - flag_salini = 'A'; - si = -si; - } - else - flag_salini = 'D'; - } - } - else - { - // Era errore fatale - } - } - - TImporto sf(flag_salini, si); - const TImporto dare('D', saldi.get_real(SLD_PDARE)); - const TImporto avere('A', saldi.get_real(SLD_PAVERE)); - sf += dare; - sf += avere; - sf.normalize(+1); // Rendi sempre positivo - tcon.saldo_finale() = sf; - } -} - -/////////////////////////////////////////////////////////// -// TBalance -/////////////////////////////////////////////////////////// - -TBalance::TBalance() -{ -} - -TBalance::TBalance(int g, int c, long s, int esercizio, bool ignora_movap, bool provvis) -{ - read(g, c, s, esercizio, ignora_movap, provvis); -} - -TBalance::TBalance(const TBill& b, int esercizio, bool ignora_movap, bool provvis) -{ - read(b, esercizio, ignora_movap, provvis); -} - -bool TBalance::find(const TBill& b, int esercizio, - TImporto& si, TImporto& da, TImporto& av, TImporto& sf, - TImporto& pd, TImporto& pa) const -{ - CHECK(b.sottoconto() > 0L, "Sottoconto mancante"); - - TString80 key; - key.format("%d||%d|%d|%ld", esercizio, b.gruppo(), b.conto(), b.sottoconto()); - const TRectype & saldi = cache().get(LF_SALDI, key); - const bool ok = !saldi.empty(); - - if (ok) - { - si.set(saldi.get_char(SLD_FLAGSALINI), saldi.get_real(SLD_SALDO)); - da.set('D', saldi.get_real(SLD_PDARE)); - av.set('A', saldi.get_real(SLD_PAVERE)); - sf.set(saldi.get_char(SLD_FLAGSALFIN), saldi.get_real(SLD_SALDOFIN)); - pd.set('D', saldi.get_real(SLD_PDAREPRO)); - pa.set('A', saldi.get_real(SLD_PAVEREPRO)); - } - else - { - si.set('D', ZERO); - da = av = sf = pd = pa = si; - } - return ok; -} - -void TBalance::read(int gruppo, int conto, long sottoconto, int esercizio, bool ignora_movap, bool provvis) -{ - const TBill zio(gruppo, conto, sottoconto); - read(zio, esercizio, ignora_movap, provvis); -} - -int TBalance::indicatore_bilancio(const TBill& b) const -{ - TString16 str; - str.format("%d|%d", b.gruppo(), b.conto()); - const int ib = atoi(cache().get(LF_PCON, str, PCN_INDBIL)); -#ifdef DBG - if (ib < 1 || ib > 5) - { - TString msg; - msg << "Impossibile stabilire l'indicatore di bilancio del conto " << b.gruppo() << ' ' << b.conto(); - NFCHECK(msg); - } -#endif - return ib; -} - -void TBalance::read(const TBill& b, int esercizio, bool ignora_movap, bool provvis) -{ - TImporto si, sf, pd, pa, prd, pra; - - find(b, esercizio, si, pd, pa, sf, prd, pra); - if (provvis) - { - pd += prd; - pa += pra; - } - _saldo_ini = si; - _progr_dare = pd; - _progr_avere = pa; - _saldo_fin = sf; - - if (_saldo_ini.is_zero()) - { - const int indbil = indicatore_bilancio(b); - if (indbil == 1 || indbil == 2 || indbil == 5) - { - TEsercizi_contabili esercizi; - const int precedente = esercizi.pred(esercizio); - if (precedente > 0 && find(b, precedente, si, pd, pa, sf, prd, pra)) - { - if (provvis) - { - pd += prd; - pa += pra; - } - _saldo_ini = si; - _saldo_ini += pd; - _saldo_ini += pa; - _saldo_ini += sf; - _saldo_ini.normalize(); - } - } - } - else - { - if (ignora_movap) - _saldo_ini.set('D', ZERO); - } -} - -const TImporto& TBalance::saldo_iniziale() const -{ return _saldo_ini; } - -const real& TBalance::progressivo_dare_iniziale() const -{ - return _saldo_ini.sezione() == 'D' ? _saldo_ini.valore() : ZERO; -} - -const real& TBalance::progressivo_avere_iniziale() const -{ - return _saldo_ini.sezione() == 'A' ? _saldo_ini.valore() : ZERO; -} - -real TBalance::progressivo_dare_finale() const -{ - real pd = progressivo_dare_iniziale(); - pd += _progr_dare.valore(); - if (_saldo_fin.sezione() == 'D') - pd += _saldo_fin.valore(); - return pd; -} - -real TBalance::progressivo_avere_finale() const -{ - real pa = progressivo_avere_iniziale(); - pa += _progr_avere.valore(); - if (_saldo_fin.sezione() == 'A') - pa += _saldo_fin.valore(); - return pa; -} - -TImporto TBalance::saldo_finale(bool chiusura) const -{ - TImporto sf(_saldo_ini); - sf += _progr_dare; - sf += _progr_avere; - if (chiusura) - sf += _saldo_fin; - return sf; -} - -TImporto TBalance::saldo_finale_chiusura() const -{ - return saldo_finale(true); -} + + +/////////////////////////////////////////////////////////// +// TContoExt +/////////////////////////////////////////////////////////// + +class TContoExt : public TConto +{ + bool _scaricato; + +public: + + bool scaricato() const { return _scaricato; } + + TContoExt(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL, bool sc = false) + : TConto(g, c, s, t, d), _scaricato(sc) {} + TContoExt(TToken_string& tgcsd, int from, int mode = 0, bool sc = false) + : TConto(tgcsd, from, mode), _scaricato(sc) {} + virtual ~TContoExt() {} +}; + +const TString& TTab_conti::build_key(const TBill& c, int anno, bool scar) const +{ + TString& key = get_tmp_string(23); + key.format("%4d%3d%3d%6ld%c", anno, c.gruppo(), c.conto(), c.sottoconto(), scar ? 'X' : '\0'); + return key; +} + +TConto* TTab_conti::add(const TBill& c, int anno, bool scar) +{ + const TString& key = build_key(c, anno, scar); + TContoExt* tc = new TContoExt(c.gruppo(), c.conto(), c.sottoconto(), + c.tipo(), NULL, scar); + TAssoc_array::add(key, tc); + return tc; +} + +TConto* TTab_conti::find(const TBill& c, int anno, bool scar) +{ + const TString& key = build_key(c, anno, scar); + TContoExt* tc = (TContoExt*)objptr(key); + return tc; +} + +void TTab_conti::remove(const TBill& c, int anno, bool scar) +{ + const TString& key = build_key(c, anno, scar); + TAssoc_array::remove(key); +} + +void TTab_conti::aggiorna_conto(const TBill& tcon, + int anno_es, const TImporto& importo, tiposal movap, + bool provv, bool somma, bool movimentato, bool scaricato) +{ + TContoExt* tc = (TContoExt*)find(tcon, anno_es, scaricato); + if (tc == NULL) + tc = (TContoExt*)add(tcon, anno_es, scaricato); + + const real i(somma ? importo.valore() : -importo.valore()); + + if (provv) + { + if (importo.sezione() == 'D') + tc->darepro() += i; + else + tc->averepro() += i; + } + else + { + if (movap == apertura) + { + if (importo.sezione() == 'D') + tc->saldo() += i; + else + tc->saldo() -= i; + } + else + { + if (movap == chiusura) + { + if (importo.sezione() == 'D') + tc->saldofin() += i; + else + tc->saldofin() -= i; + } + else + { + if (importo.sezione() == 'D') + tc->dare() += i; + else + tc->avere() += i; + } + } + } + + + // rimuovo dalla tabella il conto se dare e avere vanno a zero + if (!movimentato) + if (tc->dare().is_zero() && tc->avere().is_zero() && + tc->saldofin().is_zero() && tc->darepro().is_zero() && + tc->averepro().is_zero() && tc->saldo().is_zero()) + remove(*tc, anno_es, scaricato); +} + +/////////////////////////////////////////////////////////// +// TSaldo_agg +/////////////////////////////////////////////////////////// + +TSaldo_agg::TSaldo_agg() : _anno_es(0), _data_ulmov(""), _num_ulmov(0l), + _movap(normale), _provv(false), _movimentato(false) +{} + +void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma, bool scaricato) +{ + _tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato); +} + +void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione, + bool somma, bool scaricato) +{ + const TBill bill(gruppo, conto, sottoconto); + const TImporto imp(sezione, importo); + _tab_conti.aggiorna_conto(bill, _anno_es, imp, _movap, + _provv, somma, _movimentato, scaricato); +} + +void TSaldo_agg::aggiorna(const TRectype& rmov, bool somma, bool scaricato) +{ + const real imp = rmov.get(RMV_IMPORTO); + if (!imp.is_zero()) + { + const char sez = rmov.get_char(RMV_SEZIONE); + const TImporto importo(sez, imp); + const TBill bill(rmov); + + const long numreg = rmov.get_long(RMV_NUMREG); + if (numreg > _num_ulmov) + { + _num_ulmov = numreg; + _data_ulmov = rmov.get_date(RMV_DATAREG); + _anno_es = rmov.get_int(RMV_ANNOES); + } + aggiorna(bill, importo, somma, scaricato); + } +} + +void TSaldo_agg::reset() +{ + _tab_conti.destroy(); +} + +/////////////////////////////////////////////////////////////////////////////// +// pulizia file saldi +// +// Scorro il file saldi per l' anno year o per tutti gli anni se year = 0 +// e azzero i progressivi. +// +/////////////////////////////////////////////////////////////////////////////// + +void TSaldo_agg::clear_saldi(int year) +{ + TFast_isamfile saldi(LF_SALDI); + + set_anno_es(year); + saldi.zero(); + if (anno_es() != 0) + saldi.put(SLD_ANNOES, anno_es()); + + const TRectype last = saldi.curr(); + + for (saldi.read(_isgteq, _lock); + !saldi.eof() && saldi.curr() <= last; + saldi.next(_lock)) + { + if (!saldi.get_bool(SLD_FLSCA)) + { + saldi.remove(); + } + else + { + saldi.put(SLD_FLSCA, ""); + saldi.write(); + saldi.put(SLD_FLSCA, "X"); + saldi.read(_isequal,_unlock); + } + } + saldi.reread(_unlock); +} + +/////////////////////////////////////////////////////////////////////////////// +// Aggiornamento file saldi +// +// Scorro la tabella dei conti interna _tab_conti. +// Per ogni conto cerco il record su saldi, se non c'e' lo creo. +// Se c'e' già lo aggiorno nel seguente modo: +// GLOP +/////////////////////////////////////////////////////////////////////////////// + +void TSaldo_agg::registra() +{ + real si, r; + char flag_salini; + TDate data_ulmov; + long num_ulmov; + TLocalisamfile saldi(LF_SALDI); + const int conti = _tab_conti.items(); + + _tab_conti.restart(); + for (int i = 0; i < conti; i++) + { + THash_object* hobj = _tab_conti.get_hashobj(); + TContoExt& tcon = (TContoExt&)hobj->obj(); + const int annoes = atoi(hobj->key().left(4)); + CHECK(tcon.ok() && annoes > 2000, "Tentativo di saldare un conto incompleto"); + + saldi.zero(); + saldi.put(SLD_ANNOES, annoes); + saldi.put(SLD_GRUPPO, tcon.gruppo()); + saldi.put(SLD_CONTO, tcon.conto()); + saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); + saldi.put(SLD_FLSCA, tcon.scaricato()); + + bool update = true; + + if (saldi.read(_isequal, _lock) != NOERR) + { + saldi.zero(); + saldi.put(SLD_ANNOES, annoes); + saldi.put(SLD_GRUPPO, tcon.gruppo()); + saldi.put(SLD_CONTO, tcon.conto()); + saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); + saldi.put(SLD_FLSCA, tcon.scaricato()); + + si = tcon.saldo(); + if (si < ZERO) + { flag_salini = 'A'; si = -si; } + else + flag_salini = 'D'; + + saldi.put(SLD_FLAGSALINI, flag_salini); + saldi.put(SLD_SALDO, si); + saldi.put(SLD_PDARE, tcon.dare()); + saldi.put(SLD_PAVERE, tcon.avere()); + saldi.put(SLD_PDAREPRO, tcon.darepro()); + saldi.put(SLD_PAVEREPRO, tcon.averepro()); + + real sf = tcon.saldofin(); + char flag_salfin = sf < ZERO ? 'A' : 'D'; + if (flag_salfin == 'A') sf = -sf; + + saldi.put(SLD_FLAGSALFIN, flag_salfin); + saldi.put(SLD_SALDOFIN, sf); + + if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov); + if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov); + update = saldi.write() == _isreinsert; + if (update) + saldi.read(_isequal, _lock); + } + + if (update) + { + num_ulmov = saldi.get_long(SLD_NUMULTMOV); + data_ulmov = saldi.get_date(SLD_DATAULMOV); + + if ((_num_ulmov != 0L) && (_num_ulmov > num_ulmov)) + saldi.put(SLD_NUMULTMOV, _num_ulmov); + if ((_data_ulmov.ok()) && (_data_ulmov > data_ulmov)) + saldi.put(SLD_DATAULMOV, _data_ulmov); + r = tcon.saldo(); + si = saldi.get_real(SLD_SALDO); + flag_salini = saldi.get_char(SLD_FLAGSALINI); + if (!r.is_zero()) + { + if (flag_salini == 'A') + si = r - si; + else + si += r; + if (si < ZERO) + { + flag_salini = 'A'; + si = -si; + } + else + flag_salini = 'D'; + saldi.put(SLD_FLAGSALINI, flag_salini); + saldi.put(SLD_SALDO, si); + } + + TImporto sf('D', tcon.saldofin()); + char old_flag_sf = saldi.get(SLD_FLAGSALFIN)[0]; + TImporto old_sf(old_flag_sf, saldi.get_real(SLD_SALDOFIN)); + + sf += old_sf; + sf.normalize(); + saldi.put(SLD_FLAGSALFIN, sf.sezione()); + saldi.put(SLD_SALDOFIN, sf.valore()); + + r = saldi.get_real(SLD_PDARE); + r += tcon.dare(); + saldi.put(SLD_PDARE, r); + + r = saldi.get_real(SLD_PAVERE); + r += tcon.avere(); + saldi.put(SLD_PAVERE, r); + + r = saldi.get_real(SLD_PDAREPRO); + r += tcon.darepro(); + saldi.put(SLD_PDAREPRO, r); + + r = saldi.get_real(SLD_PAVEREPRO); + r += tcon.averepro(); + saldi.put(SLD_PAVEREPRO, r); + + const int err = saldi.rewrite(); + if (err != NOERR) + yesnofatal_box(FR("Errore %d nell'aggiornamento del saldo %d %d %ld"), + err, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); + } + + // Calcolo saldo finale per controllo segno in prima nota + if (si.is_zero()) + { + TLocalisamfile pcon(LF_PCON); + TRectype& curr = pcon.curr(); + curr.put(PCN_GRUPPO, tcon.gruppo()); + curr.put(PCN_CONTO, tcon.conto()); + const int err = pcon.read(); + if (err == NOERR) + { + const int indbil = curr.get_int(PCN_INDBIL); + if (indbil == 1 || indbil == 2 || indbil == 5) + { + TSaldo saldo; + si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); + if (si < ZERO) + { + flag_salini = 'A'; + si = -si; + } + else + flag_salini = 'D'; + } + } + else + { + // Era errore fatale + } + } + + TImporto sf(flag_salini, si); + const TImporto dare('D', saldi.get_real(SLD_PDARE)); + const TImporto avere('A', saldi.get_real(SLD_PAVERE)); + sf += dare; + sf += avere; + sf.normalize(+1); // Rendi sempre positivo + tcon.saldo_finale() = sf; + } +} + +/////////////////////////////////////////////////////////// +// TBalance +/////////////////////////////////////////////////////////// + +TBalance::TBalance() +{ +} + +TBalance::TBalance(int g, int c, long s, int esercizio, bool ignora_movap, bool provvis) +{ + read(g, c, s, esercizio, ignora_movap, provvis); +} + +TBalance::TBalance(const TBill& b, int esercizio, bool ignora_movap, bool provvis) +{ + read(b, esercizio, ignora_movap, provvis); +} + +bool TBalance::find(const TBill& b, int esercizio, + TImporto& si, TImporto& da, TImporto& av, TImporto& sf, + TImporto& pd, TImporto& pa) const +{ + CHECK(b.sottoconto() > 0L, "Sottoconto mancante"); + + TString80 key; + key.format("%d||%d|%d|%ld", esercizio, b.gruppo(), b.conto(), b.sottoconto()); + const TRectype & saldi = cache().get(LF_SALDI, key); + const bool ok = !saldi.empty(); + + if (ok) + { + si.set(saldi.get_char(SLD_FLAGSALINI), saldi.get_real(SLD_SALDO)); + da.set('D', saldi.get_real(SLD_PDARE)); + av.set('A', saldi.get_real(SLD_PAVERE)); + sf.set(saldi.get_char(SLD_FLAGSALFIN), saldi.get_real(SLD_SALDOFIN)); + pd.set('D', saldi.get_real(SLD_PDAREPRO)); + pa.set('A', saldi.get_real(SLD_PAVEREPRO)); + } + else + { + si.set('D', ZERO); + da = av = sf = pd = pa = si; + } + return ok; +} + +void TBalance::read(int gruppo, int conto, long sottoconto, int esercizio, bool ignora_movap, bool provvis) +{ + const TBill zio(gruppo, conto, sottoconto); + read(zio, esercizio, ignora_movap, provvis); +} + +int TBalance::indicatore_bilancio(const TBill& b) const +{ + TString16 str; + str.format("%d|%d", b.gruppo(), b.conto()); + const int ib = atoi(cache().get(LF_PCON, str, PCN_INDBIL)); +#ifdef DBG + if (ib < 1 || ib > 5) + { + TString msg; + msg << "Impossibile stabilire l'indicatore di bilancio del conto " << b.gruppo() << ' ' << b.conto(); + NFCHECK(msg); + } +#endif + return ib; +} + +void TBalance::read(const TBill& b, int esercizio, bool ignora_movap, bool provvis) +{ + TImporto si, sf, pd, pa, prd, pra; + + find(b, esercizio, si, pd, pa, sf, prd, pra); + if (provvis) + { + pd += prd; + pa += pra; + } + _saldo_ini = si; + _progr_dare = pd; + _progr_avere = pa; + _saldo_fin = sf; + + if (_saldo_ini.is_zero()) + { + const int indbil = indicatore_bilancio(b); + if (indbil == 1 || indbil == 2 || indbil == 5) + { + TEsercizi_contabili esercizi; + const int precedente = esercizi.pred(esercizio); + if (precedente > 0 && find(b, precedente, si, pd, pa, sf, prd, pra)) + { + if (provvis) + { + pd += prd; + pa += pra; + } + _saldo_ini = si; + _saldo_ini += pd; + _saldo_ini += pa; + _saldo_ini += sf; + _saldo_ini.normalize(); + } + } + } + else + { + if (ignora_movap) + _saldo_ini.set('D', ZERO); + } +} + +const TImporto& TBalance::saldo_iniziale() const +{ return _saldo_ini; } + +const real& TBalance::progressivo_dare_iniziale() const +{ + return _saldo_ini.sezione() == 'D' ? _saldo_ini.valore() : ZERO; +} + +const real& TBalance::progressivo_avere_iniziale() const +{ + return _saldo_ini.sezione() == 'A' ? _saldo_ini.valore() : ZERO; +} + +real TBalance::progressivo_dare_finale() const +{ + real pd = progressivo_dare_iniziale(); + pd += _progr_dare.valore(); + if (_saldo_fin.sezione() == 'D') + pd += _saldo_fin.valore(); + return pd; +} + +real TBalance::progressivo_avere_finale() const +{ + real pa = progressivo_avere_iniziale(); + pa += _progr_avere.valore(); + if (_saldo_fin.sezione() == 'A') + pa += _saldo_fin.valore(); + return pa; +} + +TImporto TBalance::saldo_finale(bool chiusura) const +{ + TImporto sf(_saldo_ini); + sf += _progr_dare; + sf += _progr_avere; + if (chiusura) + sf += _saldo_fin; + return sf; +} + +TImporto TBalance::saldo_finale_chiusura() const +{ + return saldo_finale(true); +}