From 3624682c0eae7caee3faf677a48d48714302b433 Mon Sep 17 00:00:00 2001 From: alex Date: Sun, 10 Jul 2011 04:52:04 +0000 Subject: [PATCH] Patch level : 10.1048 Files correlati : cg1.exe cg3.exe Ricompilazione Demo : [ ] Commento : MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Apertura / Chiusura a contailità separata git-svn-id: svn://10.65.10.50/branches/R_10_00@22389 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- np/np0.cpp | 5 +- np/np0200.cpp | 2095 +++++++++++++++++++++++++++++++++++++++++++++++- np/np0200.h | 37 + np/np0200a.uml | 363 +++++++++ 4 files changed, 2496 insertions(+), 4 deletions(-) create mode 100755 np/np0200.h create mode 100644 np/np0200a.uml diff --git a/np/np0.cpp b/np/np0.cpp index 5998572b3..f42875c62 100755 --- a/np/np0.cpp +++ b/np/np0.cpp @@ -6,8 +6,11 @@ int main(int argc, char** argv) const char op = argc < 2 ? '0' : argv[1][1]; switch (op) { + case '1': + np0200(argc,argv); // Apertura /Chiusura + break; default: - np0100(argc,argv);// Tabelle di modulo + np0100(argc,argv); // Tabelle di modulo break; } return 0; diff --git a/np/np0200.cpp b/np/np0200.cpp index 559e162af..f797d2336 100755 --- a/np/np0200.cpp +++ b/np/np0200.cpp @@ -1,6 +1,2095 @@ -#include "np0.h" +// Chiusura/Apertura Conti -int np0200(int argc, char* argv[]) +#include +#include +#include +#include +#include + +#include "np0.h" +#include "np0200.h" +#include "..\cg\cg2101.h" +#include "..\cg\cglib02.h" + +#include +#include +#include +#include + + +#define MAX_CG_ROWS 98 + +class TApertura_chiusura : public TSkeleton_application { - return 0; + TRelation* _rel; + TMovimentoPN* _pn; + TCursor* _cur; + TSaldo_agg* _sld; + TSaldo* _sale; + TProgind* _prog; + TConto _tcbilch,_tcproper,_tcbilap,_tcutilp,_tcperdp,_tcutile,_tcperde, _conto_corrente, _tcacutp; + TEsercizi_contabili* _esc; + TAssoc_array _cont_sep; + TString _cod_cont_sep; + + real _saldo, _totale_saldo, _capitale_netto; + int _annoesch, _annoesap; + long _numreg; + TDate _dataregap, _dataregch, _datacompch, _datacompap; + TString4 _codcausap, _codcausch; + +protected: + static bool mask_datac (TMask_field&, KEY); + static bool mask_dataap (TMask_field&, KEY); + static bool mask_distinti (TMask_field&, KEY); + static bool attivo_passivo(TMask_field&, KEY); + static bool costi_ricavi (TMask_field&, KEY); + static bool abilita_anni(TMask& m, KEY k); + bool anni_contigui (int annoch, int annoap); + const bool cerca_esercizio(int anno, TMask_field& f); + + long ultima_registrazione(); + void compila_testata(int anno,const TDate& datareg,const TString& codcaus,const TDate& datacomp); + void registra_pn(); + +public: + virtual bool create(); + virtual bool destroy(); + virtual void main_loop(); + + void costi (); + void ricavi(); + void chiudi_attivita(); + void chiudi_passivita(); + void chiudi_conti_ordine(); + void apri_attivita(); + void apri_passivita(); + void apri_conti_ordine(); + void rmov_proper (int, long, TDate&, TRectype&, TConto&, real&, bool); + void chiusura_conto_economico(); + void chiusura_conto_patrimoniale(); + void apertura_capitale_netto(); + bool set(); + + TApertura_chiusura() {} +}; + +TApertura_chiusura& app() { return (TApertura_chiusura&) main_app(); } + +bool TApertura_chiusura::abilita_anni(TMask& m, KEY k) +{ + if (k == K_SHIFT+K_F12) + { + m.enable(F_ANNOCH); + m.enable(F_ANNO); + } + return TRUE; } + +bool TApertura_chiusura::anni_contigui (int annoch, int annoap) +{ + const TEsercizio & chi = _esc->esercizio(annoch); + const TEsercizio & ap = _esc->esercizio(annoap); + const TDate inizio(ap.inizio() - 1L); + const TDate fine(chi.fine()); + + if (inizio != fine) + return warning_box(TR("I due esercizi indicati non risultano contigui")); + + return TRUE; +} + +const bool TApertura_chiusura::cerca_esercizio(int anno, TMask_field& f) +{ + if (!_esc->exist(anno)) + return f.warning_box(TR("Esercizio non presente in tabella esercizi")); + return TRUE; +} + +bool TApertura_chiusura::mask_datac(TMask_field& f, KEY k) +{ + bool ok = TRUE; + + if ( k == K_TAB && f.focusdirty() ) + { + TDate data = f.get(); + int anno = app()._esc->date2esc(data); + const int annoap = f.mask().get_int(F_ANNO); + + if (anno == annoap) + anno = app()._esc->pred(annoap); + + f.mask().set(F_ANNOCH, anno); // Esercizio di chiusura + if (anno == 0) + return f.error_box("Esercizio non presente in tabella esercizi"); + } + + if ( (k == K_ENTER) && f.to_check(k) ) + { + const TDate data = f.get(); + const int annoch = f.mask().get_int(F_ANNOCH); + const int annoap = f.mask().get_int(F_ANNO); + int anno = 0; + + if (app().cerca_esercizio(annoap,f) && app().cerca_esercizio(annoch,f) && + app().anni_contigui(annoch,annoap)) + { + const TEsercizio & ap = app()._esc->esercizio(annoap); + const TDate inizio = ap.inizio(); + const TDate fine = ap.fine(); + const TDate scarico = ap.scarico(); + + const TEsercizio & chi = app()._esc->esercizio(annoch); + const TDate iniziop = chi.inizio(); + const TDate finep = chi.fine(); + + if (data < finep) + { + f.warning_box (TR("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente")); + return FALSE; + } + if (data > fine) + { + f.warning_box (TR("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso")); + return FALSE; + } + if ( scarico.ok() && (data <= scarico) ) + { + f.warning_box (TR("La data di chiusura non puo' essere inferiore o uguale alla data di scarico")); + return FALSE; + } + if ( (data >= inizio) && (data <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso + anno = fine.year(); + else if ( (data >= iniziop) && (data <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente + anno = finep.year(); + } + else + return FALSE; + + TRelation reg("REG"); + TRectype & tabreg = reg.curr(); + TString16 annos; + + annos.format("%04d", anno); + tabreg.put("CODTAB", annos); + + TCursor cur(®, "", 1, &tabreg, &tabreg); + const TRecnotype items = cur.items(); + + cur.freeze(); + for (cur = 0L; cur.pos() < items; ++cur) + { + if (tabreg.get_int("I0") == 5) + { + const TDate datast(tabreg.get_date("D3")); + + if (data < datast) + return f.warning_box(TR("La data di apertura non puo' essere inferiore alla data ultima stampa bollato")); + } + } + } + return TRUE; +} + +bool TApertura_chiusura::mask_dataap (TMask_field& f, KEY k) +{ + bool ok = TRUE; + + if ( k == K_TAB && f.focusdirty() ) + { + TDate data = f.mask().get_date(F_DATAAP); + int anno = app()._esc->date2esc(data); + + f.mask().set(F_ANNO, anno); // Esercizio di apertura + if (anno != 0) + { + const int pred = app()._esc->pred(anno); + if (pred > 0) + { + f.mask().set(F_ANNOCH, pred); + f.mask().set(F_DATAC, app()._esc->esercizio(pred).fine()); + } + } + else + return f.error_box(TR("Esercizio non presente in tabella esercizi")); + } + + if ( (k == K_ENTER) && f.to_check(k) ) + { + const int annoch = f.mask().get_int(F_ANNOCH); + const int annoap = f.mask().get_int(F_ANNO); + const TDate data = f.get(); + int anno = 0; + + if (app().cerca_esercizio(annoap,f) && app().cerca_esercizio(annoch,f) && + app().anni_contigui(annoch,annoap)) + { + const TEsercizio & ap = app()._esc->esercizio(annoap); + const TDate inizio = ap.inizio(); + const TDate fine = ap.fine(); + const TDate scarico = ap.scarico(); + + const TEsercizio & chi = app()._esc->esercizio(annoch); + const TDate iniziop = chi.inizio(); + const TDate finep = chi.fine(); + + if (data < inizio) + { + f.warning_box (TR("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso")); + return FALSE; + } + if (data > fine) + { + f.warning_box (TR("La data di apertura non puo' essere superiore alla data di fine esercizio in corso")); + return FALSE; + } + if ( scarico.ok() && (data <= scarico) ) + { + f.warning_box (TR("La data di apertura non puo' essere inferiore o uguale alla data di scarico")); + return FALSE; + } + + if ( (data >= inizio) && (data <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso + anno = fine.year(); + else if( (data >= iniziop) && (data <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente + anno = finep.year(); + } + else + return FALSE; + + TRelation reg("REG"); + TRectype & tabreg = reg.curr(); + TString16 annos; + + annos.format("%04d", anno); + tabreg.put("CODTAB", annos); + + TCursor cur(®, "", 1, &tabreg, &tabreg); + const TRecnotype items = cur.items(); + + cur.freeze(); + for (cur = 0L; cur.pos() < items; ++cur) + { + if (tabreg.get_int("I0") == 5) + { + const TDate datast(tabreg.get_date("D3")); + + if (data < datast) + return f.warning_box(TR("La data di apertura non puo' essere inferiore alla data ultima stampa bollato")); + } + } + } + + if (k == K_ENTER) + { + int anno = f.mask().get_int(F_ANNO); + + if (anno == 0) + return f.warning_box(TR("L'eventuale esercizio di apertura non e' presente sulla tabella esercizi")); + } + return TRUE; +} + +bool TApertura_chiusura::mask_distinti (TMask_field& f, KEY k) +{ + if (k == K_ENTER) + { + const TMask& m = f.mask(); + short idg = F_BILCHG; + short idc = F_BILCHC; + short ids = F_BILCHS; + + for (int i = 0; i < 6; i++) + { + const int g = m.get_int(idg); + const int c = m.get_int(idc); + const long s = m.get_long(ids); + + short idg1 = idg; + short idc1 = idc; + short ids1 = ids; + + for (int j = i+1; j < 7; j++) + { + idg1 += 3; + idc1 += 3; + ids1 += 3; + + const int gruppo = m.get_int(idg1); + const int conto = m.get_int(idc1); + const long sottoc = m.get_long(ids1); + + if ((g == gruppo)&&(c == conto)&&(s == sottoc)) + return f.warning_box(FR("Il conto %d.%d.%ld non puo' essere ripetuto!"), gruppo, conto, sottoc); + } + + idg += 3; + idc += 3; + ids += 3; + + } + } + return TRUE; +} + +bool TApertura_chiusura::attivo_passivo (TMask_field& f, KEY k) +{ + if (k == K_ENTER) + { + int g,c; + int id = f.dlg(); + + if (id == F_UTILPC) + g = f.mask().get_int(F_UTILPG); + else + if (id == F_PERDPC) + g = f.mask().get_int(F_PERDPG); + + c = atoi(f.get()); + + TString16 key; + + key.format("%d|%d", g, c); + + const TRectype & pcon = cache().get(LF_PCON, key); + + if (!pcon.empty()) + { + int indbil = pcon.get_int(PCN_INDBIL); + if (indbil != 1 && indbil != 2 && indbil != 5) + return f.warning_box(TR("Indicatore di bilancio del conto %d %d errato: deve essere 1,2 o 5"), g, c); + } + } + return TRUE; +} + +bool TApertura_chiusura::costi_ricavi (TMask_field& f, KEY k) +{ + if (k == K_ENTER) + { + int g,c; + int id = f.dlg(); + + if (id == F_UTILEC) + g = f.mask().get_int(F_UTILEG); + else + if (id == F_PERDEC) + g = f.mask().get_int(F_PERDEG); + + c = atoi(f.get()); + + TString16 key; + + key.format("%d|%d", g, c); + + const TRectype & pcon = cache().get(LF_PCON, key); + if (!pcon.empty()) + { + int indbil = pcon.get_int(PCN_INDBIL); + if (indbil != 3 && indbil != 4) + return f.warning_box(TR("Indicatore di bilancio del conto %d %d errato: deve essere 3 o 4"), g, c); + } + } + return TRUE; +} + +bool TApertura_chiusura::create() +{ + open_files(LF_TABCOM, LF_TAB, LF_SALDI, LF_PCON, LF_MOV, LF_RMOV, LF_RMOVIVA, + LF_PARTITE, LF_SCADENZE, LF_PAGSCA, 0); + + _rel = new TRelation (LF_PCON); + _cur = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1); + + _pn = new TMovimentoPN(); + _sld = new TSaldo_agg(); + _sale = new TSaldo(); + _esc = new TEsercizi_contabili; + + _capitale_netto = ZERO; + + return TSkeleton_application::create(); +} + +bool TApertura_chiusura::destroy() +{ + delete _sale; + delete _esc; + delete _pn; + delete _rel; + delete _cur; + delete _sld; + + return TApplication::destroy(); +} + +long TApertura_chiusura::ultima_registrazione() +{ + TLocalisamfile mov(LF_MOV); + + // Leggo il numero di registrazione dell'ultimo record di mov, e lo + // incremento di uno per ottenere un numero di registrazione sicuramente non esistente. + + mov.last(); + _numreg = mov.get_long(MOV_NUMREG) + 1; + return _numreg; +} + +bool TApertura_chiusura::set() +{ + TMask m("cg4600a"); + KEY tasto; + int gbilch, cbilch , gproper, cproper, gbilap, cbilap, gutilp, gacutp; + int cutilp, gperdp, cperdp, gutile, cutile, gperde, cperde, cacutp; + long sbilch, sproper, sbilap, sutilp, sperdp, sutile, sperde, sacutp; + + TConfig conf(CONFIG_DITTA, "cg"); + m.set(F_CHIUSURA, conf.get("CoCaCh")); + m.set(F_APERTURA, conf.get("CoCaAp")); + + int anno_ap = _esc->last(); + TDate inizio = _esc->esercizio(anno_ap).inizio(); + + // determina quello precedente + const int anno_ch = _esc->pred(anno_ap); + const TDate fine = anno_ch > 0 ? _esc->esercizio(anno_ch).fine() : botime; + if (anno_ap == anno_ch) + { + anno_ap = 0; + inizio = botime; + } + + m.set(F_ANNO, anno_ap); + m.set(F_ANNOCH, anno_ch); + m.set(F_DATAC, fine); + m.set(F_DATAAP, inizio); + + m.set(F_BILCHG, conf.get("CsBiChG")); + m.set(F_BILCHC, conf.get("CsBiChC")); + m.set(F_BILCHS, conf.get("CsBiChS")); + m.set(F_PROPERG, conf.get("CsPrPeG")); + m.set(F_PROPERC, conf.get("CsPrPeC")); + m.set(F_PROPERS, conf.get("CsPrPeS")); + m.set(F_BILAPG, conf.get("CsBiApG")); + m.set(F_BILAPC, conf.get("CsBiApC")); + m.set(F_BILAPS, conf.get("CsBiApS")); + m.set(F_UTILPG, conf.get("CsUeCpG")); + m.set(F_UTILPC, conf.get("CsUeCpC")); + m.set(F_UTILPS, conf.get("CsUeCpS")); + m.set(F_PERDPG, conf.get("CsPeCpG")); + m.set(F_PERDPC, conf.get("CsPeCpC")); + m.set(F_PERDPS, conf.get("CsPeCpS")); + m.set(F_UTILEG, conf.get("CsUeCeG")); + m.set(F_UTILEC, conf.get("CsUeCeC")); + m.set(F_UTILES, conf.get("CsUeCeS")); + m.set(F_PERDEG, conf.get("CsPeCeG")); + m.set(F_PERDEC, conf.get("CsPeCeC")); + m.set(F_PERDES, conf.get("CsPeCeS")); + m.set(F_ACUTPG, conf.get("CsAuCpG")); + m.set(F_ACUTPC, conf.get("CsAuCpC")); + m.set(F_ACUTPS, conf.get("CsAuCpS")); + + m.set_handler (F_DATAC, mask_datac); + m.set_handler (F_DATAAP, mask_dataap); + m.set_handler (F_PERDES, mask_distinti); + m.set_handler (F_UTILPC, attivo_passivo); + m.set_handler (F_PERDPC, attivo_passivo); + m.set_handler (F_UTILEC, costi_ricavi); + m.set_handler (F_PERDEC, costi_ricavi); + m.set_handler (abilita_anni); + + tasto = m.run(); + + if (tasto == K_ENTER) + { + _annoesch = m.get_int(F_ANNOCH); + _annoesap = m.get_int(F_ANNO); + _dataregch = m.get (F_DATAC); + _codcausch = m.get (F_CHIUSURA); + _dataregap = m.get (F_DATAAP); + _codcausap = m.get (F_APERTURA); + if (_esc->exist(_annoesch)) + _datacompch = _esc->esercizio(_annoesch).fine(); + gbilch = m.get_int (F_BILCHG); + cbilch = m.get_int (F_BILCHC); + sbilch = m.get_long(F_BILCHS); + gproper = m.get_int (F_PROPERG); + cproper = m.get_int (F_PROPERC); + sproper = m.get_long(F_PROPERS); + gbilap = m.get_int (F_BILAPG); + cbilap = m.get_int (F_BILAPC); + sbilap = m.get_long(F_BILAPS); + gutilp = m.get_int (F_UTILPG); + cutilp = m.get_int (F_UTILPC); + sutilp = m.get_long(F_UTILPS); + gperdp = m.get_int (F_PERDPG); + cperdp = m.get_int (F_PERDPC); + sperdp = m.get_long(F_PERDPS); + gutile = m.get_int (F_UTILEG); + cutile = m.get_int (F_UTILEC); + sutile = m.get_long(F_UTILES); + gperde = m.get_int (F_PERDEG); + cperde = m.get_int (F_PERDEC); + sperde = m.get_long(F_PERDES); + gacutp = m.get_int (F_ACUTPG); + cacutp = m.get_int (F_ACUTPC); + sacutp = m.get_long(F_ACUTPS); + + _tcbilch.set (gbilch,cbilch,sbilch); + _tcproper.set(gproper,cproper,sproper); + _tcbilap.set (gbilap,cbilap,sbilap); + _tcutilp.set (gutilp,cutilp,sutilp); + _tcperdp.set (gperdp,cperdp,sperdp); + _tcutile.set (gutile,cutile,sutile); + _tcperde.set (gperde,cperde,sperde); + _tcacutp.set (gacutp,cacutp,sacutp); + + long cicli = (_cur->items() * 8) + 4; + _prog = new TProgind(cicli,TR("Chiusura/Apertura conti in corso... Prego attendere"),FALSE); + + TRelation rel("&NPENT"); + TCursor cur(&rel); + + for( cur = 0L; cur.ok(); ++cur) + { + const TString key = cur.curr().get("CODTAB"); + + _cont_sep.add(key, key); + } + _cont_sep.add(EMPTY_STRING, EMPTY_STRING); + FOR_EACH_ASSOC_STRING(_cont_sep, obj, key, str) + { + _cod_cont_sep = key; + _numreg = 0; + (*_cur) = 0L; + _sld->set_anno_es(_annoesch); + _sld->set_movprovv(FALSE); + _sld->set_tipo_saldo(chiusura); + _sld->set_movimentato(TRUE); + + costi(); + *_cur = 0l; + ricavi(); + chiusura_conto_economico(); + _totale_saldo = ZERO; + *_cur = 0l; + chiudi_attivita(); + *_cur = 0l; + chiudi_passivita(); + *_cur = 0l; + chiudi_conti_ordine(); + chiusura_conto_patrimoniale(); + _totale_saldo = ZERO; + + _sld->set_anno_es(_annoesap); + _sld->set_tipo_saldo(apertura); + _sld->set_movimentato(TRUE); + + *_cur = 0l; + apri_attivita(); + *_cur = 0l; + apri_passivita(); + *_cur = 0l; + apri_conti_ordine(); + } + apertura_capitale_netto(); + + delete _prog; + message_box(TR("Apertura/chiusura conti completata")); + } //K_ENTER + return FALSE; +} + +void TApertura_chiusura::compila_testata(int annoes,const TDate& datareg,const TString& codcaus,const TDate& datacomp) +{ + _numreg = ultima_registrazione(); + + _pn->curr().zero(); + _pn->curr().put(MOV_ANNOES, annoes); //Viene generato un movimento + _pn->curr().put(MOV_DATAREG, datareg); //a rottura di conto + _pn->curr().put(MOV_CODCAUS, codcaus); + _pn->curr().put(MOV_NUMREG, _numreg); + _pn->curr().put(MOV_DATACOMP, datacomp); + _pn->curr().put(MOV_CONTSEP, _cod_cont_sep); +} + +void TApertura_chiusura::rmov_proper(int anno,long numrig,TDate& datareg,TRectype& rmov, + TConto& tc,real& tot_saldo,bool sezione_opposta) +{ + char sez_rmov = ' '; + char sezione = ' '; + real totale = tot_saldo; + + rmov.zero(); + rmov.put(RMV_ANNOES, anno); + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_DATAREG, datareg); + rmov.put(RMV_GRUPPO, tc.gruppo()); + rmov.put(RMV_CONTO, tc.conto()); + rmov.put(RMV_SOTTOCONTO, tc.sottoconto()); + + if (totale > ZERO) + { + sez_rmov = 'A'; + sezione = 'D'; + } + else + if (totale < ZERO) + { + sez_rmov = 'D'; + sezione = 'A'; + totale = -totale; + } + + if (sezione_opposta) + { + rmov.put(RMV_SEZIONE, sez_rmov); + _sld->aggiorna(tc,TImporto(sez_rmov,totale)); //Aggiorno anche i saldi con + // l'oggetto TSaldo_agg + } + else + { + rmov.put(RMV_SEZIONE, sezione); + _sld->aggiorna(tc,TImporto(sezione,totale)); //Aggiorno anche i saldi con + //l'oggetto TSaldo_agg + } + rmov.put(RMV_IMPORTO, totale); +} + +void TApertura_chiusura::registra_pn() +{ + _pn->write(); + _pn->destroy_rows(_numreg); //Azzero l'oggetto pn. + + _sld->set_num_ulmov(_numreg); + _sld->set_data_ulmov(_pn->curr().get_date(MOV_DATAREG)); + _sld->registra(); + _sld->reset(); +} + +void TApertura_chiusura::costi() +{ + bool compila_mov = TRUE; + long s; + char sez_rmov = ' ', sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + _totale_saldo = ZERO; + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 3) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec(saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(); ; saldi.next()) + { + _saldo = ZERO; + + if (saldi.eof() || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE); + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 1 Chiusura Costi + compila_mov = FALSE; + } + + s = saldi.get_long(SLD_SOTTOCONTO); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + + if (_saldo.is_zero()) + continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + if (tot_saldo != ZERO) + rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE); + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 1 Chiusura Costi + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo >= ZERO) + sezione = 'D'; + else + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + sez_rmov = 'A'; // finito di leggere i sottoconti, oppure + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta alla somma, mandando a zero + { // il saldo di quel movimento. + sez_rmov = 'D'; + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcproper.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 3) + } // for pcon +} + +void TApertura_chiusura::ricavi() +{ + bool compila_mov = TRUE; + long s; + char sez_rmov = ' ', sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 4) + { + compila_mov = TRUE; + + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec(saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(); ; saldi.next()) + { + _saldo = ZERO; + + if (saldi.eof() || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE); + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 2 Chiusura Ricavi + compila_mov = FALSE; + } + + //numrig++; + s = saldi.get_long(SLD_SOTTOCONTO); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + + if (_saldo.is_zero()) continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + // numrig++; + if (tot_saldo != ZERO) + rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE); + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 2 Chiusura Ricavi + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo > ZERO) + sezione = 'D'; + else + if (_saldo < ZERO) + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + sez_rmov = 'A'; // finito di leggere i sottoconti, oppure + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta + if (sezione == 'A') // alla somma, mandando a zero + { // il saldo di quel movimento. + sez_rmov = 'D'; + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcproper.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 4) + } // for pcon +} + +void TApertura_chiusura::chiusura_conto_economico() +{ + _capitale_netto = _totale_saldo; //Mi serve per fare la riapertura del capitale netto + + if (_totale_saldo.is_zero()) + return; + + if (_totale_saldo > ZERO) + { + int j; + + //Compilo la testata per perdite di es. c.economico a Profitti e Perdite + //Chiusura conto economico + + j = 0; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 3 Chiusura Conto Economico + + TRectype& rmov1 = _pn->cg(j); + long numrig = 1; + rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcproper,_totale_saldo,TRUE); + _tcperde.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperde,_totale_saldo,FALSE); + _tcproper.put(rmov2, TRUE); // Contropartita + + registra_pn(); + + //Compilo la testata per perdite di es. c.patrimon. a Perdita di es. c. econom. + //Chiusura capitale netto + + j = 0; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 4 Chiusura Capitale netto + + TRectype& rmov3 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcperde,_totale_saldo,TRUE); + _tcperdp.put(rmov3, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov4 = _pn->cg(j); + rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcperdp,_totale_saldo,FALSE); + _tcperde.put(rmov4, TRUE); // Contropartita + + registra_pn(); + } + else + { + int j; + + //Compilo la testata per Profitti e perdite a Utile di es. c.economico + //Chiusura conto economico + + j = 0; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 3 Chiusura Conto Economico + + TRectype& rmov1 = _pn->cg(j); + long numrig = 1; + rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutile,_totale_saldo,FALSE); + _tcproper.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcproper,_totale_saldo,TRUE); + _tcutile.put(rmov2, TRUE); // Contropartita + + registra_pn(); + + //Compilo la testata per Utile di es. c.economico a Utile di es. c.patrimoniale + //Chiusura capitale netto + + j = 0; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 4 Chiusura Capitale netto + + TRectype& rmov3 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcutilp,_totale_saldo,FALSE); + _tcutile.put(rmov3, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov4 = _pn->cg(j); + rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcutile,_totale_saldo,TRUE); + _tcutilp.put(rmov4, TRUE); // Contropartita + + registra_pn(); + } +} + +void TApertura_chiusura::chiudi_attivita() +{ + bool compila_mov = TRUE; + long s; + char sez_rmov = ' ', sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 1) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec(saldi.curr()); + + j = 0; + numrig = 0; + + for (int err = saldi.read(_isgteq); ; saldi.next()) + { + if (saldi.eof() || err != NOERR || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita' + compila_mov = FALSE; + } + + s = saldi.get_long(SLD_SOTTOCONTO); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + const int dbkey = saldi.getkey(); + saldi.setkey(1); + + if (_saldo == ZERO) continue; // *** TBC qui fa ciclo infinito + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + // numrig++; + if (tot_saldo != ZERO) + rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita' + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo >= ZERO) + sezione = 'D'; + else + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + sez_rmov = 'A'; // finito di leggere i sottoconti, oppure + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta + if (sezione == 'A') // alla somma, mandando a zero + { // il saldo di quel movimento. + sez_rmov = 'D'; + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcbilch.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg + + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 1) + } // for pcon +} + +void TApertura_chiusura::chiudi_passivita() +{ + bool compila_mov = TRUE; + long s; + char sez_rmov = ' ', sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 2) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec (saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(); ; saldi.next()) + { + if ((saldi.curr() != rec) || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 6 Chiusura Passivita' + compila_mov = FALSE; + } + + //numrig++; + s = saldi.get_long(SLD_SOTTOCONTO); + //sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + + if (_saldo.is_zero()) continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + // numrig++; + if (tot_saldo != ZERO) + rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 6 Chiusura Passivita' + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo >= ZERO) + sezione = 'D'; + else + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + sez_rmov = 'A'; // finito di leggere i sottoconti, oppure + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta alla somma, mandando a zero + { // il saldo di quel movimento. + sez_rmov = 'D'; + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcbilch.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg + + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 2) + } // for pcon +} + +void TApertura_chiusura::chiudi_conti_ordine() +{ + bool compila_mov = TRUE; + long s; + char sez_rmov = ' ', sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 5) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec(saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(_isgteq); ; saldi.next()) + { + if (saldi.eof() || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); + compila_mov = FALSE; + } + + s = saldi.get_long(SLD_SOTTOCONTO); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + const int dbkey = saldi.getkey(); + saldi.setkey(1); + + if (_saldo == ZERO) continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + if (tot_saldo != ZERO) + rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita' + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo >= ZERO) + sezione = 'D'; + else + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + sez_rmov = 'A'; // finito di leggere i sottoconti, oppure + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta alla somma, mandando a zero + { // il saldo di quel movimento. + sez_rmov = 'D'; + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcbilch.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg + + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 1) + } // for pcon +} + +void TApertura_chiusura::chiusura_conto_patrimoniale() +{ + int j; + long numrig; + + if (_totale_saldo > ZERO) + { + //Compilo la testata per Bilancio di chiusura a Perdita di es. c. patrimoniale + //Chiusura conto patrimoniale + + j = 0; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 7 Chiusura Conto Patrimoniale + + TRectype& rmov1 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutilp,_totale_saldo,FALSE); + _tcbilch.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcbilch,_totale_saldo,TRUE); + _tcutilp.put(rmov2, TRUE); // Contropartita + + registra_pn(); + } + else + if (_totale_saldo < ZERO) + { + //Compilo la testata per Utile di es. c.patrimon. a Bilancio di chiusura + //Chiusura conto patrimoniale + + j = 0; + compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 7 Chiusura Conto Patrimoniale + + TRectype& rmov1 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcbilch,_totale_saldo,TRUE); + _tcperdp.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperdp,_totale_saldo,FALSE); + _tcbilch.put(rmov2, TRUE); // Contropartita + + registra_pn(); + } +} + +void TApertura_chiusura::apri_attivita() +{ + bool compila_mov = TRUE; + long s; + char sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 1) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec (saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(); ; saldi.next()) + { + if (saldi.eof() || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita' + compila_mov = FALSE; + } + + //numrig++; + s = saldi.get_long(SLD_SOTTOCONTO); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + + if (_saldo == ZERO) continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + if (tot_saldo != ZERO) + rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Chiusura + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita' + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo > ZERO) + sezione = 'D'; + else + if (_saldo < ZERO) + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta + if (sezione == 'A') // alla somma, mandando a zero + { // il saldo di quel movimento. + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesap); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregap); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sezione); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcbilap.put(rmov, TRUE); // Contropartita + + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sezione,_saldo)); //l'oggetto TSaldo_agg + + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 1) + } // for pcon +} + +void TApertura_chiusura::apri_passivita() +{ + bool compila_mov = TRUE; + long s; + char sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 2) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec(saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(); ; saldi.next()) + { + if (saldi.eof() || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 9 Apertura Passivita' + compila_mov = FALSE; + } + + //numrig++; + s = saldi.get_long(SLD_SOTTOCONTO); + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + + if (_saldo.is_zero()) continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + if (tot_saldo != ZERO) + rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 9 Apertura Passivita' + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo > ZERO) + sezione = 'D'; + else + if (_saldo < ZERO) + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + tot_saldo += _saldo; // finito di leggere i sottoconti, oppure + _totale_saldo += _saldo; // quando ho raggiunto un massimo di 99 + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta + if (sezione == 'A') // alla somma, mandando a zero + { // il saldo di quel movimento. + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesap); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregap); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sezione); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcbilap.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sezione,_saldo)); //l'oggetto TSaldo_agg + + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 2) + } // for pcon +} + +void TApertura_chiusura::apri_conti_ordine() +{ + bool compila_mov = TRUE; + long s; + char sezione = ' '; + real tot_saldo; + long numrig = 0; + TSaldo& sale = *_sale; + int j = 0; + TLocalisamfile saldi(LF_SALDI); + + tot_saldo = ZERO; + + TRecnotype items_pcon = _cur->items(); + + for (int i = 0; i < items_pcon; i++, ++(*_cur)) + { + int indbil = _cur->curr().get_int(PCN_INDBIL); + int g = _cur->curr().get_int(PCN_GRUPPO); + int c = _cur->curr().get_int(PCN_CONTO); + TString tmcf = _cur->curr().get (PCN_TMCF); + + _prog->addstatus(1); + + if (indbil == 5) + { + compila_mov = TRUE; + + saldi.setkey(1); + saldi.zero(); + saldi.put(SLD_ANNOES, _annoesch); + saldi.put(SLD_GRUPPO, g); + saldi.put(SLD_CONTO, c); + saldi.put(SLD_FLSCA, FALSE); + + const TRectype rec(saldi.curr()); + + j = 0; + numrig = 0; + + for (saldi.read(); ; saldi.next()) + { + if (saldi.eof() || (saldi.curr() != rec)) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso conto, indicandola + // con una sezione opposta al risultato (della somma). + + if (j >= 1) + { + numrig++; + if (tot_saldo != ZERO) + rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura + + tot_saldo = ZERO; + } + break; + } + + if (compila_mov) + { + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita' + compila_mov = FALSE; + } + + //numrig++; + s = saldi.get_long(SLD_SOTTOCONTO); + + sale.saldo_cont_sep(g, c, s, _annoesch, botime, indbil, _cod_cont_sep, false); + _saldo = sale.saldo(); + + if (_saldo == ZERO) continue; + + numrig++; + + if (j >= MAX_CG_ROWS || saldi.eof()) + { + // Aggiungo un ulteriore riga di movimento contenente la somma + // di tutti i saldi aventi lo stesso sottoconto, indicandola + // con una sezione opposta al risultato (della somma). + + if (tot_saldo != ZERO) + rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Chiusura + registra_pn(); + + j = 0; + numrig = 1; + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita' + compila_mov = FALSE; + tot_saldo = ZERO; + } + + if (_saldo > ZERO) + sezione = 'D'; + else + if (_saldo < ZERO) + { + sezione = 'A'; + _saldo = -_saldo; + } + + if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli + { // importi trovati sui saldi. Quando ho + tot_saldo += _saldo; // quando ho raggiunto un massimo di 99 + _totale_saldo += _saldo; + } // righe di movimento, genero un' altra + else // riga con importo di sezione opposta + if (sezione == 'A') // alla somma, mandando a zero + { // il saldo di quel movimento. + tot_saldo -= _saldo; + _totale_saldo -= _saldo; + } + + if (!saldi.eof()) + { + TRectype& rmov = _pn->cg(j); + + rmov.zero(); + rmov.put(RMV_ANNOES, _annoesap); //Compilo una riga di movimento + rmov.put(RMV_DATAREG, _dataregap); //per ogni sottoconto che leggo + rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste + rmov.put(RMV_CONTO, c); //righe servono per mandare a 0 + rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la + rmov.put(RMV_SEZIONE, sezione); //sezione sara' opposta a + rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi. + rmov.put(RMV_NUMREG, _numreg); + rmov.put(RMV_NUMRIG, numrig); + rmov.put(RMV_TIPOC, tmcf); + _tcbilap.put(rmov, TRUE); // Contropartita + + TBill tc(g,c,s); + _sld->aggiorna(tc,TImporto(sezione,_saldo)); //l'oggetto TSaldo_agg + + j++; + } + if (saldi.eof()) break; + } //for saldi + if (j >= 1) + { + registra_pn(); + j = 0; + } + } // if (indbil == 1) + } // for pcon +} + +void TApertura_chiusura::apertura_capitale_netto() +{ + int numrig; + + if (_capitale_netto > ZERO) + { + //Compilo la testata per Perdita es. c/to patrimoniale a Bilancio di apertura + //Apertura capitale netto + + int j = 0; + + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 10 Apertura Capitale netto + + TRectype& rmov1 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcbilap,_capitale_netto,TRUE); + _tcperdp.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcperdp,_capitale_netto,FALSE); + _tcbilap.put(rmov2, TRUE); // Contropartita + + registra_pn(); + if (_tcacutp.ok()) + { + j = 0; + + compila_testata(_annoesap,_dataregap, EMPTY_STRING,_dataregap); //Reg. 10 Apertura Capitale netto + _pn->curr().put(MOV_DESCR, "Giroconto Perdita Esercizio"); //Viene generato un movimento + + TRectype& rmov1 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcacutp,_capitale_netto,FALSE); + _tcperdp.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcperdp,_capitale_netto,TRUE); + _tcacutp.put(rmov2, TRUE); // Contropartita + + registra_pn(); + } + } + else + if (_capitale_netto < ZERO) + { + //Compilo la testata per Bilancio di apertura a Utile es. c/to patrimoniale + //Apertura capitale netto + + int j = 0; + + compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 10 Apertura Capitale netto + + TRectype& rmov1 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcbilap,_capitale_netto,TRUE); + _tcutilp.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcutilp,_capitale_netto,FALSE); + _tcbilap.put(rmov2, TRUE); // Contropartita + + registra_pn(); + if (_tcacutp.ok()) + { + j = 0; + + compila_testata(_annoesap,_dataregap, EMPTY_STRING,_dataregap); //Reg. 10 Apertura Capitale netto + _pn->curr().put(MOV_DESCR, "Giroconto Utile Esercizio"); //Viene generato un movimento + + TRectype& rmov1 = _pn->cg(j); + numrig = 1; + rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcacutp,_capitale_netto,FALSE); + _tcutilp.put(rmov1, TRUE); // Contropartita + + numrig++; + j++; + TRectype& rmov2 = _pn->cg(j); + rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcutilp,_capitale_netto,TRUE); + _tcacutp.put(rmov2, TRUE); // Contropartita + + registra_pn(); + } + } +} + +void TApertura_chiusura::main_loop() +{ + set(); +} + +int np0200 (int argc, char* argv[]) +{ + TApertura_chiusura main_app; + main_app.run(argc, argv, TR("Apertura/Chiusura Conti")); + return TRUE; +} + + + + + + + diff --git a/np/np0200.h b/np/np0200.h new file mode 100755 index 000000000..2e69a1b57 --- /dev/null +++ b/np/np0200.h @@ -0,0 +1,37 @@ +#ifndef __CG4600_H +#define __CG4600_H + +#define F_CODDITTA 101 +#define F_RAGSOC 102 +#define F_CHIUSURA 103 +#define F_APERTURA 104 +#define F_DATAC 105 +#define F_DATAAP 106 +#define F_BILCHG 107 +#define F_BILCHC 108 +#define F_BILCHS 109 +#define F_PROPERG 110 +#define F_PROPERC 111 +#define F_PROPERS 112 +#define F_BILAPG 113 +#define F_BILAPC 114 +#define F_BILAPS 115 +#define F_UTILPG 116 +#define F_UTILPC 117 +#define F_UTILPS 118 +#define F_PERDPG 119 +#define F_PERDPC 120 +#define F_PERDPS 121 +#define F_UTILEG 122 +#define F_UTILEC 123 +#define F_UTILES 124 +#define F_PERDEG 125 +#define F_PERDEC 126 +#define F_PERDES 127 +#define F_ANNO 128 +#define F_ANNOCH 129 +#define F_ACUTPG 130 +#define F_ACUTPC 131 +#define F_ACUTPS 132 + +#endif // __CG4600_H diff --git a/np/np0200a.uml b/np/np0200a.uml new file mode 100644 index 000000000..0a1c53f49 --- /dev/null +++ b/np/np0200a.uml @@ -0,0 +1,363 @@ +#include "np0200.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Apertura/Chiusura conti a contabiltà separata" -1 -1 76 19 + +NUMBER F_CODDITTA 5 +BEGIN + PROMPT 2 1 "Ditta " + FLAGS "FRD" + USE LF_NDITTE KEY 1 + CHECKTYPE REQUIRED + INPUT CODDITTA F_CODDITTA + DISPLAY "Codice" CODDITTA + DISPLAY "Ragione sociale @50" RAGSOC + OUTPUT F_CODDITTA CODDITTA + OUTPUT F_RAGSOC RAGSOC +END + + +STRING F_RAGSOC 50 +BEGIN + PROMPT 2 2 "Ragione sociale " + FLAGS "D" +END + +STRING F_CHIUSURA 3 +BEGIN + PROMPT 2 4 "Codice causale chiusura " + USE LF_CAUSALI KEY 1 SELECT MOVAP="C" + INPUT CODCAUS F_CHIUSURA + DISPLAY "Codice" CODCAUS + DISPLAY "Descrizione @50" DESCR + OUTPUT F_CHIUSURA CODCAUS + CHECKTYPE REQUIRED + FLAGS "UZ" +END + +STRING F_APERTURA 3 +BEGIN + PROMPT 2 5 "Codice causale apertura " + USE LF_CAUSALI KEY 1 SELECT MOVAP="A" + FLAGS "UZ" + INPUT CODCAUS F_APERTURA + DISPLAY "Codice" CODCAUS + DISPLAY "Descrizione@50" DESCR + OUTPUT F_APERTURA CODCAUS + CHECKTYPE REQUIRED +END + +DATE F_DATAC +BEGIN + PROMPT 36 4 "Data/Anno chiusura " + HELP "Data in cui effettuare il movimento di chiusura" +END + +DATE F_DATAAP +BEGIN + PROMPT 36 5 "Data/Anno apertura " + HELP "Data in cui effettuare il movimento di apertura" + WARNING "Inserire una data non inferiore alla data di chiusura" + VALIDATE DATE_CMP_FUNC >= F_DATAC +END + +NUMBER F_ANNOCH 4 +BEGIN + PROMPT 69 4 "" + USE ESC + INPUT CODTAB F_ANNOCH + DISPLAY "Codice" CODTAB + DISPLAY "Inizio Es.@12" D0 + DISPLAY "Fine Es.@12" D1 + DISPLAY "Scarico@12" D2 + OUTPUT F_ANNOCH CODTAB + OUTPUT F_DATAC D1 + CHECKTYPE REQUIRED + WARNING "Codice non presente in tabella esercizi" + FLAGS "GRZD" + ADD RUN cg0 -5 esc +END + +NUMBER F_ANNO 4 +BEGIN + PROMPT 69 5 "" + COPY USE F_ANNOCH + INPUT CODTAB F_ANNO + COPY DISPLAY F_ANNOCH + OUTPUT F_ANNO CODTAB + OUTPUT F_DATAAP D0 + CHECKTYPE REQUIRED + WARNING "Anno non presente in tabella esercizi" + FLAGS "GRZD" + ADD RUN cg0 -5 esc +END + + +GROUPBOX DLG_NULL 60 11 +BEGIN + PROMPT 2 7 "@bCodici sottoconto" +END + +NUMBER F_BILCHG 3 +BEGIN + PROMPT 3 9 "Bilancio di chiusura " + HELP "Codice conto di riepilogo del bilancio di chiusura" + USE LF_PCON KEY 1 SELECT SOTTOCONTO!="" + DISPLAY "Gruppo" GRUPPO + DISPLAY "Conto" CONTO + DISPLAY "Sottoconto" SOTTOCONTO + DISPLAY "Descrizione @50" DESCR + OUTPUT F_BILCHG GRUPPO + OUTPUT F_BILCHC CONTO + OUTPUT F_BILCHS SOTTOCONTO + INPUT GRUPPO F_BILCHG + INPUT CONTO F_BILCHC + INPUT SOTTOCONTO F_BILCHS +END + +NUMBER F_BILCHC 3 +BEGIN + PROMPT 44 9 "" + HELP "Codice conto di riepilogo del bilancio di chiusura" + COPY ALL F_BILCHG +END + +NUMBER F_BILCHS 6 +BEGIN + PROMPT 51 9 "" + HELP "Codice conto di riepilogo del bilancio di chiusura" + COPY ALL F_BILCHG + CHECKTYPE REQUIRED +END + +NUMBER F_PROPERG 3 +BEGIN + PROMPT 3 10 "Profitti e perdite " + HELP "Codice conto di riepilogo del Profitti e perdite" + COPY USE F_BILCHG + COPY DISPLAY F_BILCHG + OUTPUT F_PROPERG GRUPPO + OUTPUT F_PROPERC CONTO + OUTPUT F_PROPERS SOTTOCONTO + INPUT GRUPPO F_PROPERG + INPUT CONTO F_PROPERC + INPUT SOTTOCONTO F_PROPERS +END + +NUMBER F_PROPERC 3 +BEGIN + PROMPT 44 10 "" + HELP "Codice conto di riepilogo del Profitti e perdite" + COPY USE F_BILCHG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_PROPERG + COPY INPUT F_PROPERG +END + +NUMBER F_PROPERS 6 +BEGIN + PROMPT 51 10 "" + HELP "Codice conto di riepilogo del Profitti e perdite" + COPY ALL F_PROPERC + CHECKTYPE REQUIRED +END + +NUMBER F_BILAPG 3 +BEGIN + PROMPT 3 11 "Bilancio di apertura " + HELP "Codice conto di riepilogo del Bilancio di apertura" + COPY USE F_BILCHG + COPY DISPLAY F_BILCHG + OUTPUT F_BILAPG GRUPPO + OUTPUT F_BILAPC CONTO + OUTPUT F_BILAPS SOTTOCONTO + INPUT GRUPPO F_BILAPG + INPUT CONTO F_BILAPC + INPUT SOTTOCONTO F_BILAPS +END + +NUMBER F_BILAPC 3 +BEGIN + PROMPT 44 11 "" + HELP "Codice conto di riepilogo del Bilancio di apertura" + COPY USE F_BILCHG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_BILAPG + COPY INPUT F_BILAPG +END + +NUMBER F_BILAPS 6 +BEGIN + PROMPT 51 11 "" + HELP "Codice conto di riepilogo del Bilancio di apertura" + COPY ALL F_BILAPC + CHECKTYPE REQUIRED +END + +NUMBER F_UTILPG 3 +BEGIN + PROMPT 3 12 "Utile d'esercizio c/to patrim. " + HELP "Codice conto patrimoniale in cui ripilogare l'utile d'esercizio" + USE LF_PCON KEY 1 SELECT (SOTTOCONTO!="") + COPY DISPLAY F_BILCHG + OUTPUT F_UTILPG GRUPPO + OUTPUT F_UTILPC CONTO + OUTPUT F_UTILPS SOTTOCONTO + INPUT GRUPPO F_UTILPG + INPUT CONTO F_UTILPC + INPUT SOTTOCONTO F_UTILPS +END + +NUMBER F_UTILPC 3 +BEGIN + PROMPT 44 12 "" + HELP "Codice conto patrimoniale in cui ripilogare l'utile d'esercizio" + COPY USE F_UTILPG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_UTILPG + COPY INPUT F_UTILPG +END + +NUMBER F_UTILPS 6 +BEGIN + PROMPT 51 12 "" + HELP "Codice conto patrimoniale in cui ripilogare l'utile d'esercizio" + COPY ALL F_UTILPC + CHECKTYPE REQUIRED +END + +NUMBER F_PERDPG 3 +BEGIN + PROMPT 3 13 "Perdita d'esercizio c/to patr. " + HELP "Codice conto patrimoniale in cui ripilogare la perdita d'esercizio" + USE LF_PCON KEY 1 SELECT (SOTTOCONTO!="") + COPY DISPLAY F_BILCHG + OUTPUT F_PERDPG GRUPPO + OUTPUT F_PERDPC CONTO + OUTPUT F_PERDPS SOTTOCONTO + INPUT GRUPPO F_PERDPG + INPUT CONTO F_PERDPC + INPUT SOTTOCONTO F_PERDPS +END + +NUMBER F_PERDPC 3 +BEGIN + PROMPT 44 13 "" + HELP "Codice conto patrimoniale in cui ripilogare la perdita d'esercizio" + COPY USE F_PERDPG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_PERDPG + COPY INPUT F_PERDPG +END + +NUMBER F_PERDPS 6 +BEGIN + PROMPT 51 13 "" + HELP "Codice conto patrimoniale in cui ripilogare la perdita d'esercizio" + COPY ALL F_PERDPC + CHECKTYPE REQUIRED +END + +NUMBER F_UTILEG 3 +BEGIN + PROMPT 3 14 "Utile d'esercizio c/to econom. " + HELP "Codice conto economico in cui ripilogare l'utile d'esercizio" + USE LF_PCON KEY 1 SELECT (SOTTOCONTO!="") + COPY DISPLAY F_BILCHG + OUTPUT F_UTILEG GRUPPO + OUTPUT F_UTILEC CONTO + OUTPUT F_UTILES SOTTOCONTO + INPUT GRUPPO F_UTILEG + INPUT CONTO F_UTILEC + INPUT SOTTOCONTO F_UTILES +END + +NUMBER F_UTILEC 3 +BEGIN + PROMPT 44 14 "" + HELP "Codice conto economico in cui ripilogare l'utile d'esercizio" + COPY USE F_UTILEG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_UTILEG + COPY INPUT F_UTILEG +END + +NUMBER F_UTILES 6 +BEGIN + PROMPT 51 14 "" + HELP "Codice conto economico in cui ripilogare l'utile d'esercizio" + COPY ALL F_UTILEC + CHECKTYPE REQUIRED +END + +NUMBER F_PERDEG 3 +BEGIN + PROMPT 3 15 "Perdita d'esercizio c/to econ. " + HELP "Codice conto economico in cui ripilogare la perdita d'esercizio" + USE LF_PCON KEY 1 SELECT (SOTTOCONTO!="") + COPY DISPLAY F_BILCHG + OUTPUT F_PERDEG GRUPPO + OUTPUT F_PERDEC CONTO + OUTPUT F_PERDES SOTTOCONTO + INPUT GRUPPO F_PERDEG + INPUT CONTO F_PERDEC + INPUT SOTTOCONTO F_PERDES + +END + +NUMBER F_PERDEC 3 +BEGIN + PROMPT 44 15 "" + HELP "Codice conto economico in cui ripilogare la perdita d'esercizio" + COPY USE F_PERDEG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_PERDEG + COPY INPUT F_PERDEG +END + +NUMBER F_PERDES 6 +BEGIN + PROMPT 51 15 "" + HELP "Codice conto economico in cui ripilogare la perdita d'esercizio" + COPY ALL F_PERDEC + CHECKTYPE REQUIRED +END + +NUMBER F_ACUTPG 3 +BEGIN + PROMPT 3 16 "Accantonamento utili " + HELP "Codice del conto patrimoniale per l'accantonamento utili" + USE LF_PCON KEY 1 SELECT (SOTTOCONTO!="") + COPY DISPLAY F_BILCHG + OUTPUT F_ACUTPG GRUPPO + OUTPUT F_ACUTPC CONTO + OUTPUT F_ACUTPS SOTTOCONTO + INPUT GRUPPO F_ACUTPG + INPUT CONTO F_ACUTPC + INPUT SOTTOCONTO F_ACUTPS +END + +NUMBER F_ACUTPC 3 +BEGIN + PROMPT 44 16 "" + HELP "Codice del conto patrimoniale per l'accantonamento utili" + COPY USE F_UTILPG + COPY DISPLAY F_BILCHG + COPY OUTPUT F_ACUTPG + COPY INPUT F_ACUTPG + CHECKTYPE NORMAL +END + +NUMBER F_ACUTPS 6 +BEGIN + PROMPT 51 16 "" + HELP "Codice del conto patrimoniale per l'accantonamento utili" + COPY ALL F_ACUTPC +END + +ENDPAGE + +ENDMASK