///////////////////////////////////////////////////////////////////////////// // cglib02.cpp // // Aggiornamento saldi // ///////////////////////////////////////////////////////////////////////////// #include #include #include #include #include "cglib01.h" #include "cglib02.h" #include #include #include #include #include /////////////////////////////////////////////////////////// // TSaldi_list /////////////////////////////////////////////////////////// // // Cerca l'esercizio precedente di EseCorr // Se EseCorr e' gia' il primo ritorna 0 // HIDDEN int EsePre(const int EseCorr) { TEsercizi_contabili esc; return esc.pred(EseCorr); } // aep e' l'esercizio precedente TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par) { TLocalisamfile cf(LF_SALDI); bool force; TString16 key; int aep = aep_par; destroy(); cf.zero(); // Se non passo l'anno precedente lo devo comunque calcolare if (aep_par == 0) aep = EsePre(aec); cf.setkey(2); cf.put(SLD_GRUPPO,gr); cf.put(SLD_CONTO,co); for (cf.read(_isgteq);!cf.eof();cf.next()) { if (!cf.get_bool(SLD_FLSCA)) { const int ae = cf.get_int(SLD_ANNOES); const int g = cf.get_int(SLD_GRUPPO); const int c = cf.get_int(SLD_CONTO); const long s = cf.get_long(SLD_SOTTOCONTO); if (g != gr || c != co) break; if (ae != aec && ae != aep) continue; TRectype r(cf.curr()); key.format("%3d%3d%6ld", g, c, s); // Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato force = !aep_par; add((const char*) key, r, force); } } } TRectype* TSaldi_list::saldi() const { TObject* o = ((TAssoc_array*)this)->get(); return (TRectype*)o; } /////////////////////////////////////////////////////////// // TSaldo /////////////////////////////////////////////////////////// TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO), _prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0), _indbil(0), _prec(FALSE), _movimentato(FALSE), _significativo(FALSE), _rec_presente_ec(FALSE), _rec_presente_ep(FALSE), _causali_apertura(LF_CAUSALI, CAU_MOVAP) {} real TSaldo::saldofin_esprec(int annoes, int g, int c, long s, bool saldo_chiusura) { const int annoesprec = EsePre(annoes); _significativo = FALSE; if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo return ZERO; const char flag = _saldi.get(SLD_FLAGSALINI)[0]; const real saldo = _saldi.get_real(SLD_SALDO); const real pdare = _saldi.get_real(SLD_PDARE); const real pavere = _saldi.get_real(SLD_PAVERE); const real pdarepro = _saldi.get_real(SLD_PDAREPRO); const real paverepro = _saldi.get_real(SLD_PAVEREPRO); const char flagsf = _saldi.get_char(SLD_FLAGSALFIN); const real saldosf = _saldi.get_real(SLD_SALDOFIN); real tot = pdare-pavere; if (flag == 'D') tot += saldo; else tot -= saldo; if (saldo_chiusura) // W96SALDI del 18-07-96 { // Ho aggiunto il flag saldo_chiusura con valore di if (flagsf == 'D') // default a FALSE, perche' il saldo finale dell' esercizio tot += saldosf; // precedente va considerato solamente nel calcolo dei else // progressivi precedenti nella stampa mastrini, tot -= saldosf; // che e' l'unico programma ad usare la funzione } // passandogli come flag saldo_chiusura il valore TRUE. _significativo = (tot != 0); return tot; } //richiamata nel bilancio a sez.contr per data limite //in realta' calcola il saldo finale es.prec real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil) { real saldoini; _significativo = TRUE; _saldi.zero(); _saldi.put(SLD_GRUPPO,g); _saldi.put(SLD_CONTO,c); _saldi.put(SLD_SOTTOCONTO,s); _saldi.put(SLD_ANNOES,_annoes); _saldi.put(SLD_FLSCA,""); if (_rec_presente_ec = (_saldi.read() == NOERR)) saldoini = _saldi.get_real(SLD_SALDO); _significativo = _rec_presente_ec && saldoini != ZERO; if (saldoini != ZERO) //non va considerato!!! Vedi appunti _saldo_iniziale = ZERO; if (saldoini == ZERO) { if (indbil == 1 || indbil == 2 || indbil == 5) { _prec = TRUE; saldoini = saldofin_esprec(_annoes, g, c, s); } _saldo_iniziale = saldoini; } return _saldo_iniziale; } const char* TSaldo::causale_chiusura_es() { TConfig conf(CONFIG_DITTA); return conf.get("CoCaCh"); } const char* TSaldo::causale_apertura_es() { TConfig conf(CONFIG_DITTA); return conf.get("CoCaAp"); } bool TSaldo::leggi_mov(long nr) { TLocalisamfile mov(LF_MOV); // mov.zero(); mov.put (MOV_NUMREG, nr); const bool ok = mov.read() == NOERR; if (ok) { _codcaus = mov.get(MOV_CODCAUS); _datareg = mov.get(MOV_DATAREG); _provv = mov.get(MOV_PROVVIS); // _provv.trim(); _datacomp = mov.get(MOV_DATACOMP); } else NFCHECK("Testata assente: %ld", nr); return ok; } //per bilancio scalare (ovvero a sezioni contrapposte) per data limite bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf, const TDate& data_sup, int indbil, int stp_prov) { TLocalisamfile rmov(LF_RMOV); _saldo_iniziale = ZERO; _saldo = ZERO; _movimentato = FALSE; _rec_presente_ep = FALSE; _rec_presente_ec = FALSE; _prec = FALSE; rmov.setkey(2); rmov.zero(); rmov.put(RMV_GRUPPO,g); rmov.put(RMV_CONTO,c); rmov.put(RMV_SOTTOCONTO,s); // Anche se non movimentato vado a vedere il saldo if (stp_prov != 3) _saldo = calcola_saldo_iniziale(g,c,s,indbil); #ifdef DBG long num_rec = 0; const clock_t clock_start = clock(); #endif for (rmov.read(_isgteq); !rmov.eof(); rmov.next()) { const int gruppo = rmov.get_int(RMV_GRUPPO); const int conto = rmov.get_int(RMV_CONTO); const long sottoconto = rmov.get_long(RMV_SOTTOCONTO); if (gruppo != g || conto != c || sottoconto != s) break; #ifdef DBG num_rec++; if ((num_rec & 0x7F) == 0) { const double sec = (clock() - clock_start) / CLOCKS_PER_SEC; if (sec > 0.0) { TString80 msg; msg.format("%ld records at %ld rec/sec", num_rec, long(num_rec/sec)); xvt_statbar_set(msg); do_events(); } } #endif const long num_reg = rmov.get_long(RMV_NUMREG); TDate data_mov; // Leggo la testata leggi_mov(num_reg); if (bilancio == DataLimite) data_mov = _datacomp; else { if (_annoes == 0) data_mov = _datareg; else data_mov = _datacomp; } if (data_mov < data_inf || data_mov > data_sup) continue; // "Se la causale del movimento e' di chiusura, // o di apertura il movimento non va considerato" if (_codcaus.not_empty()) { const TString& movap = _causali_apertura.decode(_codcaus); if (movap == "C") continue; } //bilancio normale (non comprende i provvisori) ? if (stp_prov == 1 && _provv.not_empty()) continue; //bilancio dei soli provvisori ? if (stp_prov == 3 && _provv.empty()) continue; const char sezione = rmov.get_char(RMV_SEZIONE); const real importo = rmov.get(RMV_IMPORTO); // I mov. di puro riferimento (= con importo = 0) vanno scartati if (importo == ZERO) continue; _movimentato = TRUE; if (sezione == 'D') _saldo += importo; else _saldo -= importo; } #ifdef DBG xvt_statbar_refresh(); #endif return _movimentato; } //per bilancio di verifica all'ultima immissione bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil,int stp_prov) { //Si considerano i saldi e non piu' i movimenti char sezione,sezsf; int gruppo, conto, annoe; long sottoconto; real pdarepro, paverepro,saldofin; bool esito = FALSE; _saldo_iniziale = ZERO; _saldoiniziale = ZERO; _prg_dare = ZERO; _prg_avere = ZERO; _saldo = ZERO; saldofin = ZERO; _saldi.zero(); _saldi.put(SLD_ANNOES,annoes); _saldi.put(SLD_GRUPPO,g); _saldi.put(SLD_CONTO,c); _saldi.put(SLD_SOTTOCONTO,s); _saldi.put(SLD_FLSCA, ""); if (_saldi.read() == NOERR) { annoe = _saldi.get_int(SLD_ANNOES); gruppo = _saldi.get_int(SLD_GRUPPO); conto = _saldi.get_int(SLD_CONTO); sottoconto = _saldi.get_long(SLD_SOTTOCONTO); _saldo_iniziale = _saldi.get_real(SLD_SALDO); _prg_dare = _saldi.get_real(SLD_PDARE); _prg_avere = _saldi.get_real(SLD_PAVERE); pdarepro = _saldi.get_real(SLD_PDAREPRO); paverepro = _saldi.get_real(SLD_PAVEREPRO); sezione = _saldi.get_char(SLD_FLAGSALINI); sezsf = _saldi.get_char(SLD_FLAGSALFIN); // W96SALDI del 19-06-96 modifica richiesta saldofin = _saldi.get_real(SLD_SALDOFIN); // da PATRIZIA if (stp_prov == 1) //bilancio normale (senza provvisori) if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO) return esito; // if (stp_prov == 0 && paverepro == ZERO) if (stp_prov == 3 && paverepro == ZERO && pdarepro == ZERO) // Modifica del 24-09-96 errore MI0890. { _saldo = _prg_dare = _prg_avere = ZERO; // N.B. Non e' detto che funzioni sempre!!!!!! return esito; } if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale; if (sezsf == 'A') saldofin = -saldofin; // W96SALDI del 19-06-96 _saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi //non comprensivo del saldo finale es.precedente if (stp_prov != 3) if (indbil == 1 || indbil == 2 || indbil == 5) if (_saldo_iniziale == ZERO) _saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto); esito = TRUE; switch (stp_prov) { case 1: _saldo = _saldo_iniziale + _prg_dare - _prg_avere + saldofin; // W96SALDI del 19-06-96 break; case 2: _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro + saldofin; // W96SALDI del 19-06-96 if (pdarepro != ZERO) // Modifica del 24-09-96 errore MI0890: nel caso in cui i progressivi _prg_dare = pdarepro; // pdarepro o paverepro sono compilati sono in presenza di un movimento if (paverepro != ZERO) // provvisorio, dunque li trasferisco nei progressivi che poi uso nel _prg_avere = paverepro; // CG1500 per la stampa. break; case 3: _saldo = pdarepro - paverepro; _prg_dare = pdarepro; // Idem come sopra. _prg_avere = paverepro; // N.B. Non e' detto che funzioni sempre!!!!!! break; default: break; } } return esito; } //per bilancio a sezioni contrapposte all'ultima immissione // W96SALDI in questa funzione e' stato aggiunto il parametro saldo_chiusura che di default // e' TRUE. A cosa serve ? Serve per includere nel calcolo del saldo all' ultima immissione // anche il saldo finale compilato nei movimenti di chiusura (se non venisse considerato i conti // risulterebbero aperti); siccome alcuni programmi (esempio il bilancio IV dir. CEE) non ne // devono tenere conto, si e' data la possibilita' di usare la funzione passandogli il parametro a FALSE. // Modifica del 09-07-96 bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil,int stp_prov,bool saldo_chiusura) { //Si considerano i saldi e non piu' i movimenti char sezione; int gruppo, conto, annoe; long sottoconto; real pdarepro, paverepro; real saldofinale; char flagsf; bool esito = FALSE; _saldo_iniziale = ZERO; _prg_dare = ZERO; _prg_avere = ZERO; _saldo = ZERO; _rec_presente_ec = FALSE; _rec_presente_ep = FALSE; _prec = FALSE; _saldi.zero(); _saldi.put(SLD_ANNOES,annoes); _saldi.put(SLD_GRUPPO,g); _saldi.put(SLD_CONTO,c); _saldi.put(SLD_SOTTOCONTO,s); _saldi.put(SLD_FLSCA, ""); if (_saldi.read() == NOERR) { annoe = _saldi.get_int(SLD_ANNOES); gruppo = _saldi.get_int(SLD_GRUPPO); conto = _saldi.get_int(SLD_CONTO); sottoconto = _saldi.get_long(SLD_SOTTOCONTO); _saldo_iniziale = _saldi.get_real(SLD_SALDO); _prg_dare = _saldi.get_real(SLD_PDARE); _prg_avere = _saldi.get_real(SLD_PAVERE); pdarepro = _saldi.get_real(SLD_PDAREPRO); paverepro = _saldi.get_real(SLD_PAVEREPRO); sezione = _saldi.get_char(SLD_FLAGSALINI); flagsf = _saldi.get_char(SLD_FLAGSALFIN); saldofinale = _saldi.get_real(SLD_SALDOFIN); if (stp_prov == 1) //bilancio normale (senza provvisori) esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO); if (stp_prov == 2) //bilancio globale (con provvisori) esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO || pdarepro != ZERO || paverepro != ZERO); if (stp_prov == 3) //bilancio dei soli mov. provvisori esito = (pdarepro != ZERO || paverepro != ZERO); if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale; if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure if (flagsf == 'A') // no del saldo di chiusura inserita il 09-07-96 saldofinale = -saldofinale; _rec_presente_ec = esito; } if (stp_prov != 3) if (indbil == 1 || indbil == 2 || indbil == 5) if (_saldo_iniziale == ZERO) { _prec = TRUE; _saldo_iniziale += saldofin_esprec(annoes,g,c,s); } if (stp_prov == 1) _saldo = _saldo_iniziale + _prg_dare - _prg_avere; if (stp_prov == 2) _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro; if (stp_prov == 3) _saldo = pdarepro - paverepro; if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure _saldo += saldofinale; // no del saldo di chiusura inserita il 09-07-96 return esito; } bool TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s) { if (annoesprec == 0) _rec_presente_ep = FALSE; else { const int oldkey = _saldi.getkey(); _saldi.setkey(1); _saldi.zero(); _saldi.put(SLD_ANNOES,annoesprec); _saldi.put(SLD_GRUPPO,g); _saldi.put(SLD_CONTO,c); _saldi.put(SLD_SOTTOCONTO,s); _saldi.put(SLD_FLSCA, ""); _rec_presente_ep = _saldi.read() == NOERR; _saldi.setkey(oldkey); } return _rec_presente_ep; } //calcolo dei progressivi attuali (normali o eliminati) bool TSaldo::prg_saldo(int annoes, TConto& conto, real& prgdare, real& prgavere, bool scar) { _saldi.zero(); _saldi.put(SLD_GRUPPO,conto.gruppo()); _saldi.put(SLD_CONTO,conto.conto()); _saldi.put(SLD_SOTTOCONTO,conto.sottoconto()); _saldi.put(SLD_ANNOES,annoes); _saldi.put(SLD_FLSCA, scar); bool ok = _saldi.read() == NOERR; if (ok) { const char flagsalini = _saldi.get_char(SLD_FLAGSALINI); const real saldoini = _saldi.get_real(SLD_SALDO); prgdare = _saldi.get_real(SLD_PDARE); prgavere = _saldi.get_real(SLD_PAVERE); if (flagsalini == 'D') prgdare += saldoini ; else prgavere += saldoini; } return ok; } /////////////////////////////////////////////////////////// // TContoExt /////////////////////////////////////////////////////////// class TContoExt : public TConto { bool _scaricato; public: bool scaricato() const { return _scaricato; } TContoExt(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL, bool sc = FALSE) : TConto(g, c, s, t, d), _scaricato(sc) {} TContoExt(TToken_string& tgcsd, int from, int mode = 0, bool sc = FALSE) : TConto(tgcsd, from, mode), _scaricato(sc) {} virtual ~TContoExt() {} }; TConto* TTab_conti::add(const TBill& c, int anno, bool scar) { TString80 key; key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto()); if (scar) key << "X"; TContoExt* tc = new TContoExt(c.gruppo(), c.conto(), c.sottoconto(), c.tipo(), NULL, scar); TAssoc_array::add(key, tc); return tc; } TConto* TTab_conti::find(const TBill& c, int anno, bool scar) { TString80 key; key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto()); if (scar) key << "X"; TContoExt* tc = (TContoExt*)objptr(key); return tc; } void TTab_conti::remove(const TBill& c, int anno, bool scar) { TString80 key; key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto()); if (scar) key << "X"; TAssoc_array::remove(key); } void TTab_conti::aggiorna_conto(const TBill& tcon, int anno_es, const TImporto& importo, tiposal movap, bool provv, bool somma, bool movimentato, bool scaricato) { TContoExt* tc = (TContoExt*)find(tcon, anno_es, scaricato); if (tc == NULL) tc = (TContoExt*)add(tcon, anno_es, scaricato); const real i(somma ? importo.valore() : -importo.valore()); if (provv) { if (importo.sezione() == 'D') tc->darepro() += i; else tc->averepro() += i; } else { if (movap == apertura) { if (importo.sezione() == 'D') tc->saldo() += i; else tc->saldo() -= i; } else { if (movap == chiusura) { if (importo.sezione() == 'D') tc->saldofin() += i; else tc->saldofin() -= i; } else { if (importo.sezione() == 'D') tc->dare() += i; else tc->avere() += i; } } } // rimuovo dalla tabella il conto se dare e avere vanno a zero if (!movimentato) if (tc->dare().is_zero() && tc->avere().is_zero() && tc->saldofin().is_zero() && tc->darepro().is_zero() && tc->averepro().is_zero() && tc->saldo().is_zero()) remove(*tc, anno_es, scaricato); } /////////////////////////////////////////////////////////// // TSaldo_agg /////////////////////////////////////////////////////////// TSaldo_agg::TSaldo_agg() : _anno_es(0), _data_ulmov(""), _num_ulmov(0l), _movap(normale), _provv(FALSE), _movimentato(FALSE) {} void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma, bool scaricato) { _tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato); } void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione, bool somma, bool scaricato) { const TImporto imp(sezione, importo); _tab_conti.aggiorna_conto(TBill(gruppo, conto, sottoconto), _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato); } void TSaldo_agg::reset() { _tab_conti.destroy(); } /////////////////////////////////////////////////////////////////////////////// // pulizia file saldi // // Scorro il file saldi per l' anno year o per tutti gli anni se year = 0 // e azzero i progressivi. // /////////////////////////////////////////////////////////////////////////////// void TSaldo_agg::clear_saldi(int year) { TLocalisamfile saldi(LF_SALDI); set_anno_es(year); saldi.zero(); if (anno_es() != 0) saldi.put(SLD_ANNOES, anno_es()); TRectype last(saldi.curr()); for (saldi.read(_isgteq, _lock); !saldi.eof() && saldi.curr() <= last; saldi.next(_lock)) { if (!saldi.get_bool(SLD_FLSCA)) { saldi.remove(); } else { saldi.put(SLD_FLSCA, ""); saldi.write(); saldi.put(SLD_FLSCA, "X"); saldi.read(_isequal,_unlock); } } saldi.reread(_unlock); } /////////////////////////////////////////////////////////////////////////////// // Aggiornamento file saldi // // Scorro la tabella dei conti interna _tab_conti. // Per ogni conto cerco il record su saldi, se non c'e' lo creo. // Se c'e' gia' lo aggiorno nel seguente modo: // GLOP /////////////////////////////////////////////////////////////////////////////// void TSaldo_agg::registra() { real si, r; char flag_salini; TDate data_ulmov; long num_ulmov; TLocalisamfile saldi(LF_SALDI); int conti = _tab_conti.items(); _tab_conti.restart(); for (int i = 0; i < conti; i++) { THash_object* hobj = _tab_conti.get_hashobj(); TContoExt& tcon = (TContoExt&)hobj->obj(); CHECK(tcon.ok(), "Tentativo di saldare un conto incompleto"); const int annoes = atoi(hobj->key().left(4)); saldi.zero(); saldi.put(SLD_ANNOES, annoes); saldi.put(SLD_GRUPPO, tcon.gruppo()); saldi.put(SLD_CONTO, tcon.conto()); saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); saldi.put(SLD_FLSCA, tcon.scaricato()); bool update = TRUE; if (saldi.read(_isequal, _lock) != NOERR) { saldi.zero(); saldi.put(SLD_ANNOES, atoi(hobj->key().left(4))); saldi.put(SLD_GRUPPO, tcon.gruppo()); saldi.put(SLD_CONTO, tcon.conto()); saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); saldi.put(SLD_FLSCA, tcon.scaricato()); si = tcon.saldo(); if (si < ZERO) { flag_salini = 'A'; si = -si; } else flag_salini = 'D'; saldi.put(SLD_FLAGSALINI, flag_salini); saldi.put(SLD_SALDO, si); saldi.put(SLD_PDARE, tcon.dare()); saldi.put(SLD_PAVERE, tcon.avere()); saldi.put(SLD_PDAREPRO, tcon.darepro()); saldi.put(SLD_PAVEREPRO, tcon.averepro()); real sf = tcon.saldofin(); char flag_salfin = sf < ZERO ? 'A' : 'D'; if (flag_salfin == 'A') sf = -sf; saldi.put(SLD_FLAGSALFIN, flag_salfin); saldi.put(SLD_SALDOFIN, sf); if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov); if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov); update = saldi.write() == _isreinsert; if (update) saldi.read(_isequal, _lock); } if (update) { num_ulmov = saldi.get_long(SLD_NUMULTMOV); data_ulmov = saldi.get_date(SLD_DATAULMOV); if ((_num_ulmov != 0L) && (_num_ulmov > num_ulmov)) saldi.put(SLD_NUMULTMOV, _num_ulmov); if ((_data_ulmov.ok()) && (_data_ulmov > data_ulmov)) saldi.put(SLD_DATAULMOV, _data_ulmov); r = tcon.saldo(); si = saldi.get_real(SLD_SALDO); flag_salini = saldi.get_char(SLD_FLAGSALINI); if (r != ZERO) { if (flag_salini == 'A') si = r - si; else si += r; if (si < ZERO) { flag_salini = 'A'; si = -si; } else flag_salini = 'D'; saldi.put(SLD_FLAGSALINI, flag_salini); saldi.put(SLD_SALDO, si); } TImporto sf('D', tcon.saldofin()); char old_flag_sf = saldi.get(SLD_FLAGSALFIN)[0]; TImporto old_sf(old_flag_sf, saldi.get_real(SLD_SALDOFIN)); sf += old_sf; sf.normalize(); saldi.put(SLD_FLAGSALFIN, sf.sezione()); saldi.put(SLD_SALDOFIN, sf.valore()); r = saldi.get_real(SLD_PDARE); r += tcon.dare(); saldi.put(SLD_PDARE, r); r = saldi.get_real(SLD_PAVERE); r += tcon.avere(); saldi.put(SLD_PAVERE, r); r = saldi.get_real(SLD_PDAREPRO); r += tcon.darepro(); saldi.put(SLD_PDAREPRO, r); r = saldi.get_real(SLD_PAVEREPRO); r += tcon.averepro(); saldi.put(SLD_PAVEREPRO, r); const int err = saldi.rewrite(); if (err != NOERR) yesnofatal_box("Errore %d nell'aggiornamento del saldo %d %d %ld", err, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); } // Calcolo saldo finale per controllo segno in prima nota if (si.is_zero()) { TLocalisamfile pcon(LF_PCON); TRectype& curr = pcon.curr(); curr.put(PCN_GRUPPO, tcon.gruppo()); curr.put(PCN_CONTO, tcon.conto()); const int err = pcon.read(); CHECK(err == NOERR, "Impossibile stabilire indicatore di bilancio"); const int indbil = curr.get_int(PCN_INDBIL); if (indbil == 1 || indbil == 2 || indbil == 5) { TSaldo saldo; si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); if (si < ZERO) { flag_salini = 'A'; si = -si; } else flag_salini = 'D'; } } TImporto sf(flag_salini, si); const TImporto dare('D', saldi.get_real(SLD_PDARE)); const TImporto avere('A', saldi.get_real(SLD_PAVERE)); sf += dare; sf += avere; sf.normalize(+1); // Rendi sempre positivo tcon.saldo_finale() = sf; } }