488 lines
13 KiB
C++
Executable File
488 lines
13 KiB
C++
Executable File
// cglib01.cpp
|
|
// calcolo dei saldi
|
|
|
|
#include <applicat.h>
|
|
#include <date.h>
|
|
#include <real.h>
|
|
#include <lffiles.h>
|
|
#include <isam.h>
|
|
#include <utility.h>
|
|
#include <config.h>
|
|
#include <rmov.h>
|
|
#include <mov.h>
|
|
#include <saldi.h>
|
|
#include <pconti.h>
|
|
#include <clifo.h>
|
|
|
|
#include "cglib.h"
|
|
|
|
const MAXSTR = 128;
|
|
static char __tmp [MAXSTR];
|
|
static TFixed_string tmp (__tmp, MAXSTR);
|
|
|
|
TClifo_list::TClifo_list(int g, int c, char tipocf)
|
|
{
|
|
TLocalisamfile cf(LF_CLIFO);
|
|
destroy();
|
|
cf.setkey(3);
|
|
cf.zero();
|
|
cf.put(CLI_TIPOCF,tipocf);
|
|
cf.put(CLI_GRUPPO,g);
|
|
cf.put(CLI_CONTO,c);
|
|
TRectype rec(cf.curr());
|
|
cf.read(_isgteq);
|
|
for ( ;!cf.eof();cf.next())
|
|
{
|
|
if (cf.curr() > rec) break;
|
|
TRectype r(cf.curr());
|
|
add(r);
|
|
}
|
|
}
|
|
|
|
Saldo::Saldo()
|
|
{
|
|
_saldo_iniziale = 0.00;
|
|
_prg_dare = 0.00;
|
|
_prg_avere = 0.00;
|
|
_saldo = 0.00;
|
|
_indbil = 0;
|
|
_saldi = new TLocalisamfile(LF_SALDI);
|
|
_mov = new TLocalisamfile(LF_MOV);
|
|
_rmov = new TLocalisamfile(LF_RMOV);
|
|
_clifo = new TLocalisamfile(LF_CLIFO);
|
|
}
|
|
|
|
Saldo::~Saldo()
|
|
{
|
|
delete _saldi;
|
|
delete _mov;
|
|
delete _rmov;
|
|
delete _clifo;
|
|
}
|
|
|
|
real Saldo::saldofin_esprec(int annoes, int g, int c, long s)
|
|
{
|
|
real saldo,pdare,pavere,pdaresca,paveresca;
|
|
char flag;
|
|
|
|
TRectype app = ricerca_progr_prec(annoes-1, g, c, s);
|
|
|
|
flag = app.get(SLD_FLAGSALINI)[0];
|
|
saldo = app.get_real(SLD_SALDO);
|
|
pdare = app.get_real(SLD_PDARE);
|
|
pavere = app.get_real(SLD_PAVERE);
|
|
pdaresca = app.get_real(SLD_PDARESCA);
|
|
paveresca = app.get_real(SLD_PAVERESCA);
|
|
if (flag == 'D')
|
|
return saldo+pdaresca-paveresca+pdare-pavere;//saldo finale es. precedente;
|
|
else //if (flag == 'A')
|
|
return pdaresca-saldo-paveresca+pdare-pavere;
|
|
}
|
|
|
|
real Saldo::calcola_saldo_iniziale(int annoes,int g,int c,long s,int indbil)
|
|
{
|
|
real saldoini, pdaresca, paveresca;
|
|
char flag;
|
|
TLocalisamfile& saldi = *_saldi;
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,g);
|
|
if (c != 0)
|
|
saldi.put(SLD_CONTO,c);
|
|
if (s != 0)
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
saldi.put(SLD_ANNOES,annoes);
|
|
|
|
saldi.read();
|
|
|
|
if (saldi.bad())
|
|
saldi.zero();
|
|
|
|
flag = saldi.get(SLD_FLAGSALINI)[0];
|
|
saldoini = saldi.get_real(SLD_SALDO);
|
|
pdaresca = saldi.get_real(SLD_PDARESCA);
|
|
paveresca = saldi.get_real(SLD_PAVERESCA);
|
|
|
|
if (saldoini == 0.00) //e il conto e' patrimoniale o d'ordine
|
|
if ( (indbil == 1)||(indbil == 2)||(indbil == 5) )
|
|
saldoini = saldofin_esprec(annoes, g, c, s);
|
|
|
|
if (flag == 'D')
|
|
return saldoini+pdaresca-paveresca;
|
|
else //if (flag == 'A')
|
|
return pdaresca-saldoini-paveresca;
|
|
}
|
|
|
|
// La funzione seguente calcola il saldo per data limite o all'ultima immissione es.in /
|
|
// corso o precedente, a seconda del valore dei suoi parametri al momento della chiamata
|
|
bool Saldo::calcola(int annoes, int annoesprec, int g, int c, long s,
|
|
const TDate& data_inf, const TDate& data_sup,
|
|
int indbil, bool controllo_competenza, const TDate& inizio_es,
|
|
const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
|
|
{
|
|
if (data_sup.ok())
|
|
{
|
|
if (!calcola_data_limite(annoes, g, c, s, data_inf, data_sup, indbil,
|
|
controllo_competenza, inizio_es, fine_es, fine_es_prec,stp_prov))
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (!calcola_ultima_immissione(annoes, annoesprec, g, c, s, indbil))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
const char* Saldo::causale_chiusura_es()
|
|
{
|
|
TConfig conf(CONFIG_DITTA);
|
|
tmp = conf.get("CoCaCh");
|
|
|
|
return __tmp;
|
|
}
|
|
|
|
const char* Saldo::causale_apertura_es()
|
|
{
|
|
TConfig conf(CONFIG_DITTA);
|
|
tmp = conf.get("CoCaAp");
|
|
|
|
return __tmp;
|
|
}
|
|
|
|
bool Saldo::causale_mov(long nr, const TDate& inizio_es, const TDate& data_sup, TString& provv)
|
|
{
|
|
TString codcaus;
|
|
TDate datareg;
|
|
TLocalisamfile& mov = *_mov;
|
|
|
|
mov.zero();
|
|
mov.put (MOV_NUMREG,nr);
|
|
|
|
if (mov.read() == NOERR)
|
|
{
|
|
codcaus = mov.get(MOV_CODCAUS);
|
|
datareg = mov.get_date(MOV_DATAREG);
|
|
provv = mov.get(MOV_PROVVIS);
|
|
if (codcaus == causale_chiusura_es())
|
|
return TRUE;
|
|
|
|
if (codcaus == causale_apertura_es())
|
|
if ( (datareg < inizio_es) || (datareg > data_sup) )
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
bool Saldo::calcola_data_limite(int annoes, int g, int c, long s, const TDate& data_inf, const TDate& data_sup, int indbil, bool controllo_competenza, const TDate& inizio_es, const TDate& fine_es, const TDate& fine_es_prec,bool stp_prov)
|
|
{
|
|
TString sezione, gcs_corr, gcs_prec="", provv = "";
|
|
real importo, dep = 0.00;
|
|
int gruppo, conto, annoe;
|
|
long sottoconto, num_reg;
|
|
TLocalisamfile& rmov = *_rmov;
|
|
|
|
TDate data_rmv;
|
|
bool esito = FALSE;
|
|
|
|
rmov.setkey(2);
|
|
rmov.zero();
|
|
rmov.put(RMV_GRUPPO,g);
|
|
if (c != 0)
|
|
rmov.put(RMV_CONTO,c);
|
|
if (s != 0)
|
|
rmov.put(RMV_SOTTOCONTO,s);
|
|
TRectype rec(rmov.curr());
|
|
|
|
rmov.read(_isgteq);
|
|
for ( ; !rmov.eof(); rmov.next())
|
|
{
|
|
if (rmov.curr() != rec) break;
|
|
|
|
annoe = rmov.get_int(RMV_ANNOES);
|
|
gruppo = rmov.get_int(RMV_GRUPPO);
|
|
conto = rmov.get_int(RMV_CONTO);
|
|
sottoconto = rmov.get_long(RMV_SOTTOCONTO);
|
|
data_rmv = rmov.get_date(RMV_DATAREG);
|
|
num_reg = rmov.get_long(RMV_NUMREG);
|
|
|
|
//se la causale del movimento e' uguale a quella di chiusura, il movimento non va considerato
|
|
if (causale_mov(num_reg,inizio_es,data_sup,provv))
|
|
break;
|
|
|
|
if ((!stp_prov) && (provv.trim().not_empty())) //se non e' richiesta stampa
|
|
continue; //mov. provvisori li scarto
|
|
|
|
gcs_corr = format ("%3d%3d%6ld", gruppo, conto, sottoconto);
|
|
|
|
if (gcs_corr != gcs_prec)
|
|
{
|
|
gcs_prec = gcs_corr;
|
|
dep += calcola_saldo_iniziale(annoe,gruppo,conto,sottoconto,indbil);
|
|
}
|
|
|
|
//controllo sulle date
|
|
if (annoe != annoes)
|
|
if (annoe != annoes-1)
|
|
continue;
|
|
|
|
if (controllo_competenza)
|
|
if ( (annoe == annoes -1) && (data_sup != fine_es) )
|
|
continue;
|
|
else
|
|
if ( (data_rmv <= fine_es) && (data_rmv <= fine_es_prec) ||
|
|
(data_rmv > fine_es) )
|
|
continue;
|
|
|
|
if ( (data_rmv < data_inf) || (data_rmv > data_sup) )
|
|
continue;
|
|
|
|
sezione = rmov.get(RMV_SEZIONE);
|
|
importo = rmov.get_real(RMV_IMPORTO);
|
|
|
|
if (importo.is_zero())
|
|
continue;
|
|
|
|
esito = TRUE;
|
|
|
|
if (sezione == "D") dep += importo;
|
|
else dep -= importo;
|
|
|
|
}
|
|
_saldo = dep;
|
|
return esito;
|
|
}
|
|
|
|
bool Saldo::calcola_ultima_immissione(int annoes, int annoesprec, int g, int c,
|
|
long s, int indbil)
|
|
{
|
|
//Si considerano i saldi e non piu' i movimenti
|
|
|
|
int gruppo, conto, annoe;
|
|
long sottoconto;
|
|
real saldo, pdare, pavere;
|
|
TLocalisamfile& saldi = *_saldi;
|
|
bool esito = FALSE;
|
|
|
|
_saldo_iniziale = 0.00;
|
|
_prg_dare = 0.00;
|
|
_prg_avere = 0.00;
|
|
saldi.zero();
|
|
|
|
if (annoes != 0)
|
|
saldi.put(SLD_ANNOES,annoes);
|
|
if (g != 0)
|
|
saldi.put(SLD_GRUPPO,g);
|
|
if (c != 0)
|
|
saldi.put(SLD_CONTO,c);
|
|
if (s != 0)
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
|
|
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 = saldi.get_real(SLD_SALDO);
|
|
pdare = saldi.get_real(SLD_PDARE);
|
|
pavere = saldi.get_real(SLD_PAVERE);
|
|
|
|
if (annoesprec == 0) //all'ultima immissione es.in corso
|
|
{
|
|
if ( (pdare == 0)&&(pavere == 0.0) )
|
|
{
|
|
if ( (indbil == 3) || (indbil == 4) )
|
|
return esito;
|
|
|
|
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
|
|
{
|
|
if (saldo == 0)
|
|
{
|
|
saldo = saldofin_esprec(annoes,gruppo,conto,sottoconto);
|
|
if (saldo == 0.00)
|
|
return esito;
|
|
}
|
|
_saldo_iniziale = saldo;
|
|
}
|
|
}
|
|
else _saldo_iniziale = saldo;
|
|
|
|
esito = TRUE;
|
|
_prg_dare = pdare;
|
|
_prg_avere = pavere;
|
|
|
|
// i tre valori precedenti vengono utilizzati per la stampa bilancio
|
|
// di verifica
|
|
|
|
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
|
|
|
|
}
|
|
else //all'ultima immissione es.precedente
|
|
{
|
|
TRecnotype numrec = saldi.recno();
|
|
TRectype app = ricerca_progr_prec(annoe-1, gruppo, conto, sottoconto);
|
|
annoe = app.get_int (SLD_ANNOES);
|
|
pdare = app.get_real(SLD_PDARE);
|
|
pavere = app.get_real(SLD_PAVERE);
|
|
saldi.readat(numrec);
|
|
if ( (pdare == 0) && (pavere == 0) )
|
|
return esito;
|
|
|
|
esito = TRUE;
|
|
_prg_dare = pdare;
|
|
_prg_avere = pavere;
|
|
_saldo = pdare - pavere;
|
|
}
|
|
}
|
|
return esito;
|
|
}
|
|
|
|
TRectype& Saldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
|
|
{
|
|
TLocalisamfile& saldi = *_saldi;
|
|
|
|
saldi.zero();
|
|
static TRectype rec(saldi.curr());
|
|
|
|
if (annoesprec != 0)
|
|
saldi.put(SLD_ANNOES,annoesprec);
|
|
if (g != 0)
|
|
saldi.put(SLD_GRUPPO,g);
|
|
if (c != 0)
|
|
saldi.put(SLD_CONTO,c);
|
|
if (s != 0)
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
|
|
saldi.read();
|
|
if (saldi.bad())
|
|
saldi.zero();
|
|
|
|
rec = saldi.curr();
|
|
return rec;
|
|
}
|
|
|
|
//calcolo dei progressivi attuali
|
|
bool Saldo::prg_attuali(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
|
|
{
|
|
real saldoini, pdare, pavere, pdaresca, paveresca;
|
|
char flagsalini;
|
|
int g = conto.gruppo();
|
|
int c = conto.conto();
|
|
long s = conto.sottoconto();
|
|
TLocalisamfile& saldi = *_saldi;
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,g);
|
|
if (conto.conto() != 0)
|
|
saldi.put(SLD_CONTO,c);
|
|
if (conto.sottoconto() != 0)
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
saldi.put(SLD_ANNOES,annoes);
|
|
|
|
if (saldi.read() == NOERR)
|
|
{
|
|
flagsalini = saldi.get(SLD_FLAGSALINI)[0];
|
|
saldoini = saldi.get_real(SLD_SALDO);
|
|
|
|
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
|
|
if (saldoini == 0)
|
|
{
|
|
saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
|
|
if (saldoini > 0.00)
|
|
flagsalini = 'D';
|
|
else flagsalini = 'A';
|
|
}
|
|
pdare = saldi.get_real(SLD_PDARE);
|
|
pavere = saldi.get_real(SLD_PAVERE);
|
|
pdaresca = saldi.get_real(SLD_PDARESCA);
|
|
paveresca = saldi.get_real(SLD_PAVERESCA);
|
|
if (flagsalini == 'D')
|
|
{
|
|
prgdare = saldoini + pdare + pdaresca;
|
|
prgavere = pavere + paveresca;
|
|
}
|
|
else
|
|
{
|
|
prgdare = pdare + pdaresca;
|
|
prgavere = saldoini + pavere + paveresca;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool Saldo::prg_mov_eliminati(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
|
|
{
|
|
real saldoini, pdaresca, paveresca;
|
|
char flagsalini;
|
|
TLocalisamfile& saldi = *_saldi;
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,conto.gruppo());
|
|
if (conto.conto() != 0)
|
|
saldi.put(SLD_CONTO,conto.conto());
|
|
if (conto.sottoconto() != 0)
|
|
saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
|
|
saldi.put(SLD_ANNOES,annoes);
|
|
|
|
if (saldi.read() == NOERR)
|
|
{
|
|
flagsalini = saldi.get(SLD_FLAGSALINI)[0];
|
|
saldoini = saldi.get_real(SLD_SALDO);
|
|
|
|
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
|
|
if (saldoini == 0)
|
|
{
|
|
saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
|
|
if (saldoini > 0.00)
|
|
flagsalini = 'D';
|
|
else flagsalini = 'A';
|
|
}
|
|
pdaresca = saldi.get_real(SLD_PDARESCA);
|
|
paveresca = saldi.get_real(SLD_PAVERESCA);
|
|
if (flagsalini == 'D')
|
|
{
|
|
prgdare = saldoini + pdaresca;
|
|
prgavere = paveresca;
|
|
}
|
|
else
|
|
{
|
|
prgdare = pdaresca;
|
|
prgavere = saldoini + paveresca;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
TLocalisamfile * get_descr_cf (TLocalisamfile * pconti,
|
|
TLocalisamfile * clifo, int g, int c, long s)
|
|
{
|
|
pconti->zero();
|
|
pconti->put (PCN_GRUPPO, g);
|
|
pconti->put (PCN_CONTO , c);
|
|
pconti->put (PCN_SOTTOCONTO, s);
|
|
|
|
pconti->read();
|
|
|
|
if (pconti->good())
|
|
return pconti;
|
|
|
|
TString tipocf = pconti->get(PCN_TMCF);
|
|
long codcf = s;
|
|
|
|
clifo->zero();
|
|
clifo->put(CLI_CODCF, codcf);
|
|
clifo->put(CLI_TIPOCF, tipocf);
|
|
|
|
clifo->read();
|
|
|
|
if (clifo->good())
|
|
return clifo;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
|