674 lines
17 KiB
C++
Executable File
674 lines
17 KiB
C++
Executable File
// cglib01.cpp
|
|
// calcolo dei saldi
|
|
|
|
#include <applicat.h>
|
|
#include <config.h>
|
|
#include <isam.h>
|
|
#include <tabutil.h>
|
|
#include <utility.h>
|
|
|
|
#include <rmov.h>
|
|
#include <mov.h>
|
|
#include <saldi.h>
|
|
#include <pconti.h>
|
|
#include <causali.h>
|
|
#include <clifo.h>
|
|
|
|
#include "cglib.h"
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Causale
|
|
///////////////////////////////////////////////////////////
|
|
|
|
TCaus::TCaus(const char* cod)
|
|
: _rec(LF_CAUSALI)
|
|
{
|
|
//if (*cod) read(cod);
|
|
read(cod);
|
|
}
|
|
|
|
|
|
// Legge le righe della causale attualmente selezionata sulla maschera
|
|
bool TCaus::read(const char* cod)
|
|
{
|
|
TLocalisamfile caus(LF_CAUSALI);
|
|
|
|
_rec = caus.curr(); _rec.zero(); // Delete header
|
|
|
|
if (*cod > ' ')
|
|
{
|
|
caus.setkey(1);
|
|
caus.put(CAU_CODCAUS, cod);
|
|
|
|
int err = caus.read();
|
|
if (err != NOERR) return FALSE;
|
|
_rec = caus.curr();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TCaus::chiusura() const
|
|
{ return _rec.get_char("MOVAP") == 'C'; }
|
|
|
|
bool TCaus::apertura() const
|
|
{ return _rec.get_char("MOVAP") == 'A'; }
|
|
|
|
//
|
|
// Cerca l'esercizio precedente di EseCorr
|
|
// Se EseCorr e' gia' il primo ritorna 0
|
|
// senno' ritorna, astutamente, EseCorr - 1
|
|
//
|
|
const int EsePre(const int EseCorr)
|
|
{
|
|
TTable ese("ESC");
|
|
TString first(30);
|
|
TString16 codtab;
|
|
|
|
ese.first();
|
|
first = ese.get("CODTAB");
|
|
|
|
codtab.format("%04d", EseCorr);
|
|
|
|
if (codtab == first)
|
|
return 0;
|
|
|
|
return EseCorr - 1;
|
|
}
|
|
|
|
// aep e' l'esercizio precedente
|
|
TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par)
|
|
{
|
|
TLocalisamfile cf(LF_SALDI, FALSE);
|
|
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);
|
|
|
|
// if (aep)
|
|
cf.setkey(2);
|
|
/* else
|
|
{
|
|
cf.setkey(1);
|
|
cf.put(SLD_ANNOES,aec);
|
|
}
|
|
*/
|
|
cf.put(SLD_GRUPPO,gr);
|
|
cf.put(SLD_CONTO,co);
|
|
// TRectype rec(cf.curr());
|
|
|
|
for (cf.read(_isgteq);!cf.eof();cf.next())
|
|
{
|
|
// if (cf.curr() > rec) break;
|
|
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 (aep) {
|
|
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
|
|
if (aep_par)
|
|
force = FALSE;
|
|
else
|
|
force = TRUE;
|
|
|
|
add((const char*) key, r, force);
|
|
}
|
|
}
|
|
|
|
TRectype* TSaldi_list::saldi() const
|
|
{
|
|
TObject* o = ((TAssoc_array*)this)->get();
|
|
if (o == NULL)
|
|
return (TRectype*)NULL;
|
|
else
|
|
return (TRectype*)o;
|
|
}
|
|
|
|
TSaldo::TSaldo()
|
|
{
|
|
_saldo_ep = new TRectype(LF_SALDI);
|
|
_saldo_iniziale = ZERO;
|
|
_saldoiniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_saldo = ZERO;
|
|
_annoes = 0;
|
|
_indbil = 0;
|
|
_prec = FALSE;
|
|
_movimentato = _significativo = FALSE;
|
|
_rec_presente_ec = _rec_presente_ep = FALSE;
|
|
}
|
|
|
|
TSaldo::~TSaldo()
|
|
{
|
|
delete _saldo_ep;
|
|
}
|
|
|
|
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
|
|
{
|
|
const int annoesprec = EsePre(annoes);
|
|
if (annoesprec == 0) // non ci sono esercizi prima del primo
|
|
{
|
|
_rec_presente_ep = FALSE;
|
|
_significativo = FALSE;
|
|
return ZERO;
|
|
}
|
|
|
|
const TRectype& app = ricerca_progr_prec(annoesprec, g, c, s);
|
|
|
|
const char flag = app.get(SLD_FLAGSALINI)[0];
|
|
const real saldo = app.get_real(SLD_SALDO);
|
|
const real pdare = app.get_real(SLD_PDARE);
|
|
const real pavere = app.get_real(SLD_PAVERE);
|
|
//const real pdaresca = app.get_real(SLD_PDARESCA);
|
|
//const real paveresca = app.get_real(SLD_PAVERESCA);
|
|
|
|
/*
|
|
_significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO
|
|
|| pdaresca != ZERO || paveresca != ZERO);
|
|
*/
|
|
_significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO);
|
|
|
|
//real tot = pdare-pavere+pdaresca-paveresca;
|
|
real tot = pdare-pavere;
|
|
|
|
if (flag == 'D')
|
|
tot += saldo;
|
|
else
|
|
tot -= saldo;
|
|
|
|
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, pdaresca, paveresca, pdare, pavere;
|
|
char flag;
|
|
TLocalisamfile saldi(LF_SALDI, FALSE);
|
|
|
|
_significativo = TRUE;
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,g);
|
|
saldi.put(SLD_CONTO,c);
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
saldi.put(SLD_ANNOES,_annoes);
|
|
|
|
if (saldi.read() == NOERR)
|
|
_rec_presente_ec = TRUE;
|
|
else
|
|
{
|
|
saldi.zero();
|
|
_rec_presente_ec = FALSE;
|
|
}
|
|
|
|
flag = saldi.get_char(SLD_FLAGSALINI);
|
|
saldoini = saldi.get_real(SLD_SALDO);
|
|
|
|
_significativo = (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);
|
|
flag = 'D'; // Il segno DEVE essere quello del saldo precedente
|
|
}
|
|
_saldo_iniziale = saldoini;
|
|
}
|
|
|
|
#ifdef DBG
|
|
TString sldi(saldoini.string());
|
|
#endif
|
|
|
|
//if (flag == 'D')
|
|
//return saldoini;
|
|
return _saldo_iniziale;
|
|
//else
|
|
//return (-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");
|
|
}
|
|
|
|
void TSaldo::leggi_mov(long nr)
|
|
{
|
|
TLocalisamfile mov(LF_MOV, FALSE);
|
|
|
|
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);
|
|
_datacomp = mov.get_date(MOV_DATACOMP);
|
|
}
|
|
}
|
|
|
|
//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)
|
|
{
|
|
TString16 gcs_corr, gcs_prec;
|
|
int gruppo, conto, annoe;
|
|
long sottoconto, num_reg;
|
|
real importo;
|
|
TDate data_mov;
|
|
char sezione;
|
|
|
|
TLocalisamfile rmov(LF_RMOV, FALSE);
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_saldo = ZERO;
|
|
_movimentato = FALSE;
|
|
_rec_presente_ep = FALSE;
|
|
_rec_presente_ec = FALSE;
|
|
_prec = FALSE;
|
|
|
|
gcs_prec = "";
|
|
|
|
rmov.setkey(2);
|
|
rmov.zero();
|
|
rmov.put(RMV_GRUPPO,g);
|
|
rmov.put(RMV_CONTO,c);
|
|
rmov.put(RMV_SOTTOCONTO,s);
|
|
TRectype rec(rmov.curr());
|
|
|
|
for (rmov.read(_isgteq); !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);
|
|
num_reg = rmov.get_long(RMV_NUMREG);
|
|
sezione = rmov.get_char(RMV_SEZIONE);
|
|
importo = rmov.get_real(RMV_IMPORTO);
|
|
|
|
// 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' uguale a quella di chiusura,
|
|
// o di apertura il movimento non va considerato"
|
|
// if (_codcaus.not_empty())
|
|
// if (_codcaus == causale_chiusura_es() ||
|
|
// _codcaus == causale_apertura_es())
|
|
// continue;
|
|
|
|
// Modifica del 03-03-1995
|
|
TCaus cau(_codcaus);
|
|
|
|
if (_codcaus.not_empty())
|
|
if (cau.chiusura()) //|| cau.apertura())
|
|
continue;
|
|
|
|
/*
|
|
if (!stp_prov && _provv.trim().not_empty())
|
|
continue;
|
|
*/
|
|
|
|
if (stp_prov == 1 && _provv.trim().not_empty()) //bilancio normale (non comprende i provvisori)
|
|
continue;
|
|
|
|
if (stp_prov == 3 && _provv.trim().empty()) //bilancio dei soli provvisori
|
|
continue;
|
|
|
|
// "I mov. di puro riferimento (= con importo = 0) vanno scartati"
|
|
if (importo == ZERO) continue;
|
|
|
|
gcs_corr = format ("%3d%3d%6ld", gruppo, conto, sottoconto);
|
|
|
|
if (gcs_corr != gcs_prec)
|
|
{
|
|
gcs_prec = gcs_corr;
|
|
if (stp_prov != 3) //bilancio normale o globale
|
|
_saldo = calcola_saldo_iniziale(gruppo,conto,sottoconto,indbil);
|
|
}
|
|
|
|
#ifdef DBG
|
|
TString dep1(_saldo.string());
|
|
#endif
|
|
|
|
_movimentato = TRUE;
|
|
|
|
if (sezione == 'D')
|
|
_saldo += importo;
|
|
else
|
|
_saldo -= importo;
|
|
}
|
|
#ifdef DBG
|
|
TString dep2(_saldo.string());
|
|
#endif
|
|
|
|
// Anche se non movimentato vado a vedere il saldo
|
|
if (!_movimentato)
|
|
if (stp_prov != 3)
|
|
_saldo = calcola_saldo_iniziale(g,c,s,indbil);
|
|
|
|
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;
|
|
int gruppo, conto, annoe;
|
|
long sottoconto;
|
|
real pdarepro, paverepro;
|
|
bool esito = FALSE;
|
|
TLocalisamfile saldi(LF_SALDI, FALSE);
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_saldoiniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_prg_daresca = ZERO;
|
|
_prg_averesca = ZERO;
|
|
_saldo = ZERO;
|
|
|
|
saldi.zero();
|
|
|
|
saldi.put(SLD_ANNOES,annoes);
|
|
saldi.put(SLD_GRUPPO,g);
|
|
saldi.put(SLD_CONTO,c);
|
|
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_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);
|
|
|
|
if (stp_prov == 1) //bilancio normale (senza provvisori)
|
|
if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO)
|
|
return esito;
|
|
|
|
if (stp_prov == 2) //bilancio globale (con provvisori)
|
|
if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO
|
|
&& pdarepro == ZERO && paverepro == ZERO)
|
|
return esito;
|
|
|
|
if (stp_prov == 3) //bilancio dei soli mov. provvisori
|
|
if (pdarepro == ZERO && paverepro == ZERO)
|
|
return esito;
|
|
|
|
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
|
|
|
|
_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;
|
|
|
|
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;
|
|
}
|
|
return esito;
|
|
}
|
|
|
|
//per bilancio a sezioni contrapposte all'ultima immissione
|
|
bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil,int stp_prov)
|
|
{
|
|
//Si considerano i saldi e non piu' i movimenti
|
|
char sezione;
|
|
int gruppo, conto, annoe;
|
|
long sottoconto;
|
|
real pdarepro, paverepro;
|
|
bool esito = FALSE;
|
|
TLocalisamfile saldi(LF_SALDI, FALSE);
|
|
|
|
_saldo_iniziale = ZERO;
|
|
_prg_dare = ZERO;
|
|
_prg_avere = ZERO;
|
|
_prg_daresca = ZERO;
|
|
_prg_averesca = 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);
|
|
|
|
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);
|
|
|
|
/*
|
|
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
|
|
|| _prg_daresca != ZERO || _prg_averesca != ZERO);
|
|
*/
|
|
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;
|
|
|
|
_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);
|
|
}
|
|
|
|
//_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
|
|
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;
|
|
|
|
return esito;
|
|
}
|
|
|
|
TRectype& TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
|
|
{
|
|
TLocalisamfile saldi(LF_SALDI, FALSE);
|
|
|
|
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);
|
|
|
|
if (saldi.read() == NOERR)
|
|
_rec_presente_ep = TRUE;
|
|
else
|
|
{
|
|
saldi.zero();
|
|
_rec_presente_ep = FALSE;
|
|
}
|
|
|
|
(*_saldo_ep) = saldi.curr();
|
|
saldi.setkey(oldkey);
|
|
|
|
// riposiziona...
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,g);
|
|
saldi.put(SLD_CONTO,c);
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
saldi.put(SLD_ANNOES,annoesprec+1);
|
|
saldi.read(_isequal);
|
|
|
|
return (*_saldo_ep);
|
|
}
|
|
|
|
//calcolo dei progressivi attuali
|
|
bool TSaldo::prg_attuali(int annoes,TConto& conto,real& prgdare,real& prgavere)
|
|
{
|
|
real saldoini = ZERO;
|
|
real pdare = ZERO;
|
|
real pavere = ZERO;
|
|
real pdaresca = ZERO;
|
|
real paveresca = ZERO;
|
|
char flagsalini;
|
|
int g = conto.gruppo();
|
|
int c = conto.conto();
|
|
long s = conto.sottoconto();
|
|
TLocalisamfile saldi(LF_SALDI, FALSE);
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,g);
|
|
saldi.put(SLD_CONTO,c);
|
|
saldi.put(SLD_SOTTOCONTO,s);
|
|
saldi.put(SLD_ANNOES,annoes);
|
|
|
|
if (saldi.read() == NOERR)
|
|
{
|
|
flagsalini = saldi.get_char(SLD_FLAGSALINI);
|
|
saldoini = saldi.get_real(SLD_SALDO);
|
|
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 TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prgavere)
|
|
{
|
|
real saldoini = ZERO;
|
|
real pdaresca = ZERO;
|
|
real paveresca = ZERO;
|
|
char flagsalini;
|
|
int g = conto.gruppo();
|
|
int c = conto.conto();
|
|
long s = conto.sottoconto();
|
|
TLocalisamfile saldi(LF_SALDI, FALSE);
|
|
|
|
saldi.zero();
|
|
saldi.put(SLD_GRUPPO,g);
|
|
saldi.put(SLD_CONTO,c);
|
|
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);
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
|
|
|