// Chiusura/Apertura Conti #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include bool mask_datac (TMask_field&, KEY); bool mask_dataap (TMask_field&, KEY); bool mask_distinti (TMask_field&, KEY); #define MAX 200 class CG4600_application : public TApplication { friend bool mask_datac (TMask_field&, KEY); friend bool mask_dataap (TMask_field&, KEY); friend bool mask_distinti (TMask_field&, KEY); TTable* _esc, * _reg; TRelation* _rel; TMovimentoPN* _pn; TLocalisamfile* _saldi; TRectype* _rec; TLocalisamfile* _mov; TCursor* _cur; TSaldo_agg* _sld; Saldo* _sale; TConto _tcbilch,_tcproper,_tcbilap,_tcutilp,_tcperdp,_tcutile,_tcperde, _conto_corrente; real _saldo, _totale_saldo; int _annoesch, _annoesap; long _numreg; TDate _dataregap, _dataregch, _data_inizioap, _data_finech; TString _codcausap, _codcausch; public: virtual bool create(); virtual bool destroy(); virtual bool menu(MENU_TAG m); void costi (); void ricavi(); void attivita(); void passivita(); void rmov_proper (int, long, TDate&, TRectype&, TConto&, real&, bool); void ultima_registrazione(); void compila_testata(int,TDate&,TDate&,TString&); void chiusura_conto_economico(); void chiusura_conto_patrimoniale(); bool set(); // bool epilogo_conti(); CG4600_application() {} }; HIDDEN CG4600_application* app() { return (CG4600_application *) MainApp(); } bool mask_datac (TMask_field& f, KEY k) { TTable TabEs ("ESC"); TTable TabReg("REG"); TString annos (4); int anno = 0;; bool ok = TRUE; if ( (k == K_ENTER) && f.to_check(k) ) { TabEs.last(); TDate inizio = TabEs.get_date("D0"); TDate fine = TabEs.get_date("D1"); TDate scarico = TabEs.get_date("D2"); TabEs.prev(); TDate iniziop = TabEs.get_date("D0"); TDate finep = TabEs.get_date("D1"); if (f.get() < finep) { f.warning_box ("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente"); return FALSE; } if (f.get() > fine) { f.warning_box ("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso"); return FALSE; } if ( scarico.ok() && (f.get() <= scarico) ) { f.warning_box ("La data di chiusura non puo' essere inferiore o uguale alla data di scarico"); return FALSE; } if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso anno = fine.year(); else if ( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente anno = finep.year(); TabReg.zero(); annos = format ("%04d", anno); TabReg.put ("CODTAB", annos); TRectype r (TabReg.curr()); TabReg.read(_isgteq); for (; !TabReg.eof(); TabReg.next()) { if (TabReg.curr() != r) break; int tiporeg = TabReg.get_int("I0"); if (tiporeg == 5) { TDate datast = TabReg.get_date("D3"); if (f.get() < datast.string()) { ok = FALSE; break; } } } if (!ok) { f.warning_box("La data di chiusura non puo' essere inferiore alla data ultima stampa bollato"); return FALSE; } } return TRUE; } bool mask_dataap (TMask_field& f, KEY k) { TTable TabEs ("ESC"); TTable TabReg("REG"); int anno = 0; TString annos (4); bool ok = TRUE; if ( (k == K_ENTER) && f.to_check(k) ) { TabEs.last(); TDate inizio = TabEs.get_date("D0"); TDate fine = TabEs.get_date("D1"); TDate scarico = TabEs.get_date("D2"); TabEs.prev(); TDate iniziop = TabEs.get_date("D0"); TDate finep = TabEs.get_date("D1"); if (f.get() < inizio) { f.warning_box ("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso"); return FALSE; } if (f.get() > fine) { f.warning_box ("La data di apertura non puo' essere superiore alla data di fine esercizio in corso"); return FALSE; } if ( scarico.ok() && (f.get() <= scarico) ) { f.warning_box ("La data di apertura non puo' essere inferiore o uguale alla data di scarico"); return FALSE; } if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso anno = fine.year(); else if( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente anno = finep.year(); TabReg.zero(); annos = format ("%04d", anno); TabReg.put ("CODTAB", annos); TRectype r (TabReg.curr()); TabReg.read(_isgteq); for (; !TabReg.eof(); TabReg.next()) { if (TabReg.curr() != r) break; int tiporeg = TabReg.get_int("I0"); if (tiporeg == 5) { TDate datast = TabReg.get_date("D3"); if (f.get() < datast) { ok = FALSE; break; } } } if (!ok) { f.warning_box("La data di apertura non puo' essere inferiore alla data ultima stampa bollato"); return FALSE; } } return TRUE; } bool mask_distinti (TMask_field& f, KEY k) { int idg,idc,ids,idg1,idc1,ids1; if (k == K_ENTER) { idg = 108; idc = 109; ids = 110; for (int i = 0; i < 7; i++) { int g = f.mask().get_int(idg); int c = f.mask().get_int(idc); long s = f.mask().get_long(ids); idg1 = idg; idc1 = idc; ids1 = ids; for (int j = i+1; j < 7; j++) { idg1 = idg1 + 3; idc1 = idc1 + 3; ids1 = ids1 + 3; int gruppo = f.mask().get_int(idg1); int conto = f.mask().get_int(idc1); long sottoc = f.mask().get_long(ids1); if ((g == gruppo)&&(c == conto)&&(s == sottoc)) { f.warning_box("Nessun sottoconto puo' essere ripetuto!"); return FALSE; } } idg = idg + 3; idc = idc + 3; ids = ids + 3; } } return TRUE; } bool CG4600_application::create() { TApplication::create(); _rel = new TRelation (LF_PCON); _cur = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1); _pn = new TMovimentoPN(); _saldi = new TLocalisamfile (LF_SALDI); _rec = new TRectype(LF_SALDI); _mov = new TLocalisamfile (LF_MOV); _esc = new TTable ("ESC"); _reg = new TTable ("REG"); _sld = new TSaldo_agg(); _sale = new Saldo(); dispatch_e_menu (BAR_ITEM(1)); return TRUE; } bool CG4600_application::destroy() { delete _saldi; delete _sale; delete _mov; delete _esc; delete _reg; delete _pn; delete _rel; delete _cur; delete _sld; delete _rec; return TApplication::destroy(); } void CG4600_application::ultima_registrazione() { long numregmov; _mov->setkey(1); //Leggo il numero di registrazione _mov->last(); //dell'ultimo record di mov, e lo numregmov = _mov->get_long(MOV_NUMREG); //incremento di uno per ottenere _numreg = numregmov + 1; //un numero di registrazione //sicuramente non esistente. } bool CG4600_application::set() { TTable TabEs ("ESC"); TMask m ("cg4600a"); KEY tasto; int gbilch, cbilch , gproper, cproper, gbilap, cbilap, gutilp; int cutilp, gperdp, cperdp, gutile, cutile, gperde, cperde; long sbilch, sproper, sbilap, sutilp, sperdp, sutile, sperde; TConfig conf(CONFIG_DITTA); m.set(F_CHIUSURA, conf.get("CoCaCh")); m.set(F_APERTURA, conf.get("CoCaAp")); TabEs.last(); int annoap = TabEs.get_int ("CODTAB"); TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso _data_inizioap = inizio; TabEs.prev(); int annoch = TabEs.get_int ("CODTAB"); TDate fine = TabEs.get_date("D1"); //data fine es. precedente _data_finech = fine; m.set(F_ANNO, annoap); m.set(F_ANNOCH, annoch); m.set(F_DATAC, fine.string()); m.set(F_DATAAP,inizio.string()); 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_handler (F_DATAC, mask_datac); m.set_handler (F_DATAAP, mask_dataap); m.set_handler (F_PERDES, mask_distinti); 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); 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); _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); ultima_registrazione(); // anno_ese_precedente(); (*_cur) = 0L; _sld->set_anno_es(_annoesch); _sld->set_movprovv(FALSE); _sld->set_movap(FALSE); costi (); _sld->reset(); //Azzera la tabella dei conti dell'oggetto TSaldo_agg _pn->destroy_rows(); //Azzero l'oggetto pn. ultima_registrazione(); *_cur = 0l; ricavi(); _sld->reset(); chiusura_conto_economico(); _totale_saldo = ZERO; _sld->reset(); _pn->destroy_rows(); //Azzero l'oggetto pn. ultima_registrazione(); *_cur = 0l; attivita(); _sld->reset(); _pn->destroy_rows(); //Azzero l'oggetto pn. ultima_registrazione(); *_cur = 0l; passivita(); _sld->reset(); chiusura_conto_patrimoniale(); return TRUE; } //K_ENTER return FALSE; } void CG4600_application::compila_testata(int annoes,TDate& datareg,TDate& datacomp,TString& codcaus) { _pn->lfile()->zero(); _pn->lfile()->put(MOV_ANNOES, annoes); //Viene generato un mov _pn->lfile()->put(MOV_DATAREG, datareg); //quando si incontra il _pn->lfile()->put(MOV_CODCAUS, codcaus); //primo conto con indbil _pn->lfile()->put(MOV_NUMREG, _numreg); _pn->lfile()->put(MOV_DATACOMP, datacomp); } void CG4600_application::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,totale,sez_rmov);//Aggiorno anche i saldi con l'oggetto //TSaldo_agg } else { rmov.put(RMV_SEZIONE, sezione); _sld->aggiorna(tc,totale,sezione);//Aggiorno anche i saldi con l'oggetto //TSaldo_agg } rmov.put(RMV_IMPORTO, totale); } void CG4600_application::costi() { bool compila_mov = TRUE; long s; char sez_rmov = ' ', sezione = ' '; real tot_saldo; long numrig = 0; Saldo& sale = *_sale; _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); if (indbil == 3) { if (compila_mov) { compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 1 compila_mov = FALSE; } _saldi->setkey(1); _saldi->zero(); _saldi->put(SLD_ANNOES, _annoesch); _saldi->put(SLD_GRUPPO, g); _saldi->put(SLD_CONTO, c); (*_rec) = _saldi->curr(); int j = 0; for (_saldi->read(); ; _saldi->next()) { TRectype& rmov = _pn->cg(j); _saldo = ZERO; 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++; rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE); tot_saldo = ZERO; } break; } numrig++; s = _saldi->get_long(SLD_SOTTOCONTO); sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil); _saldo = sale.saldo(); if (_saldo.is_zero()) continue; 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 200 _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 (j == MAX || _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++; rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE); tot_saldo = ZERO; } if (!_saldi->eof()) { 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); TConto tc(g,c,s); _sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg j++; } if (_saldi->eof()) break; } //for saldi if (j >= 1) { _pn->write(); _sld->registra(); j = 0; _pn->destroy_rows(); //Azzero l'oggetto pn. } } // if (indbil == 3) } // for pcon } void CG4600_application::ricavi() { bool compila_mov = TRUE; long s; char sez_rmov = ' ', sezione = ' '; real tot_saldo; long numrig = 0; Saldo& sale = *_sale; 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); if (indbil == 4) { if (compila_mov) { compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 2 compila_mov = FALSE; } _saldi->setkey(1); _saldi->zero(); _saldi->put(SLD_ANNOES, _annoesch); _saldi->put(SLD_GRUPPO, g); _saldi->put(SLD_CONTO, c); (*_rec) = _saldi->curr(); int j = 0; for (_saldi->read(); ; _saldi->next()) { TRectype& rmov = _pn->cg(j); _saldo = ZERO; 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++; rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE); tot_saldo = ZERO; } break; } numrig++; s = _saldi->get_long(SLD_SOTTOCONTO); sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil); _saldo = sale.saldo(); if (_saldo.is_zero()) continue; 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 200 _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 (j == MAX || _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++; rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE); tot_saldo = ZERO; } if (!_saldi->eof()) { 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); TConto tc(g,c,s); _sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg j++; } if (_saldi->eof()) break; } //for saldi if (j >= 1) { _pn->write(); _sld->registra(); j = 0; _pn->destroy_rows(); //Azzero l'oggetto pn. } } // if (indbil == 4) } // for pcon } void CG4600_application::chiusura_conto_economico() { if (_totale_saldo > ZERO) { int j; //Compilo la testata per perdite di es. c.economico a Profitti e Perdite //Chiusura conto economico j = 0; ultima_registrazione(); compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 3 TRectype& rmov1 = _pn->cg(j); long numrig = 1; rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcproper,_totale_saldo,TRUE); numrig++; j++; TRectype& rmov2 = _pn->cg(j); rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperde,_totale_saldo,FALSE); _pn->write(); _sld->registra(); _sld->reset(); //Compilo la testata per perdite di es. c.patrimon. a Perdita di es. c. econom. //Chiusura capitale netto _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 4 TRectype& rmov3 = _pn->cg(j); numrig = 1; rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcperde,_totale_saldo,TRUE); numrig++; j++; TRectype& rmov4 = _pn->cg(j); rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcperdp,_totale_saldo,FALSE); _pn->write(); _sld->registra(); _sld->reset(); //Compilo la testata per Perdita es. c/to patrimoniale a Bilancio di apertura //Apertura capitale netto _sld->set_anno_es(_annoesap); _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesap,_dataregap,_data_inizioap,_codcausap); //Reg. 10 TRectype& rmov5 = _pn->cg(j); numrig = 1; rmov_proper(_annoesap,numrig,_dataregap,rmov5,_tcbilap,_totale_saldo,TRUE); numrig++; j++; TRectype& rmov6 = _pn->cg(j); rmov_proper(_annoesap,numrig,_dataregap,rmov6,_tcperdp,_totale_saldo,FALSE); _pn->write(); _sld->registra(); _sld->set_anno_es(_annoesch); } else if (_totale_saldo < ZERO) { int j; //Compilo la testata per Profitti e perdite a Utile di es. c.economico //Chiusura conto economico _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 3 TRectype& rmov1 = _pn->cg(j); long numrig = 1; rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutile,_totale_saldo,FALSE); numrig++; j++; TRectype& rmov2 = _pn->cg(j); rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcproper,_totale_saldo,TRUE); _pn ->write(); _sld->registra(); _sld->reset(); //Compilo la testata per Utile di es. c.economico a Utile di es. c.patrimoniale //Chiusura capitale netto _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 4 TRectype& rmov3 = _pn->cg(j); numrig = 1; rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcutilp,_totale_saldo,FALSE); numrig++; j++; TRectype& rmov4 = _pn->cg(j); rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcutile,_totale_saldo,TRUE); _pn ->write(); _sld->registra(); _sld->reset(); //Compilo la testata per Bilancio di apertura a Utile es. c/to patrimoniale //Apertura capitale netto _sld->set_anno_es(_annoesap); _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesap,_dataregap,_data_inizioap,_codcausap); //Reg. 10 TRectype& rmov5 = _pn->cg(j); numrig = 1; rmov_proper(_annoesap,numrig,_dataregap,rmov5,_tcbilap,_totale_saldo,TRUE); numrig++; j++; TRectype& rmov6 = _pn->cg(j); rmov_proper(_annoesap,numrig,_dataregap,rmov6,_tcutilp,_totale_saldo,FALSE); _pn->write(); _sld->registra(); _sld->set_anno_es(_annoesch); } } void CG4600_application::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 _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 7 TRectype& rmov1 = _pn->cg(j); numrig = 1; rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutilp,_totale_saldo,FALSE); numrig++; j++; TRectype& rmov2 = _pn->cg(j); rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcbilch,_totale_saldo,TRUE); _pn->write(); _sld->registra(); } else if (_totale_saldo < ZERO) { //Compilo la testata per Utile di es. c.patrimon. a Bilancio di chiusura //Chiusura conto patrimoniale _pn->destroy_rows(); //Azzero l'oggetto pn. j = 0; ultima_registrazione(); compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 7 TRectype& rmov1 = _pn->cg(j); numrig = 1; rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcbilch,_totale_saldo,TRUE); numrig++; j++; TRectype& rmov2 = _pn->cg(j); rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperdp,_totale_saldo,FALSE); _pn ->write(); _sld->registra(); } } void CG4600_application::attivita() { bool compila_mov_ch = TRUE; bool compila_mov_ap = TRUE; long s; char sez_rmov = ' ', sezione = ' '; real tot_saldo; long numrig = 0; Saldo& sale = *_sale; tot_saldo = ZERO; TRecnotype items_pcon = _cur->items(); for (int i = 0; i < items_pcon; i++, ++(*_cur)) { _sld->set_anno_es(_annoesch); int indbil = _cur->curr().get_int(PCN_INDBIL); int g = _cur->curr().get_int(PCN_GRUPPO); int c = _cur->curr().get_int(PCN_CONTO); if (indbil == 1) { if (compila_mov_ch) { compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 5 Chiusura compila_mov_ch = FALSE; } _saldi->setkey(1); _saldi->zero(); _saldi->put(SLD_ANNOES, _annoesch); _saldi->put(SLD_GRUPPO, g); _saldi->put(SLD_CONTO, c); TRectype rec (_saldi->curr()); int j = 0; for (_saldi->read(); ; _saldi->next()) { TRectype& rmov = _pn->cg(j); 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++; rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura tot_saldo = ZERO; } break; } numrig++; s = _saldi->get_long(SLD_SOTTOCONTO); sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil); _saldo = sale.saldo(); if (_saldo == ZERO) continue; 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 200 _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 (j == MAX || _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++; rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura tot_saldo = ZERO; } if (!_saldi->eof()) { 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); TConto tc(g,c,s); _sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg j++; } if (_saldi->eof()) break; } //for saldi if (j >= 1) { _pn->write(); _sld->registra(); _sld->reset(); j = 0; long items_pn = _pn->cg_items(); _sld->set_anno_es(_annoesap); if (compila_mov_ap) { ultima_registrazione(); compila_testata(_annoesap,_dataregap,_data_inizioap,_codcausap); //Reg. 8 Apertura compila_mov_ap = FALSE; } for (int i = 0; i < items_pn; i++) { char sez_rmov; TRectype& rmov = _pn->cg(j); char sezione = rmov.get (RMV_SEZIONE)[0]; int gruppo = rmov.get_int (RMV_GRUPPO); int conto = rmov.get_int (RMV_CONTO); long sottoc = rmov.get_long(RMV_SOTTOCONTO); real importo = rmov.get_real(RMV_IMPORTO); if (sezione == 'D') sez_rmov = 'A'; else if (sezione == 'A') sez_rmov = 'D'; rmov.put(RMV_ANNOES, _annoesap); rmov.put(RMV_NUMREG, _numreg); rmov.put(RMV_DATAREG, _dataregap); if (i == (items_pn - 1)) //Quando incontro il conto { rmov.put(RMV_GRUPPO, _tcbilap.gruppo()); rmov.put(RMV_CONTO, _tcbilap.conto()); rmov.put(RMV_SOTTOCONTO, _tcbilap.sottoconto()); //bilancio di chiusura lo rmov.put(RMV_SEZIONE, sez_rmov); //sostituisco con quello di _sld->aggiorna(_tcbilap,importo,sez_rmov); //apertura, non girando l'importo } //perche' non l'avevo girato else //precedentemente, mentre per gli altri { //conti l'importo deve essere girato, rmov.put(RMV_SEZIONE, sez_rmov); //perche' erano gia' stati girati TConto tc(gruppo,conto,sottoc); //precedentemente per fare la chiusura _sld->aggiorna(tc,importo,sez_rmov); } j++; } _pn->write(); _sld->registra(); j = 0; _pn->destroy_rows(); //Azzero l'oggetto pn. } } // if (indbil == 1) } // for pcon } void CG4600_application::passivita() { bool compila_mov_ch = TRUE; bool compila_mov_ap = TRUE; long s; char sez_rmov = ' ', sezione = ' '; real tot_saldo; long numrig = 0; Saldo& sale = *_sale; tot_saldo = ZERO; TRecnotype items_pcon = _cur->items(); for (int i = 0; i < items_pcon; i++, ++(*_cur)) { _sld->set_anno_es(_annoesch); int indbil = _cur->curr().get_int(PCN_INDBIL); int g = _cur->curr().get_int(PCN_GRUPPO); int c = _cur->curr().get_int(PCN_CONTO); if (indbil == 2) { if (compila_mov_ch) { compila_testata(_annoesch,_dataregch,_data_finech,_codcausch); //Reg. 6 Chiusura compila_mov_ch = FALSE; } _saldi->setkey(1); _saldi->zero(); _saldi->put(SLD_ANNOES, _annoesch); _saldi->put(SLD_GRUPPO, g); _saldi->put(SLD_CONTO, c); TRectype rec (_saldi->curr()); int j = 0; for (_saldi->read(); ; _saldi->next()) { TRectype& rmov = _pn->cg(j); 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++; rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura tot_saldo = ZERO; } break; } numrig++; s = _saldi->get_long(SLD_SOTTOCONTO); sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil); _saldo = sale.saldo(); if (_saldo.is_zero()) continue; 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 200 _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 (j == MAX || _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++; rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura tot_saldo = ZERO; } if (!_saldi->eof()) { 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); TConto tc(g,c,s); _sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg j++; } if (_saldi->eof()) break; } //for saldi if (j >= 1) { _pn->write(); _sld->registra(); _sld->reset(); j = 0; long items_pn = _pn->cg_items(); _sld->set_anno_es(_annoesap); if (compila_mov_ap) { ultima_registrazione(); compila_testata(_annoesap,_dataregap,_data_inizioap,_codcausap); //Reg. 9 Apertura compila_mov_ap = FALSE; } for (int i = 0; i < items_pn; i++) { char sez_rmov; TRectype& rmov = _pn->cg(j); char sezione = rmov.get (RMV_SEZIONE)[0]; int gruppo = rmov.get_int (RMV_GRUPPO); int conto = rmov.get_int (RMV_CONTO); long sottoc = rmov.get_long(RMV_SOTTOCONTO); real importo = rmov.get_real(RMV_IMPORTO); if (sezione == 'D') sez_rmov = 'A'; else if (sezione == 'A') sez_rmov = 'D'; rmov.put(RMV_ANNOES, _annoesap); rmov.put(RMV_NUMREG, _numreg); rmov.put(RMV_DATAREG, _dataregap); if (i == (items_pn - 1)) //Quando incontro il conto { rmov.put(RMV_GRUPPO, _tcbilap.gruppo()); rmov.put(RMV_CONTO, _tcbilap.conto()); rmov.put(RMV_SOTTOCONTO, _tcbilap.sottoconto()); //bilancio di chiusura lo rmov.put(RMV_SEZIONE, sez_rmov); //sostituisco con quello di _sld->aggiorna(_tcbilap,importo,sez_rmov); //apertura, non girando l'importo } //perche' non l'avevo girato else //precedentemente, mentre per gli altri { //conti l'importo deve essere girato, rmov.put(RMV_SEZIONE, sez_rmov); //perche' erano gia' stati girati TConto tc(gruppo,conto,sottoc); //precedentemente per fare la chiusura _sld->aggiorna(tc,importo,sez_rmov); } j++; } _pn->write(); _sld->registra(); j = 0; _pn->destroy_rows(); } } // if (indbil == 2) } // for pcon } bool CG4600_application::menu(MENU_TAG m) { if (m == BAR_ITEM(1)) return set(); return FALSE; } int /*main */ cg4600 (int argc, char* argv[]) { CG4600_application main_app; main_app.run(argc, argv, "Chiusura Apertura Conti"); return TRUE; }