88fd68c2b3
Files correlati : cg3.exe cg4.exe Ricompilazione Demo : [ ] Commento : Cm20090 Stampando il registro in prova, non viene mai stampata la parte delle vendite ma ripetuta la parte di acquisto al suo posto senza valori. Se stampo il bollato non mi viene data la stampa e mi si iconizza il programma git-svn-id: svn://10.65.10.50/trunk@11764 c028cbd2-c16b-5b4b-a496-9718f37d4682
1087 lines
31 KiB
C++
Executable File
1087 lines
31 KiB
C++
Executable File
/////////////////////////////////////////////////////////////////////////////
|
|
// cglib02.cpp
|
|
//
|
|
// Aggiornamento saldi
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#include <diction.h>
|
|
#include <progind.h>
|
|
#include <relation.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
#include <xvtility.h>
|
|
|
|
#include "cglib01.h"
|
|
#include "cglib02.h"
|
|
|
|
#include <causali.h>
|
|
#include <mov.h>
|
|
#include <pconti.h>
|
|
#include <rmov.h>
|
|
#include <saldi.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// 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)
|
|
{
|
|
TString16 key;
|
|
int aep = aep_par;
|
|
|
|
destroy();
|
|
|
|
// Se non passo l'anno precedente lo devo comunque calcolare
|
|
if (aep_par == 0)
|
|
aep = EsePre(aec);
|
|
|
|
TLocalisamfile cf(LF_SALDI);
|
|
cf.setkey(2);
|
|
cf.put(SLD_GRUPPO,gr);
|
|
cf.put(SLD_CONTO,co);
|
|
|
|
for (cf.read(_isgteq);!cf.eof();cf.next())
|
|
{
|
|
if (!cf.get_bool(SLD_FLSCA))
|
|
{
|
|
const int ae = cf.get_int(SLD_ANNOES);
|
|
const int g = cf.get_int(SLD_GRUPPO);
|
|
const int c = cf.get_int(SLD_CONTO);
|
|
const long s = cf.get_long(SLD_SOTTOCONTO);
|
|
|
|
if (g != gr || c != co) break;
|
|
if (ae != aec && ae != aep) continue;
|
|
|
|
const TRectype& r = cf.curr();
|
|
key.format("%3d%3d%6ld", g, c, s);
|
|
|
|
// Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato
|
|
bool force = !aep_par;
|
|
add(key, r, force);
|
|
}
|
|
}
|
|
}
|
|
|
|
TRectype* TSaldi_list::saldi() const
|
|
{
|
|
TObject* o = ((TAssoc_array*)this)->get();
|
|
return (TRectype*)o;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TSaldo
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO),
|
|
_prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0),
|
|
_indbil(0), _prec(FALSE), _movimentato(FALSE), _significativo(FALSE),
|
|
_rec_presente_ec(FALSE), _rec_presente_ep(FALSE),
|
|
_causali_apertura(LF_CAUSALI, CAU_MOVAP)
|
|
|
|
{}
|
|
|
|
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s, bool saldo_chiusura, bool provvis)
|
|
{
|
|
_significativo = FALSE;
|
|
|
|
const int annoesprec = EsePre(annoes);
|
|
if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo
|
|
return ZERO;
|
|
|
|
const char flag = _saldi.get(SLD_FLAGSALINI)[0];
|
|
const real saldo = _saldi.get_real(SLD_SALDO);
|
|
const real pdare = _saldi.get_real(SLD_PDARE);
|
|
const real pavere = _saldi.get_real(SLD_PAVERE);
|
|
const real pdarepro = _saldi.get_real(SLD_PDAREPRO);
|
|
const real paverepro = _saldi.get_real(SLD_PAVEREPRO);
|
|
const char flagsf = _saldi.get_char(SLD_FLAGSALFIN);
|
|
const real saldosf = _saldi.get_real(SLD_SALDOFIN);
|
|
|
|
real tot = pdare-pavere;
|
|
|
|
if (flag == 'D') tot += saldo;
|
|
else tot -= saldo;
|
|
|
|
if (saldo_chiusura) // W96SALDI del 18-07-96
|
|
{ // Ho aggiunto il flag saldo_chiusura con valore di
|
|
if (flagsf == 'D') // default a FALSE, perche' il saldo finale dell' esercizio
|
|
tot += saldosf; // precedente va considerato solamente nel calcolo dei
|
|
else // progressivi precedenti nella stampa mastrini,
|
|
tot -= saldosf; // che e' l'unico programma ad usare la funzione
|
|
} // passandogli come flag saldo_chiusura il valore TRUE.
|
|
|
|
if (provvis)
|
|
{
|
|
tot += pdarepro;
|
|
tot -= paverepro;
|
|
}
|
|
|
|
_significativo = !tot.is_zero();
|
|
return tot;
|
|
}
|
|
|
|
//richiamata nel bilancio a sez.contr per data limite
|
|
//in realta' calcola il saldo finale es.prec
|
|
real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil, bool provvis)
|
|
{
|
|
real saldoini;
|
|
_significativo = TRUE;
|
|
|
|
_saldi.zero();
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_ANNOES,_annoes);
|
|
_saldi.put(SLD_FLSCA,"");
|
|
|
|
if (_rec_presente_ec = (_saldi.read() == NOERR))
|
|
saldoini = _saldi.get_real(SLD_SALDO);
|
|
|
|
_significativo = _rec_presente_ec && saldoini != ZERO;
|
|
|
|
if (saldoini != ZERO) //non va considerato!!! Vedi appunti
|
|
_saldo_iniziale = ZERO;
|
|
|
|
if (saldoini == ZERO)
|
|
{
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
{
|
|
_prec = TRUE;
|
|
saldoini = saldofin_esprec(_annoes, g, c, s, false, provvis);
|
|
}
|
|
_saldo_iniziale = saldoini;
|
|
}
|
|
return _saldo_iniziale;
|
|
}
|
|
|
|
bool TSaldo::leggi_mov(long nr)
|
|
{
|
|
const TRectype& mov = cache().get(LF_MOV, nr);
|
|
const bool ok = !mov.empty();
|
|
if (ok)
|
|
{
|
|
_codcaus = mov.get(MOV_CODCAUS);
|
|
_datareg = mov.get(MOV_DATAREG);
|
|
_provv = mov.get(MOV_PROVVIS); // _provv.trim();
|
|
_datacomp = mov.get(MOV_DATACOMP);
|
|
}
|
|
else
|
|
NFCHECK("Testata assente: %ld", nr);
|
|
return ok;
|
|
}
|
|
|
|
//per bilancio scalare (ovvero a sezioni contrapposte) per data limite
|
|
bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf,
|
|
const TDate& data_sup, int indbil, int stp_prov, const char* filter)
|
|
{
|
|
_saldo_iniziale = ZERO;
|
|
_saldo = ZERO;
|
|
_movimentato = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_rec_presente_ec = FALSE;
|
|
_prec = FALSE;
|
|
|
|
TRelation rel(LF_RMOV);
|
|
TRectype& rmov = rel.curr();
|
|
|
|
rmov.put(RMV_GRUPPO,g);
|
|
rmov.put(RMV_CONTO,c);
|
|
rmov.put(RMV_SOTTOCONTO,s);
|
|
|
|
TCursor cur(&rel, filter, 2, &rmov, &rmov);
|
|
const TRecnotype items = cur.items();
|
|
cur.freeze();
|
|
|
|
// Anche se non movimentato vado a vedere il saldo
|
|
if (stp_prov != 3 && (filter == NULL || *filter == '\0'))
|
|
_saldo = calcola_saldo_iniziale(g,c,s,indbil,stp_prov == 2);
|
|
|
|
for (cur = 0L; cur.pos() < items; ++cur)
|
|
{
|
|
const long num_reg = rmov.get_long(RMV_NUMREG);
|
|
|
|
if (!leggi_mov(num_reg)) // Leggo la testata
|
|
continue; // Evita righe orfane!
|
|
|
|
TDate data_mov;
|
|
if (bilancio == DataLimite)
|
|
data_mov = _datacomp;
|
|
else
|
|
{
|
|
if (_annoes == 0)
|
|
data_mov = _datareg;
|
|
else
|
|
data_mov = _datacomp;
|
|
}
|
|
|
|
if (data_mov < data_inf || data_mov > data_sup)
|
|
continue;
|
|
|
|
// "Se la causale del movimento e' di chiusura,
|
|
// o di apertura il movimento non va considerato"
|
|
if (_codcaus.not_empty())
|
|
{
|
|
const TString& movap = _causali_apertura.decode(_codcaus);
|
|
if (movap == "C")
|
|
continue;
|
|
}
|
|
|
|
//bilancio normale (non comprende i provvisori) ?
|
|
if (stp_prov == 1 && _provv.not_empty())
|
|
continue;
|
|
|
|
//bilancio dei soli provvisori ?
|
|
if (stp_prov == 3 && _provv.empty())
|
|
continue;
|
|
|
|
const char sezione = rmov.get_char(RMV_SEZIONE);
|
|
const real importo = rmov.get_real(RMV_IMPORTO);
|
|
|
|
// I mov. di puro riferimento (= con importo = 0) vanno scartati
|
|
if (importo.is_zero())
|
|
continue;
|
|
|
|
_movimentato = TRUE;
|
|
|
|
if (sezione == 'D')
|
|
_saldo += importo;
|
|
else
|
|
_saldo -= importo;
|
|
}
|
|
|
|
#ifdef DBG
|
|
xvt_statbar_refresh();
|
|
#endif
|
|
#ifdef __LONGDOUBLE__
|
|
_saldo.round(TCurrency::get_firm_dec());
|
|
#endif
|
|
|
|
return _movimentato;
|
|
}
|
|
|
|
|
|
//per bilancio di verifica all'ultima immissione
|
|
bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil,int stp_prov)
|
|
{
|
|
//Si considerano i saldi e non piu' i movimenti
|
|
char sezione;
|
|
real pdarepro, paverepro;
|
|
bool esito = FALSE;
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_saldoiniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_saldo = ZERO;
|
|
_saldofin = ZERO;
|
|
_sezsf = ' ';
|
|
|
|
_saldi.zero();
|
|
_saldi.put(SLD_ANNOES,annoes);
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_FLSCA, "");
|
|
|
|
if (_saldi.read() == NOERR)
|
|
{
|
|
// int annoe = _saldi.get_int(SLD_ANNOES);
|
|
// int gruppo = _saldi.get_int(SLD_GRUPPO);
|
|
// int conto = _saldi.get_int(SLD_CONTO);
|
|
// long sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
|
|
_saldo_iniziale = _saldi.get_real(SLD_SALDO);
|
|
_prg_dare = _saldi.get_real(SLD_PDARE);
|
|
_prg_avere = _saldi.get_real(SLD_PAVERE);
|
|
pdarepro = _saldi.get_real(SLD_PDAREPRO);
|
|
paverepro = _saldi.get_real(SLD_PAVEREPRO);
|
|
sezione = _saldi.get_char(SLD_FLAGSALINI);
|
|
_sezsf = _saldi.get_char(SLD_FLAGSALFIN); // W96SALDI del 19-06-96 modifica richiesta
|
|
_saldofin = _saldi.get_real(SLD_SALDOFIN); // da PATRIZIA
|
|
|
|
if (stp_prov == 1) //bilancio normale (senza provvisori)
|
|
if (_saldo_iniziale.is_zero() && _prg_dare.is_zero() && _prg_avere.is_zero())
|
|
return esito;
|
|
// if (stp_prov == 0 && paverepro == ZERO)
|
|
if (stp_prov == 3 && paverepro.is_zero() && pdarepro.is_zero()) // Modifica del 24-09-96 errore MI0890.
|
|
{
|
|
_saldo = _prg_dare = _prg_avere = ZERO; // N.B. Non e' detto che funzioni sempre!!!!!!
|
|
return esito;
|
|
}
|
|
if (sezione == 'A')
|
|
_saldo_iniziale = -_saldo_iniziale;
|
|
if (_sezsf == 'A')
|
|
_saldofin = -_saldofin; // W96SALDI del 19-06-96
|
|
|
|
_saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi
|
|
//non comprensivo del saldo finale es.precedente
|
|
|
|
if (_saldo_iniziale.is_zero() && stp_prov != 3)
|
|
{
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
_saldo_iniziale += saldofin_esprec(annoes,g,c,s, false, stp_prov == 2);
|
|
}
|
|
|
|
esito = TRUE;
|
|
|
|
switch (stp_prov)
|
|
{
|
|
case 1:
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _saldofin; // W96SALDI del 19-06-96
|
|
break;
|
|
case 2:
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro + _saldofin; // W96SALDI del 19-06-96
|
|
if (pdarepro != ZERO) // Modifica del 24-09-96 errore MI0890: nel caso in cui i progressivi
|
|
_prg_dare = pdarepro; // pdarepro o paverepro sono compilati sono in presenza di un movimento
|
|
if (paverepro != ZERO) // provvisorio, dunque li trasferisco nei progressivi che poi uso nel
|
|
_prg_avere = paverepro; // CG1500 per la stampa.
|
|
break;
|
|
case 3:
|
|
_saldo = pdarepro - paverepro;
|
|
_prg_dare = pdarepro; // Idem come sopra.
|
|
_prg_avere = paverepro; // N.B. Non e' detto che funzioni sempre!!!!!!
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return esito;
|
|
}
|
|
|
|
//per bilancio a sezioni contrapposte all'ultima immissione
|
|
// W96SALDI in questa funzione e' stato aggiunto il parametro saldo_chiusura che di default
|
|
// e' TRUE. A cosa serve ? Serve per includere nel calcolo del saldo all' ultima immissione
|
|
// anche il saldo finale compilato nei movimenti di chiusura (se non venisse considerato i conti
|
|
// risulterebbero aperti); siccome alcuni programmi (esempio il bilancio IV dir. CEE) non ne
|
|
// devono tenere conto, si e' data la 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;
|
|
bool esito = FALSE;
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_saldo = ZERO;
|
|
_saldofin = ZERO;
|
|
_sezsf = ' ';
|
|
_rec_presente_ec = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_prec = FALSE;
|
|
|
|
_saldi.zero();
|
|
_saldi.put(SLD_ANNOES,annoes);
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_FLSCA, "");
|
|
|
|
if (_saldi.read() == NOERR)
|
|
{
|
|
// annoe = _saldi.get_int(SLD_ANNOES);
|
|
// gruppo = _saldi.get_int(SLD_GRUPPO);
|
|
// conto = _saldi.get_int(SLD_CONTO);
|
|
// sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
|
|
_saldo_iniziale = _saldi.get_real(SLD_SALDO);
|
|
_prg_dare = _saldi.get_real(SLD_PDARE);
|
|
_prg_avere = _saldi.get_real(SLD_PAVERE);
|
|
pdarepro = _saldi.get_real(SLD_PDAREPRO);
|
|
paverepro = _saldi.get_real(SLD_PAVEREPRO);
|
|
sezione = _saldi.get_char(SLD_FLAGSALINI);
|
|
_sezsf = _saldi.get_char(SLD_FLAGSALFIN);
|
|
_saldofin = _saldi.get_real(SLD_SALDOFIN);
|
|
|
|
if (stp_prov == 1) //bilancio normale (senza provvisori)
|
|
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO);
|
|
|
|
if (stp_prov == 2) //bilancio globale (con provvisori)
|
|
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
|
|
|| pdarepro != ZERO || paverepro != ZERO);
|
|
|
|
if (stp_prov == 3) //bilancio dei soli mov. provvisori
|
|
esito = (pdarepro != ZERO || paverepro != ZERO);
|
|
|
|
if (sezione == 'A')
|
|
_saldo_iniziale = -_saldo_iniziale;
|
|
|
|
if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure
|
|
if (_sezsf == 'A') // no del saldo di chiusura inserita il 09-07-96
|
|
_saldofin = -_saldofin;
|
|
|
|
_rec_presente_ec = esito;
|
|
}
|
|
|
|
if (_saldo_iniziale.is_zero() && stp_prov != 3)
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
{
|
|
_prec = TRUE;
|
|
_saldo_iniziale += saldofin_esprec(annoes,g,c,s,false,stp_prov==2);
|
|
}
|
|
|
|
if (stp_prov == 1)
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
|
|
|
|
if (stp_prov == 2)
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro;
|
|
|
|
if (stp_prov == 3)
|
|
_saldo = pdarepro - paverepro;
|
|
|
|
if (saldo_chiusura) // W96SALDI modifica inserita per il discorso di inclusione oppure
|
|
_saldo += _saldofin; // no del saldo di chiusura inserita il 09-07-96
|
|
|
|
#ifdef __LONGDOUBLE__
|
|
_saldo.round(TCurrency::get_firm_dec());
|
|
#endif
|
|
|
|
return esito;
|
|
}
|
|
|
|
const real& TSaldo::saldo_periodo(int g, int c, long s, const TDate& dal, const TDate& al,
|
|
int indbil, bool provv, const TString & codcomm)
|
|
|
|
{
|
|
_saldo_iniziale = ZERO;
|
|
_saldo = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_movimentato = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_rec_presente_ec = FALSE;
|
|
_prec = FALSE;
|
|
|
|
TEsercizi_contabili es;
|
|
const int codes = es.date2esc(dal);
|
|
const TDate inizio = es.esercizio(codes).inizio();
|
|
const bool is_commessa = codcomm.not_empty();
|
|
|
|
_annoes = codes;
|
|
if( !is_commessa)
|
|
{
|
|
TString key(20);
|
|
|
|
key.format("%04d| |%d|%d|%ld", _annoes, g, c, s);
|
|
const TRectype & saldo = cache().get(LF_SALDI, key);
|
|
|
|
_saldo_iniziale = saldo.get_real(SLD_SALDO);
|
|
_prec = _saldo_iniziale == ZERO;
|
|
|
|
if (_prec)
|
|
{
|
|
_saldo_iniziale = saldofin_esprec(codes,g,c,s);
|
|
}
|
|
else
|
|
if (saldo.get_char(SLD_FLAGSALINI) == 'A')
|
|
_saldo_iniziale = -_saldo_iniziale;
|
|
}
|
|
|
|
|
|
TRelation relrmov(LF_RMOV);
|
|
TRectype & rmov = relrmov.curr();
|
|
|
|
rmov.put(RMV_GRUPPO,g);
|
|
rmov.put(RMV_CONTO,c);
|
|
rmov.put(RMV_SOTTOCONTO,s);
|
|
|
|
TCursor cur(&relrmov, "", 2, &rmov, &rmov);
|
|
const TRecnotype items = cur.items();
|
|
|
|
cur.freeze();
|
|
|
|
TString prompt(30);
|
|
|
|
prompt.format(FR("Calcolo saldo conto %d-%d-%ld"), g, c, s);
|
|
|
|
TProgind p(items, prompt, FALSE);
|
|
|
|
for (cur = 0L; cur.pos() < items && !p.iscancelled(); ++cur)
|
|
{
|
|
p.addstatus(1L);
|
|
|
|
const long num_reg = rmov.get_long(RMV_NUMREG);
|
|
const real importo = rmov.get_real(RMV_IMPORTO);
|
|
|
|
if ((!is_commessa || codcomm == rmov.get(RMV_CODCMS)) &&
|
|
importo != ZERO)
|
|
{
|
|
const char sezione = rmov.get_char(RMV_SEZIONE);
|
|
// "Se la causale del movimento e' di chiusura,
|
|
// o di apertura il movimento non va considerato"
|
|
const TString& movap = _causali_apertura.decode(_codcaus);
|
|
leggi_mov(num_reg);
|
|
|
|
if ((provv || _provv.empty()) && movap.blank())
|
|
{
|
|
if (_datacomp >= dal && _datacomp <= al)
|
|
{
|
|
_movimentato = TRUE;
|
|
|
|
if (sezione == 'D')
|
|
_prg_dare += importo;
|
|
else
|
|
_prg_avere += importo;
|
|
}
|
|
else
|
|
if ((!is_commessa) && _datacomp >= inizio && _datacomp < dal)
|
|
{
|
|
if (sezione == 'D')
|
|
_saldo_iniziale += importo;
|
|
else
|
|
_saldo_iniziale -= importo;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
|
|
return _saldo;
|
|
}
|
|
|
|
bool TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
|
|
{
|
|
if (annoesprec == 0)
|
|
_rec_presente_ep = FALSE;
|
|
else
|
|
{
|
|
const int oldkey = _saldi.getkey();
|
|
_saldi.setkey(1);
|
|
_saldi.zero();
|
|
_saldi.put(SLD_ANNOES,annoesprec);
|
|
_saldi.put(SLD_GRUPPO,g);
|
|
_saldi.put(SLD_CONTO,c);
|
|
_saldi.put(SLD_SOTTOCONTO,s);
|
|
_saldi.put(SLD_FLSCA, "");
|
|
_rec_presente_ep = _saldi.read() == NOERR;
|
|
_saldi.setkey(oldkey);
|
|
}
|
|
return _rec_presente_ep;
|
|
}
|
|
|
|
//calcolo dei progressivi attuali (normali o eliminati)
|
|
bool TSaldo::prg_saldo(int annoes, TConto& conto, real& prgdare, real& prgavere, bool scar)
|
|
{
|
|
_saldi.zero();
|
|
_saldi.put(SLD_GRUPPO,conto.gruppo());
|
|
_saldi.put(SLD_CONTO,conto.conto());
|
|
_saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
|
|
_saldi.put(SLD_ANNOES,annoes);
|
|
_saldi.put(SLD_FLSCA, scar);
|
|
|
|
bool ok = _saldi.read() == NOERR;
|
|
|
|
if (ok)
|
|
{
|
|
const char flagsalini = _saldi.get_char(SLD_FLAGSALINI);
|
|
const real saldoini = _saldi.get_real(SLD_SALDO);
|
|
prgdare = _saldi.get_real(SLD_PDARE);
|
|
prgavere = _saldi.get_real(SLD_PAVERE);
|
|
|
|
if (flagsalini == 'D')
|
|
prgdare += saldoini ;
|
|
else
|
|
prgavere += saldoini;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TContoExt
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TContoExt : public TConto
|
|
{
|
|
bool _scaricato;
|
|
|
|
public:
|
|
|
|
bool scaricato() const { return _scaricato; }
|
|
|
|
TContoExt(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL, bool sc = FALSE)
|
|
: TConto(g, c, s, t, d), _scaricato(sc) {}
|
|
TContoExt(TToken_string& tgcsd, int from, int mode = 0, bool sc = FALSE)
|
|
: TConto(tgcsd, from, mode), _scaricato(sc) {}
|
|
virtual ~TContoExt() {}
|
|
};
|
|
|
|
const TString& TTab_conti::build_key(const TBill& c, int anno, bool scar) const
|
|
{
|
|
static TString80 key;
|
|
key.format("%4d%3d%3d%6ld%c", anno, c.gruppo(), c.conto(), c.sottoconto(), scar ? 'X' : '\0');
|
|
return key;
|
|
}
|
|
|
|
TConto* TTab_conti::add(const TBill& c, int anno, bool scar)
|
|
{
|
|
const TString& key = build_key(c, anno, scar);
|
|
TContoExt* tc = new TContoExt(c.gruppo(), c.conto(), c.sottoconto(),
|
|
c.tipo(), NULL, scar);
|
|
TAssoc_array::add(key, tc);
|
|
return tc;
|
|
}
|
|
|
|
TConto* TTab_conti::find(const TBill& c, int anno, bool scar)
|
|
{
|
|
const TString& key = build_key(c, anno, scar);
|
|
TContoExt* tc = (TContoExt*)objptr(key);
|
|
return tc;
|
|
}
|
|
|
|
void TTab_conti::remove(const TBill& c, int anno, bool scar)
|
|
{
|
|
const TString& key = build_key(c, anno, scar);
|
|
TAssoc_array::remove(key);
|
|
}
|
|
|
|
void TTab_conti::aggiorna_conto(const TBill& tcon,
|
|
int anno_es, const TImporto& importo, tiposal movap,
|
|
bool provv, bool somma, bool movimentato, bool scaricato)
|
|
{
|
|
TContoExt* tc = (TContoExt*)find(tcon, anno_es, scaricato);
|
|
if (tc == NULL)
|
|
tc = (TContoExt*)add(tcon, anno_es, scaricato);
|
|
|
|
const real i(somma ? importo.valore() : -importo.valore());
|
|
|
|
if (provv)
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->darepro() += i;
|
|
else
|
|
tc->averepro() += i;
|
|
}
|
|
else
|
|
{
|
|
if (movap == apertura)
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->saldo() += i;
|
|
else
|
|
tc->saldo() -= i;
|
|
}
|
|
else
|
|
{
|
|
if (movap == chiusura)
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->saldofin() += i;
|
|
else
|
|
tc->saldofin() -= i;
|
|
}
|
|
else
|
|
{
|
|
if (importo.sezione() == 'D')
|
|
tc->dare() += i;
|
|
else
|
|
tc->avere() += i;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// rimuovo dalla tabella il conto se dare e avere vanno a zero
|
|
if (!movimentato)
|
|
if (tc->dare().is_zero() && tc->avere().is_zero() &&
|
|
tc->saldofin().is_zero() && tc->darepro().is_zero() &&
|
|
tc->averepro().is_zero() && tc->saldo().is_zero())
|
|
remove(*tc, anno_es, scaricato);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TSaldo_agg
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TSaldo_agg::TSaldo_agg() : _anno_es(0), _data_ulmov(""), _num_ulmov(0l),
|
|
_movap(normale), _provv(FALSE), _movimentato(FALSE)
|
|
{}
|
|
|
|
void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma, bool scaricato)
|
|
{
|
|
_tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato);
|
|
}
|
|
|
|
void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione,
|
|
bool somma, bool scaricato)
|
|
{
|
|
const TBill bill(gruppo, conto, sottoconto);
|
|
const TImporto imp(sezione, importo);
|
|
_tab_conti.aggiorna_conto(bill, _anno_es, imp, _movap,
|
|
_provv, somma, _movimentato, scaricato);
|
|
}
|
|
|
|
void TSaldo_agg::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(FR("Errore %d nell'aggiornamento del saldo %d %d %ld"),
|
|
err, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
|
|
}
|
|
|
|
// Calcolo saldo finale per controllo segno in prima nota
|
|
if (si.is_zero())
|
|
{
|
|
TLocalisamfile pcon(LF_PCON);
|
|
TRectype& curr = pcon.curr();
|
|
curr.put(PCN_GRUPPO, tcon.gruppo());
|
|
curr.put(PCN_CONTO, tcon.conto());
|
|
const int err = pcon.read();
|
|
if (err == NOERR)
|
|
{
|
|
const int indbil = curr.get_int(PCN_INDBIL);
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
{
|
|
TSaldo saldo;
|
|
si = saldo.saldofin_esprec(annoes, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
|
|
if (si < ZERO)
|
|
{
|
|
flag_salini = 'A'; si = -si;
|
|
}
|
|
else
|
|
flag_salini = 'D';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Era errore fatale
|
|
}
|
|
}
|
|
|
|
TImporto sf(flag_salini, si);
|
|
const TImporto dare('D', saldi.get_real(SLD_PDARE));
|
|
const TImporto avere('A', saldi.get_real(SLD_PAVERE));
|
|
sf += dare;
|
|
sf += avere;
|
|
sf.normalize(+1); // Rendi sempre positivo
|
|
tcon.saldo_finale() = sf;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TBalance
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TBalance::TBalance()
|
|
{
|
|
}
|
|
|
|
TBalance::TBalance(int g, int c, long s, int esercizio, bool ignora_movap, bool provvis)
|
|
{
|
|
read(g, c, s, esercizio, ignora_movap, provvis);
|
|
}
|
|
|
|
TBalance::TBalance(const TBill& b, int esercizio, bool ignora_movap, bool provvis)
|
|
{
|
|
read(b, esercizio, ignora_movap, provvis);
|
|
}
|
|
|
|
bool TBalance::find(const TBill& b, int esercizio,
|
|
TImporto& si, TImporto& da, TImporto& av, TImporto& sf,
|
|
TImporto& pd, TImporto& pa) const
|
|
{
|
|
CHECK(b.sottoconto() > 0L, "Sottoconto mancante");
|
|
|
|
TString key(30);
|
|
key.format("%d||%d|%d|%ld", esercizio, b.gruppo(), b.conto(), b.sottoconto());
|
|
const TRectype & saldi = cache().get(LF_SALDI, key);
|
|
if (!saldi.empty())
|
|
{
|
|
si.set(saldi.get_char(SLD_FLAGSALINI), saldi.get_real(SLD_SALDO));
|
|
da.set('D', saldi.get_real(SLD_PDARE));
|
|
av.set('A', saldi.get_real(SLD_PAVERE));
|
|
sf.set(saldi.get_char(SLD_FLAGSALFIN), saldi.get_real(SLD_SALDOFIN));
|
|
pd.set('D', saldi.get_real(SLD_PDAREPRO));
|
|
pa.set('A', saldi.get_real(SLD_PAVEREPRO));
|
|
}
|
|
else
|
|
{
|
|
si.set('D', ZERO);
|
|
da = av = sf = pd = pa = si;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
void TBalance::read(int gruppo, int conto, long sottoconto, int esercizio, bool ignora_movap, bool provvis)
|
|
{
|
|
const TBill zio(gruppo, conto, sottoconto);
|
|
read(zio, esercizio, ignora_movap, provvis);
|
|
}
|
|
|
|
int TBalance::indicatore_bilancio(const TBill& b) const
|
|
{
|
|
TString16 str;
|
|
str.format("%d|%d", b.gruppo(), b.conto());
|
|
const int ib = atoi(cache().get(LF_PCON, str, PCN_INDBIL));
|
|
if (ib == 0)
|
|
NFCHECK("Impossibile stabilire l'indicatore di bilancio");
|
|
return ib;
|
|
}
|
|
|
|
void TBalance::read(const TBill& b, int esercizio, bool ignora_movap, bool provvis)
|
|
{
|
|
TImporto si, sf, pd, pa, prd, pra;
|
|
|
|
find(b, esercizio, si, pd, pa, sf, prd, pra);
|
|
if (provvis)
|
|
{
|
|
pd += prd;
|
|
pa += pra;
|
|
}
|
|
_saldo_ini = si;
|
|
_progr_dare = pd;
|
|
_progr_avere = pa;
|
|
_saldo_fin = sf;
|
|
|
|
if (_saldo_ini.is_zero())
|
|
{
|
|
const int indbil = indicatore_bilancio(b);
|
|
if (indbil == 1 || indbil == 2 || indbil == 5)
|
|
{
|
|
TEsercizi_contabili esercizi;
|
|
const int precedente = esercizi.pred(esercizio);
|
|
if (precedente > 0 && find(b, precedente, si, pd, pa, sf, prd, pra))
|
|
{
|
|
if (provvis)
|
|
{
|
|
pd += prd;
|
|
pa += pra;
|
|
}
|
|
_saldo_ini = si;
|
|
_saldo_ini += pd;
|
|
_saldo_ini += pa;
|
|
_saldo_ini += sf;
|
|
_saldo_ini.normalize();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ignora_movap)
|
|
_saldo_ini.set('D', ZERO);
|
|
}
|
|
}
|
|
|
|
const TImporto& TBalance::saldo_iniziale() const
|
|
{ return _saldo_ini; }
|
|
|
|
const real& TBalance::progressivo_dare_iniziale() const
|
|
{
|
|
return _saldo_ini.sezione() == 'D' ? _saldo_ini.valore() : ZERO;
|
|
}
|
|
|
|
const real& TBalance::progressivo_avere_iniziale() const
|
|
{
|
|
return _saldo_ini.sezione() == 'A' ? _saldo_ini.valore() : ZERO;
|
|
}
|
|
|
|
real TBalance::progressivo_dare_finale() const
|
|
{
|
|
real pd = progressivo_dare_iniziale();
|
|
pd += _progr_dare.valore();
|
|
if (_saldo_fin.sezione() == 'D')
|
|
pd += _saldo_fin.valore();
|
|
return pd;
|
|
}
|
|
|
|
real TBalance::progressivo_avere_finale() const
|
|
{
|
|
real pa = progressivo_avere_iniziale();
|
|
pa += _progr_avere.valore();
|
|
if (_saldo_fin.sezione() == 'A')
|
|
pa += _saldo_fin.valore();
|
|
return pa;
|
|
}
|
|
|
|
TImporto TBalance::saldo_finale(bool chiusura) const
|
|
{
|
|
TImporto sf(_saldo_ini);
|
|
sf += _progr_dare;
|
|
sf += _progr_avere;
|
|
if (chiusura)
|
|
sf += _saldo_fin;
|
|
return sf;
|
|
}
|
|
|
|
TImporto TBalance::saldo_finale_chiusura() const
|
|
{
|
|
return saldo_finale(TRUE);
|
|
}
|
|
|