root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Corrrezioni ai bilanci e list movimenti

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1216 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
nik 1995-04-06 16:10:12 +00:00
parent e3b1c1f4d3
commit 7220946cc8
5 changed files with 540 additions and 400 deletions

375
cg/cg1500.cpp

@ -93,6 +93,7 @@ class CG1500_application : public TPrintapp
real _saldo_finale_tot, _saldo_ini_gruppo_dare, _saldo_ini_gruppo_avere;
real _gruppo_da_ordine, _gruppo_a_ordine;
real _prg_saldoini_dare, _prg_saldoini_avere, _prg_inidare_ord, _prg_iniavere_ord;
real _nuovo_tot_saldo_d, _nuovo_tot_saldo_a;
TDate _datalim, _data, _datada, _dataa, _dataini, _ultima_data, _u_max;
bool _cambiato_conto_1, _cambiato_conto_2, _add_file_avere;
@ -100,7 +101,7 @@ class CG1500_application : public TPrintapp
bool _add_dare, _add_avere, _controlla, _salto_pagina, _flag, _stampato;
bool _sottoc_dare, _sottoc_avere, _salto_pagina1, _livello_conto;
bool _stampa_mov_prov;
TString _causale_ap, _causale_chi;
//TString _causale_ap, _causale_chi;
TArray _clienti, _fornitori;
public:
@ -116,16 +117,15 @@ public:
virtual void preprocess_header();
virtual bool preprocess_page(int,int);
virtual print_action postprocess_page(int,int);
//virtual print_action postprocess_print(int,int);
virtual void postclose_print();
virtual void set_page(int,int);
real compensazione(bool compensa, int indbil_conto, real& saldo);
const char* causale_chiusura() { return _causale_chi;}
const char* causale_apertura() { return _causale_ap;}
//const char* causale_chiusura() { return _causale_chi;}
//const char* causale_apertura() { return _causale_ap;}
bool bil_sez_contr();
bool bil_verifica();
bool ricerca_sottoc_clifo(int,int,bool,int,real&);
bool ricerca_cf(int,int,char,real&,real&,real&,real&,real&,real&,real&);
bool ricerca_cf(int,int,char,int,real&,real&,real&,real&,real&,real&,real&);
bool calcola(int,int,long);
void leggi_pcon(); // Inizializza i TArray C/F
void crea_sort_clifo();
@ -140,7 +140,7 @@ public:
const real&, const real&);
int stampa_record_conto(int,int,const char*,const real&,const real&,
const real&,const real&,const real&,const char);
int stampa_intestazione_ditta();
int stampa_intestazione_ditta();
int cerca_indbil(int,int);
void scrivig_file_temp();
void scrivic_file_temp();
@ -778,7 +778,7 @@ bool CG1500_application::bil_sez_contr()
bool esiste_conto=FALSE, esiste_sc = FALSE;
bool movimentato = FALSE;
CHECK(_tmp_saldi_att == NULL, "La minchia che riapro cg01");
CHECK(_tmp_saldi_att == NULL, "La minchia che riapro cg01"); //Messaggio di Ferdinando, non mio!!!
_tmp_saldi_att = new TIsamtempfile(LF_SALDI, "cg01", 2);
_prog->addstatus(1);
_tmp_saldi_pass = new TIsamtempfile(LF_SALDI, "cg02", 2);
@ -1007,7 +1007,7 @@ bool CG1500_application::ricerca_sottoc_clifo(int g,int c, bool compensa, int in
bool esiste_sc = FALSE;
bool movimentato = FALSE;
if (_annoes) aep = _annoes-1;
if (_annoes) aep = EsePre(_annoes);
sld.set_annoes(_annoes);
_listacf = new TSaldi_list(g, c, _annoes, aep);
@ -1121,7 +1121,7 @@ bool CG1500_application::bil_verifica()
real mov_gruppo_dare, mov_gruppo_avere, prg_gruppo_dare, prg_gruppo_avere;
bool esiste_conto = FALSE, esiste_sc = FALSE, movimentato = FALSE;
CHECK(_tmp_saldi_att == NULL, "La minchia che riapro cg01");
CHECK(_tmp_saldi_att == NULL, "La minchia che riapro cg01"); //Messaggio di Ferdinando, non mio!!!
_tmp_saldi_att = new TIsamtempfile(LF_SALDI, "cg01", 2);
_gp=-1;
@ -1131,6 +1131,8 @@ bool CG1500_application::bil_verifica()
_saldo_ini_conto_avere = ZERO;
_saldo_ini_gruppo_dare = ZERO;
_saldo_ini_gruppo_avere = ZERO;
_nuovo_tot_saldo_d = ZERO;
_nuovo_tot_saldo_a = ZERO;
saldo_conto = ZERO;
mov_conto_dare = ZERO;
mov_conto_avere = ZERO;
@ -1218,7 +1220,7 @@ bool CG1500_application::bil_verifica()
indbil_conto = _pcn->get_int(PCN_INDBIL);
if ( (tipo_conto == 'C') || (tipo_conto == 'F') )
{
esiste_sc = ricerca_cf(g,c,tipo_conto,saldo_finale,saldo_iniziale,
esiste_sc = ricerca_cf(g,c,tipo_conto,indbil_conto,saldo_finale,saldo_iniziale,
mov_conto_dare,mov_conto_avere,prg_conto_dare,prg_conto_avere,
saldo_conto);
if ( (_verifica == 2) && (_stampav == 2) )
@ -1271,11 +1273,21 @@ bool CG1500_application::bil_verifica()
// if (_stampav == 1)
// continue;
movimentato = calcola(g,c,s);
if (movimentato || _stampav != 1)
{
saldo_iniziale = _saldo_ini_dare - _saldo_ini_avere;
_nuovo_tot_saldo_d += _mov_periodo_dare;
_nuovo_tot_saldo_a += _mov_periodo_avere;
if (saldo_iniziale > ZERO)
_nuovo_tot_saldo_d += saldo_iniziale;
else
{
real app = -saldo_iniziale;
_nuovo_tot_saldo_a += app;
}
if (_datada == _dataini)
saldo_finale = saldo_iniziale+_mov_periodo_dare-_mov_periodo_avere;
else if (_datada > _dataini)
@ -1294,10 +1306,19 @@ bool CG1500_application::bil_verifica()
// continue;
movimentato = sld.ultima_immissione_verifica(_annoes,g,c,s,indbil_conto);
//modifica del 31/03/95
if (!movimentato && _stampav!=1)
if (indbil_conto == 1 || indbil_conto == 2 || indbil_conto == 5)
saldo_iniziale = sld.saldofin_esprec(_annoes,g,c,s);
if (movimentato)
saldo_iniziale = sld.saldoini();
//fine modifica
if (movimentato || _stampav != 1)
{
saldo_iniziale = sld.saldoini();
//saldo_iniziale = sld.saldoini();
_mov_periodo_dare = sld.prgdare();
_mov_periodo_avere = sld.prgavere();
_prg_prec_dare = ZERO;
@ -1317,6 +1338,20 @@ bool CG1500_application::bil_verifica()
esiste_sc = TRUE;
esiste_conto = TRUE;
if (_tipo_stampa1 == 2)
{
_nuovo_tot_saldo_d += _mov_periodo_dare;
_nuovo_tot_saldo_a += _mov_periodo_avere;
real nuovo = sld.saldoinisusaldi();
if (nuovo > ZERO)
_nuovo_tot_saldo_d += nuovo;
else
{
nuovo = -nuovo;
_nuovo_tot_saldo_a += nuovo;
}
}
if (saldo_iniziale < ZERO)
_saldo_ini_conto_avere += saldo_iniziale;
else
@ -1356,7 +1391,6 @@ bool CG1500_application::bil_verifica()
_tmp_saldi_att->put(SLD_DATAULMOV,_u_max);
_tmp_saldi_att->write();
}
_gp = g;
_cp = c;
}
@ -1381,10 +1415,11 @@ bool CG1500_application::bil_verifica()
scrivi_record_gruppo(prg_gruppo_dare,prg_gruppo_avere,
mov_gruppo_dare,mov_gruppo_avere,saldo_gruppo);
}
if ( (_verifica == 1)||( (_verifica == 2)&&
(!((_stampav == 2)&&(saldo_conto == 0))) ) )
scrivi_record_conto(prg_conto_dare,prg_conto_avere,mov_conto_dare,
mov_conto_avere,saldo_conto);
if (esiste_sc)
if ( (_verifica == 1)||( (_verifica == 2)&&
(!((_stampav == 2)&&(saldo_conto == 0))) ) )
scrivi_record_conto(prg_conto_dare,prg_conto_avere,mov_conto_dare,
mov_conto_avere,saldo_conto);
}
_pcn->readat(recnum);
}
@ -1442,11 +1477,11 @@ bool CG1500_application::calcola(int g, int c, long s)
TString codcaus(mov.get(MOV_CODCAUS));
// if (codcaus.not_empty())
// if (codcaus == causale_chiusura())
// continue;
// if (codcaus.not_empty())
// if (codcaus == causale_chiusura())
// continue;
// Modifica del 03-03-95
// Modifica del 03-03-95
TCaus cau (codcaus);
@ -1459,7 +1494,7 @@ bool CG1500_application::calcola(int g, int c, long s)
sezione = rmov.get_char(RMV_SEZIONE);
importo = rmov.get_real(RMV_IMPORTO);
if (_annoes == 0)
data_reg = data;
else data_reg = datacomp;
@ -1480,7 +1515,7 @@ bool CG1500_application::calcola(int g, int c, long s)
_u_max = fnc_max(_u_max, data);
}
*/
// Modifica del 03-03-95
// Modifica del 03-03-95
if ( data_reg >= _datada && data_reg <= _dataa)
if ((cau.apertura() && _dataini != _datada) ||
@ -1503,7 +1538,7 @@ bool CG1500_application::calcola(int g, int c, long s)
_saldo_ini_dare += importo;
else _saldo_ini_avere += importo;
_u_max = fnc_max(_u_max, data);
conto_mov = TRUE;
conto_mov = TRUE;
}
}
else if (_datada > _dataini) //calcolo i progressivi precedenti
@ -1519,7 +1554,7 @@ bool CG1500_application::calcola(int g, int c, long s)
return conto_mov;
}
bool CG1500_application::ricerca_cf(int g,int c,char tipocf,real& saldo_finale,real& saldo_iniziale,
bool CG1500_application::ricerca_cf(int g,int c,char tipocf,int ib, real& saldo_finale,real& saldo_iniziale,
real& mov_conto_dare,real& mov_conto_avere,real& prg_conto_dare,real& prg_conto_avere,real& saldo_conto)
{
TSaldo sld;
@ -1551,6 +1586,16 @@ bool CG1500_application::ricerca_cf(int g,int c,char tipocf,real& saldo_finale,r
saldo_iniziale = _saldo_ini_dare - _saldo_ini_avere;
_nuovo_tot_saldo_d += _mov_periodo_dare;
_nuovo_tot_saldo_a += _mov_periodo_avere;
if (saldo_iniziale > ZERO)
_nuovo_tot_saldo_d += saldo_iniziale;
else
{
real app = -saldo_iniziale;
_nuovo_tot_saldo_a += app;
}
if (_datada == _dataini)
saldo_finale = saldo_iniziale+_mov_periodo_dare-_mov_periodo_avere;
else if (_datada > _dataini)
@ -1564,12 +1609,34 @@ bool CG1500_application::ricerca_cf(int g,int c,char tipocf,real& saldo_finale,r
}
else
{
if (!sld.ultima_immissione_verifica(_annoes,g,c,s,_indbil))
if (_stampav == 1 || _stampav == 3)
continue;
//Attenzione! Nel caso di "tutti i conti" devono scendere solo i cli/for movimentati!!!
//modifica del 31/03/1995
bool movimentato = sld.ultima_immissione_verifica(_annoes,g,c,s,_indbil);
saldo_iniziale = sld.saldoini();
if (!movimentato)
{
if (_stampav == 1)
continue;
//vado sui saldi con l'anno precedente e calcolo saldo_iniziale
//se esiste tale record e almeno un valore e' significativo (indipendentemente dal valore
//del saldo iniziale calcolato, allora metto a TRUE il flag movimentato
//solo se e' un conto patrimoniale
if (ib == 1 || ib == 2 || ib == 5)
{
saldo_iniziale = sld.saldofin_esprec(_annoes,g,c,s);
//movimentato = sld.esiste_saldo_ep();
movimentato = sld.significativo();
}
}
if (!movimentato)
continue;
//fine modifica 31/03/1995
//saldo_iniziale = sld.saldoini();
_mov_periodo_dare = sld.prgdare();
_mov_periodo_avere = sld.prgavere();
_prg_prec_dare = ZERO;
@ -1579,7 +1646,18 @@ bool CG1500_application::ricerca_cf(int g,int c,char tipocf,real& saldo_finale,r
if (saldo_finale == ZERO)
if (_stampav == 2)
continue;
continue;
_nuovo_tot_saldo_d += _mov_periodo_dare;
_nuovo_tot_saldo_a += _mov_periodo_avere;
real nuovo = sld.saldoinisusaldi();
if (nuovo > ZERO)
_nuovo_tot_saldo_d += nuovo;
else
{
nuovo = -nuovo;
_nuovo_tot_saldo_a += nuovo;
}
}
esiste_sc = TRUE;
@ -1783,6 +1861,12 @@ void CG1500_application::crea_sort_clifo()
init_sort();
int anno;
if (_tipo_stampa1 == 1)
anno = _annoapp;
else anno = _annoes;
*_cur = 0l;
for (int i = 0; i < items; i++,++(*_cur))
@ -1813,13 +1897,31 @@ void CG1500_application::crea_sort_clifo()
int g = ((TToken_string&)gccf[i]).get_int(0);
int c = ((TToken_string&)gccf[i]).get_int(1);
int aprec = EsePre(anno);
saldi.zero();
saldi.put(SLD_ANNOES, _annoes);
saldi.put(SLD_ANNOES, anno);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_SOTTOCONTO, codcf);
if (saldi.read() != NOERR) continue;
if (saldi.read() != NOERR)
if (_tipo_stampa1 == 1) //bilancio per data limite
continue;
else if (_stampac == 2) //se sono richiesti i conti movimentati
{ //esco, se no...
_indbil = cerca_indbil(g,c);
if (_indbil == 1 || _indbil == 2 || _indbil == 5)
{
saldi.zero();
saldi.put(SLD_ANNOES, aprec);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_SOTTOCONTO, codcf);
if (saldi.read() != NOERR)
continue;
}
}
if ( (((_cp != -1) && (c != _cp)) || ((_gp != -1) && (g != _gp))) &&
esiste_sc )
@ -1873,10 +1975,18 @@ void CG1500_application::crea_sort_clifo()
//if (!sld.ultima_immissione_bilancio(_annoes,g,c,codcf,_indbil))
// if (_stampac == 1)
// continue;
movimentato = sld.ultima_immissione_verifica(_annoes,g,c,codcf,_indbil);
movimentato = sld.ultima_immissione_verifica(anno,g,c,codcf,_indbil);
if (!movimentato && _stampac!=1)
if (_indbil == 1 || _indbil == 2 || _indbil == 5)
saldo_iniziale = sld.saldofin_esprec(anno,g,c,codcf);
if (movimentato)
saldo_iniziale = sld.saldoini();
if (movimentato || _stampac != 1)
{
saldo_iniziale = sld.saldoini();
//saldo_iniziale = sld.saldoini();
_mov_periodo_dare = sld.prgdare();
_mov_periodo_avere = sld.prgavere();
@ -1893,7 +2003,7 @@ void CG1500_application::crea_sort_clifo()
if (!(saldo_finale == ZERO && _stampac == 2))
{
esiste_sc = TRUE;
if (saldo_iniziale < ZERO)
_saldo_ini_conto_avere += saldo_iniziale;
else
@ -2602,6 +2712,10 @@ void CG1500_application::stampa_riga_totali(int r)
_saldo_avere_tot = -r;
_saldo_dare_tot = ZERO;
}
/*
if (_tipo_stampa1 == 1)
_nuovo_tot_saldo_a = -_nuovo_tot_saldo_a;
*/
}
if (_stampa_width == 148)
{
@ -2626,16 +2740,25 @@ void CG1500_application::stampa_riga_totali(int r)
else
{
if (_stampa_width == 132)
set_row(r,"****** ********@18gTOTALE GENERALE@49g!@50g%r@67g%r@82g!@83g%r@99g%r@114g!@115g%r %c",&_saldo_dare_tot,&_saldo_avere_tot,
{
set_row(r++,"@1g****** ********@18gTOTALE GENERALE@49g!@50g%r@67g%r@82g!@83g%r@99g%r@114g!@115g%r %c",&_saldo_dare_tot,&_saldo_avere_tot,
&_mov_dare_tot,&_mov_avere_tot,&_saldo_finale_tot,app);
else if (app == 'D')
set_row(r,"****** ********@18gTOTALE GENERALE@49g!@50g%r@67g%r@82g!@83g%r@100g%r@115g!@116g%r@148g!",&_saldo_dare_tot,
&_saldo_avere_tot,&_mov_dare_tot,&_mov_avere_tot,
&_saldo_finale_tot);
else
set_row(r,"****** ********@18gTOTALE GENERALE@49g!@50g%r@67g%r@82g!@83g%r@100g%r@115g!@132g%r@148g!",&_saldo_dare_tot,
&_saldo_avere_tot,&_mov_dare_tot,&_mov_avere_tot,
&_saldo_finale_tot);
if ((_tipo_stampa1 == 1 && _datada == _dataini) || _tipo_stampa1 == 2)
set_row(r,"@1g****** ********@18gTOTALE CON SALDI INIZIALI@49g!@82g!@83g%r@99g%r@114g!",&_nuovo_tot_saldo_d,&_nuovo_tot_saldo_a);
}
else
{
if (app == 'D')
set_row(r++,"@1g****** ********@18gTOTALE GENERALE@49g!@50g%r@67g%r@82g!@83g%r@100g%r@115g!@116g%r@148g!",&_saldo_dare_tot,
&_saldo_avere_tot,&_mov_dare_tot,&_mov_avere_tot,
&_saldo_finale_tot);
else
set_row(r++,"@1g****** ********@18gTOTALE GENERALE@49g!@50g%r@67g%r@82g!@83g%r@100g%r@115g!@132g%r@148g!",&_saldo_dare_tot,
&_saldo_avere_tot,&_mov_dare_tot,&_mov_avere_tot,
&_saldo_finale_tot);
if ((_tipo_stampa1 == 1 && _datada == _dataini) || _tipo_stampa1 == 2)
set_row(r,"@1g****** ********@18gTOTALE CON SALDI INIZIALI@49g!@82g!@83g%r@100g%r@115g!@148g!",&_nuovo_tot_saldo_d,&_nuovo_tot_saldo_a);
}
}
}
@ -3006,96 +3129,98 @@ bool CG1500_application::set_print(int)
{
TMask m ("cg1500a");
KEY tasto;
{
TConfig conf(CONFIG_DITTA);
/*
{
TConfig conf(CONFIG_DITTA);
_causale_ap = conf.get("CoCaAp");
_causale_chi = conf.get("CoCaCh");
}
_causale_ap = conf.get("CoCaAp");
_causale_chi = conf.get("CoCaCh");
}
*/
m.set_handler (F_VERIFICA, my_handler);
m.set_handler (F_BILANCIO, mask_bilancio);
m.set_handler (F_STAMPA1, mask_bilancio);
m.set_handler (F_STAMPA, mask_bilancio);
m.set_handler (F_DATALIM, mask_datalim);
m.set_handler (F_DATADA, mask_date);
m.set_handler (F_DATAA, mask_date);
m.set_handler (F_ANNO, mask_anno);
m.set_handler (F_VERIFICA, my_handler);
m.set_handler (F_BILANCIO, mask_bilancio);
m.set_handler (F_STAMPA1, mask_bilancio);
m.set_handler (F_STAMPA, mask_bilancio);
m.set_handler (F_DATALIM, mask_datalim);
m.set_handler (F_DATADA, mask_date);
m.set_handler (F_DATAA, mask_date);
m.set_handler (F_ANNO, mask_anno);
tasto = m.run();
if (tasto == K_ENTER)
{
_annoes = atoi(m.get(F_ANNO));
_bilancio = atoi(m.get(F_BILANCIO));
_data = m.get(F_DATASTAMPA);
if (_bilancio == 1)
tasto = m.run();
if (tasto == K_ENTER)
{
_prog = new TProgind(_pcn->items(),"Elaborazione in corso... prego attendere",FALSE);
_totali = (bool)(m.get(F_TOTALI) == "X");
_codici = (bool)(m.get(F_CODICI) == "X");
_saldo = (bool)(m.get(F_SALDO) == "X");
_tipo_stampa = atoi(m.get(F_STAMPA));
if (_tipo_stampa == 1)
_annoes = atoi(m.get(F_ANNO));
_bilancio = atoi(m.get(F_BILANCIO));
_data = m.get(F_DATASTAMPA);
if (_bilancio == 1)
{
if (_annoes != 0)
_dataini = InizioEsercizio(_annoes);
else _dataini = _inizioEs;
_datalim = m.get(F_DATALIM);
_stampa_mov_prov = (bool)(m.get(F_STAMPAMPROV) == "X");
}
bil_sez_contr();
}
else
{
_stampa_width = atoi(m.get(F_MODULO));
if (_stampa_width == 1)
_stampa_width = 132;
else _stampa_width = 148; //perche' questo e' in realta' il margine dx (vedi es. di stampa AS/400)
_verifica = atoi(m.get(F_VERIFICA));
if ( (_verifica == 1)||(_verifica == 2) )
_prog = new TProgind(_pcn->items(),"Elaborazione in corso... prego attendere",FALSE);
_tipo_stampa1 = atoi(m.get(F_STAMPA1));
if (_tipo_stampa1 == 1)
{
if (_annoes != 0)
_dataini = InizioEsercizio(_annoes);
else _dataini = _inizioEs;
_datada = m.get(F_DATADA);
_dataa = m.get(F_DATAA);
_stampa_mov_prov = (bool)(m.get(F_STAMPAMPROV) == "X");
_totali = (bool)(m.get(F_TOTALI) == "X");
_codici = (bool)(m.get(F_CODICI) == "X");
_saldo = (bool)(m.get(F_SALDO) == "X");
_tipo_stampa = atoi(m.get(F_STAMPA));
if (_tipo_stampa == 1)
{
if (_annoes != 0)
_dataini = InizioEsercizio(_annoes);
else _dataini = _inizioEs;
_datalim = m.get(F_DATALIM);
_stampa_mov_prov = (bool)(m.get(F_STAMPAMPROV) == "X");
}
bil_sez_contr();
}
if ( (_verifica == 1)||(_verifica == 2) )
else
{
_stampav = atoi(m.get(F_STAMPAV));
bil_verifica();
}
else
{
_situazione = m.get(F_SITUAZIONE);
_stampac = atoi(m.get(F_STAMPAC));
_ordinamento = atoi(m.get(F_ORDINAMENTO));
// _cur->setkey(3);
if (_situazione.not_empty())
_cur->setfilter(format("TIPOCF = \"%s\"",(const char*)_situazione));
else
_cur->setfilter("");
_stampa_width = atoi(m.get(F_MODULO));
if (_stampa_width == 1)
_stampa_width = 132;
else _stampa_width = 148; //perche' questo e' in realta' il margine dx (vedi es. di stampa AS/400)
_verifica = atoi(m.get(F_VERIFICA));
if ( (_verifica == 1)||(_verifica == 2) )
_prog = new TProgind(_pcn->items(),"Elaborazione in corso... prego attendere",FALSE);
_tipo_stampa1 = atoi(m.get(F_STAMPA1));
if (_tipo_stampa1 == 1)
{
if (_annoes != 0)
_dataini = InizioEsercizio(_annoes);
else _dataini = _inizioEs;
_datada = m.get(F_DATADA);
_dataa = m.get(F_DATAA);
_stampa_mov_prov = (bool)(m.get(F_STAMPAMPROV) == "X");
}
if ( (_verifica == 1)||(_verifica == 2) )
{
_stampav = atoi(m.get(F_STAMPAV));
bil_verifica();
}
else
{
_situazione = m.get(F_SITUAZIONE);
_stampac = atoi(m.get(F_STAMPAC));
_ordinamento = atoi(m.get(F_ORDINAMENTO));
// _cur->setkey(3);
if (_situazione.not_empty())
_cur->setfilter(format("TIPOCF = \"%s\"",(const char*)_situazione));
else
_cur->setfilter("");
_prog = new TProgind(_cur->items(),"Elaborazione in corso... prego attendere",FALSE);
_clienti.destroy();
_fornitori.destroy();
leggi_pcon();
crea_sort_clifo();
_sort->endsort();
delete _cf;
_prog = new TProgind(_cur->items(),"Elaborazione in corso... prego attendere",FALSE);
_clienti.destroy();
_fornitori.destroy();
leggi_pcon();
crea_sort_clifo();
_sort->endsort();
delete _cf;
}
}
delete _prog;
return TRUE;
}
delete _prog;
return TRUE;
}
return FALSE;
return FALSE;
}
TRectype& look_com (const char * cod, TLocalisamfile *comuni)

241
cg/cg1600.cpp

@ -271,7 +271,7 @@ class CG1600_application : public TPrintapp
TSaldi_list* _listasld;
TProgind* _prog;
TParagraph_string* _descr;
TSaldo* _sld;
TSaldo* _sld;
TDate _data_fine_ese,_data_fine_ese_prec,_data_fine_raf,_data_fine_raf_prec;
TDate _datastampa,_datalimite,_databilrafr,_datai,_datairaf;
@ -305,10 +305,11 @@ class CG1600_application : public TPrintapp
real _totale_parziale,_totale_parziale_raf;
real _tot_parz_sld,_tot_parz_sld_d,_tot_parz_sld_a,_tot_parz_prg_d;
real _tot_parz_prg_a,_tot_parz_mov_d,_tot_parz_mov_a;
real _nuovo_tot_saldo_d, _nuovo_tot_saldo_a;
int _i;
bool _reset_righe_stampa,_totale_attivita_gia_stampato,_totale_passivita_gia_stampato,_statopatr_no_stamp;
bool _sbilancio_ordine;
TString _causale_ap, _causale_chi;
//TString _causale_ap, _causale_chi;
public:
@ -355,8 +356,8 @@ public:
bool calcola(int,int,long,const TDate&,const TDate&);
bool sottoc_clifo_scalare (int,int,int,int,real&,real&);
void sottoc_clifo_verifica(int,int,int,char,TString&,TString&,TString&,int,int,bool);
const char* causale_apertura() { return _causale_ap;}
const char* causale_chiusura() { return _causale_chi;}
//const char* causale_apertura() { return _causale_ap;}
//const char* causale_chiusura() { return _causale_chi;}
void stampa_saldo_132(const real&);
void stampa_saldo_198(real&, real&);
void set_bil_key(bil_ivd* b, char sezione, char lettera,
@ -749,7 +750,7 @@ bool tipo_stampa(TMask_field& f,KEY k)
if (tipo_stampa == 2)
if (anno == 0)
{
error_box("Nella stampa all' ultima immissione l' anno esercizio e' obbligatorio");
error_box("Nella stampa all' ultima immissione l' anno esercizio e' obbligatorio");
return FALSE;
}
@ -765,7 +766,7 @@ bool data_inizio(TMask_field& f, KEY k)
anno = f.mask().get_int(F_ANNOESE);
data = f.mask().get (F_DATAINI);
a()._anno_esercizio = anno;
//a()._anno_esercizio = anno;
if (k == K_ENTER)
{
@ -777,7 +778,7 @@ bool data_inizio(TMask_field& f, KEY k)
a()._anno_esercizio = anno;
if (data == botime)
a()._dataini = in;
a()._dataini = in;
else
if (data < in || data > fin)
{
@ -801,12 +802,14 @@ bool data_inizio(TMask_field& f, KEY k)
if (anno == 0)
{
f.error_box("La data limite indicata non appartiene ad alcun esercizio attivo della ditta");
return FALSE;
}
return FALSE;
}
a()._anno_esercizio = anno;
a()._anno_esercizio = anno;
a()._dataini = data;
}
a()._data_ini_ese = a()._inizioEs;
a()._data_fine_ese = a()._fineEs;
}
}
TString datastr = a()._dataini.string();
TString data1 = a()._data_ini_ese.string();
@ -823,7 +826,7 @@ bool data_fine(TMask_field& f, KEY k)
annoes = f.mask().get_int(F_ANNOESE);
data = f.mask().get (F_DATAFINE);
data_ini = f.mask().get (F_DATAINI);
a()._anno_esercizio = annoes;
//a()._anno_esercizio = annoes;
if (k == K_ENTER)
{
@ -1077,7 +1080,7 @@ void CG1600_application::crea_sort_piano_conti_scalare()
//analizzato, e se questi contiene la classe IV dir. CEE,
//allore devo controllare se va dettagliato (STSOTTBIL)
if (sez != "0")
if (sez != "0" && sez != "")
{
if (!stsottbil || tmcf == 'C' || tmcf == 'F')
conto_dettagliato = FALSE;
@ -1310,7 +1313,7 @@ void CG1600_application::crea_sort_piano_conti_scalare()
}
}
else
if (sez != "0")
if (sez != "0" && sez != "")
{
if (sez == "2")
{
@ -1323,7 +1326,7 @@ void CG1600_application::crea_sort_piano_conti_scalare()
}
}
else
if (sez != "0")
if (sez != "0" && sez != "")
{
if (sez == "2")
{
@ -1398,7 +1401,9 @@ void CG1600_application::crea_sort_piano_conti_verifica()
sld_prg_avere_conto = ZERO;
mov_dare_conto = ZERO;
mov_avere_conto = ZERO;
_nuovo_tot_saldo_d = ZERO;
_nuovo_tot_saldo_a = ZERO;
indbil = 0;
gruppo_prec = -1;
conto_prec = -1;
@ -1465,7 +1470,7 @@ void CG1600_application::crea_sort_piano_conti_verifica()
//analizzato , se contiene la classe IV dir. CEE
//allora devo controllare se va dettagliato (STSOTTBIL)
if (sez != "0")
if (sez != "0" && sez != "")
{
if ((tmcf == 'C') || (tmcf == 'F'))
{
@ -1517,7 +1522,20 @@ void CG1600_application::crea_sort_piano_conti_verifica()
sld_prg_avere = _saldo_ini_avere;
mov_dare = _mov_periodo_dare;
mov_avere = _mov_periodo_avere;
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
//modifica del 05/04/1995
real app = sld_prg_dare - sld_prg_avere;
_nuovo_tot_saldo_d += mov_dare;
_nuovo_tot_saldo_a += mov_avere;
if (app > ZERO)
_nuovo_tot_saldo_d += app;
else
{
app = -app;
_nuovo_tot_saldo_a += app;
}
//fine modifica
}
else if (_dataini > _data_ini_ese)
{
@ -1532,8 +1550,14 @@ void CG1600_application::crea_sort_piano_conti_verifica()
if (_tipo_stampa == 2)
{
if (!_sld->ultima_immissione_verifica(_anno_esercizio,g,c,s,indbil))
continue;
app = _sld->saldoini();
// continue;
//modifica del 05/04/1995
{
if (indbil == 1 || indbil == 2 || indbil == 5)
app = _sld->saldofin_esprec(_anno_esercizio,g,c,s);
}
else app = _sld->saldoini();
//fine modifica
if (app < ZERO)
{
app = -app;
@ -1547,7 +1571,23 @@ void CG1600_application::crea_sort_piano_conti_verifica()
}
mov_dare = _sld->prgdare();
mov_avere = _sld->prgavere();
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
//modifica del 05/04/1995
if (!(saldo == ZERO && _stampamov))
{
_nuovo_tot_saldo_d += mov_dare;
_nuovo_tot_saldo_a += mov_avere;
real nuovo = _sld->saldoinisusaldi();
if (nuovo > ZERO)
_nuovo_tot_saldo_d += nuovo;
else
{
nuovo = -nuovo;
_nuovo_tot_saldo_a += nuovo;
}
}
//fine modifica
}
if (classe_conto)
@ -1563,7 +1603,7 @@ void CG1600_application::crea_sort_piano_conti_verifica()
}
else
{
if (sez != "0")
if (sez != "0" && sez != "")
scrivi_record(sez,let,numerorom,numero,g,c,s,saldo,ZERO,sld_prg_dare,sld_prg_avere,mov_dare,mov_avere,tmcf);
}
}
@ -1602,7 +1642,7 @@ void CG1600_application::sottoc_clifo_verifica(int g,int c,int anno,char tipocf,
sld_prg_avere_conto = ZERO;
mov_dare_conto = ZERO;
mov_avere_conto = ZERO;
int items = _listasld->items();
sez_conto = sez;
@ -1646,6 +1686,19 @@ void CG1600_application::sottoc_clifo_verifica(int g,int c,int anno,char tipocf,
mov_dare = _mov_periodo_dare;
mov_avere = _mov_periodo_avere;
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
//modifica 05/04/1994
real app = sld_prg_dare - sld_prg_avere;
_nuovo_tot_saldo_d += mov_dare;
_nuovo_tot_saldo_a += mov_avere;
if (app > ZERO)
_nuovo_tot_saldo_d += app;
else
{
app = -app;
_nuovo_tot_saldo_a += app;
}
//fine modifica
}
else if (_dataini > _data_ini_ese)
{
@ -1659,9 +1712,18 @@ void CG1600_application::sottoc_clifo_verifica(int g,int c,int anno,char tipocf,
else
if (_tipo_stampa == 2)
{
/*
if (!_sld->ultima_immissione_bilancio(_anno_esercizio,g,c,s,indbil))
continue;
app = _sld->saldoini();
*/
//modifica 05/04/1994
if (!_sld->ultima_immissione_verifica(_anno_esercizio,g,c,s,indbil))
{
if (indbil == 1 || indbil == 2 || indbil == 5)
app = _sld->saldofin_esprec(_anno_esercizio,g,c,s);
}
else app = _sld->saldoini();
//fine modifica
if (app < ZERO)
{
app = -app;
@ -1675,7 +1737,23 @@ void CG1600_application::sottoc_clifo_verifica(int g,int c,int anno,char tipocf,
}
mov_dare = _sld->prgdare();
mov_avere = _sld->prgavere();
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
saldo = sld_prg_dare-sld_prg_avere+mov_dare-mov_avere;
//modifica 05/04/1994
if (!(saldo == ZERO && _stampamov))
{
_nuovo_tot_saldo_d += mov_dare;
_nuovo_tot_saldo_a += mov_avere;
real nuovo = _sld->saldoinisusaldi();
if (nuovo > ZERO)
_nuovo_tot_saldo_d += nuovo;
else
{
nuovo = -nuovo;
_nuovo_tot_saldo_a += nuovo;
}
}
//fine modifica
}
if (stsottbil)
@ -1979,13 +2057,14 @@ bool CG1600_application::calcola(int g, int c, long s,
bool CG1600_application::set_print(int)
{
KEY tasto;
/*
{
TConfig conf(CONFIG_DITTA);
_causale_ap = conf.get("CoCaAp");
_causale_chi = conf.get("CoCaCh");
}
*/
_msk->set_handler(F_DATALIM, data_limite);
_msk->set_handler(F_TIPOSTAMPA, tipo_stampa);
@ -3857,7 +3936,7 @@ bool CG1600_application::preprocess_stampa_verifica(int counter)
set_row (_i,"@65g%r", &_tot_gen_prg_a);
set_row (_i,"@82g%r", &_tot_gen_mov_d);
set_row (_i,"@98g%r", &_tot_gen_mov_a);
if (!_stampa_modulo)
{
if (_tot_gen_saldo < ZERO)
@ -3872,6 +3951,11 @@ bool CG1600_application::preprocess_stampa_verifica(int counter)
else
stampa_saldo_198(_tot_gen_saldo_d,_tot_gen_saldo_a);
//modifica 05/04/1995
if ((_tipo_stampa == 1 && _dataini == _data_ini_ese) || _tipo_stampa == 2)
set_row(_i,"@0g****** ******** TOTALE CON SALDI INIZIALI@48g!@81g!@82g%r@98g%r@114g!",&_nuovo_tot_saldo_d,&_nuovo_tot_saldo_a);
//fine modifica
_sez_da_stamp = ' ';
_sez_stamp = ' ';
return TRUE;
@ -4010,14 +4094,55 @@ bool CG1600_application::preprocess_stampa_verifica(int counter)
}
}
_tot_num_prg_d += _sld_prg_dare;
_tot_numr_prg_d += _sld_prg_dare;
_tot_let_prg_d += _sld_prg_dare;
_tot_gen_prg_d += _sld_prg_dare;
_tot_num_prg_a += _sld_prg_avere;
_tot_numr_prg_a += _sld_prg_avere;
_tot_let_prg_a += _sld_prg_avere;
_tot_gen_prg_a += _sld_prg_avere;
if (_dataini == _data_ini_ese)
{
real saldo_num = _sld_prg_dare - _sld_prg_avere;
if (saldo_num > ZERO)
_tot_num_prg_d += saldo_num;
else
{
saldo_num = -saldo_num;
_tot_num_prg_a += saldo_num;
}
real saldo_numr = _sld_prg_dare - _sld_prg_avere;
if (saldo_numr > ZERO)
_tot_numr_prg_d += saldo_numr;
else
{
saldo_numr = -saldo_numr;
_tot_numr_prg_a += saldo_numr;
}
real saldo_let = _sld_prg_dare - _sld_prg_avere;
if (saldo_let > ZERO)
_tot_let_prg_d += saldo_let;
else
{
saldo_let = -saldo_let;
_tot_let_prg_a += saldo_let;
}
real saldo_gen = _sld_prg_dare - _sld_prg_avere;
if (saldo_gen > ZERO)
_tot_gen_prg_d += saldo_gen;
else
{
saldo_gen = -saldo_gen;
_tot_gen_prg_a += saldo_gen;
}
}
else
{
_tot_num_prg_d += _sld_prg_dare;
_tot_numr_prg_d += _sld_prg_dare;
_tot_let_prg_d += _sld_prg_dare;
_tot_gen_prg_d += _sld_prg_dare;
_tot_num_prg_a += _sld_prg_avere;
_tot_numr_prg_a += _sld_prg_avere;
_tot_let_prg_a += _sld_prg_avere;
_tot_gen_prg_a += _sld_prg_avere;
}
_tot_num_mov_d += _mov_dare;
_tot_numr_mov_d += _mov_dare;
_tot_let_mov_d += _mov_dare;
@ -4515,9 +4640,26 @@ void CG1600_application::setta_righe_verifica()
set_row (_i,"@0g%s", bil->gruppo);
set_row (_i,"@4g%s", bil->conto);
set_row (_i,"@8g%s", bil->sottoc);
set_row (_i,"@15g%s", (const char*) descr_sottoc);
set_row (_i,"@49g%r", &_sld_prg_dare);
set_row (_i,"@65g%r", &_sld_prg_avere);
set_row (_i,"@15g%-.33s", (const char*) descr_sottoc);
if (_dataini == _data_ini_ese)
{
real saldoini = _sld_prg_dare - _sld_prg_avere;
if (saldoini >= ZERO)
set_row(_i,"@49g%r", &saldoini);
else
{
saldoini = -saldoini;
set_row(_i,"@65g%r", &saldoini);
}
}
else
{
set_row (_i,"@49g%r", &_sld_prg_dare);
set_row (_i,"@65g%r", &_sld_prg_avere);
}
set_row (_i,"@82g%r", &_mov_dare);
set_row (_i,"@98g%r", &_mov_avere);
if (_stampa_modulo)
@ -4558,8 +4700,25 @@ void CG1600_application::setta_righe_verifica()
if (descr_classe != descr_sottoc)
{
set_row (_i,"@2g%s", (const char*) descr_sottoc);
set_row (_i,"@49g%r", &_sld_prg_dare);
set_row (_i,"@66g%r", &_sld_prg_avere);
if (_dataini == _data_ini_ese)
{
real saldoini = _sld_prg_dare - _sld_prg_avere;
if (saldoini >= ZERO)
set_row(_i,"@49g%r", &saldoini);
else
{
saldoini = -saldoini;
set_row(_i,"@65g%r", &saldoini);
}
}
else
{
set_row (_i,"@49g%r", &_sld_prg_dare);
set_row (_i,"@65g%r", &_sld_prg_avere);
}
set_row (_i,"@82g%r", &_mov_dare);
set_row (_i,"@99g%r", &_mov_avere);
if (_stampa_modulo)
@ -4883,7 +5042,7 @@ void CG1600_application::intesta_scalare()
{
set_header (3,"@115gEsercizio@125g%d", _anno_esercizio_raf);
databilrafrstr = _databilrafr.string();
set_header (4,"@112galla data@122g%s", (const char*) databilrafrstr);
set_header (4,"@113galla data@122g%s", (const char*) databilrafrstr);
}
if (_tipo_stampa == 1)
{

4
cg/cg3100a.uml

@ -119,7 +119,7 @@ BEGIN
DISPLAY "Documento" NUMDOC
DISPLAY "Descrizione@50" DESCR
OUTPUT F_NUMEROINI NUMREG
CHECKTYPE NORMAL
//CHECKTYPE NORMAL
FLAGS "R"
GROUP 2
END
@ -132,7 +132,7 @@ BEGIN
INPUT NUMREG F_NUMEROFIN
COPY DISPLAY F_NUMEROINI
OUTPUT F_NUMEROFIN NUMREG
CHECKTYPE NORMAL
//CHECKTYPE NORMAL
FLAGS "R"
NUM_EXPR {(#F_NUMEROFIN==0)||(#F_NUMEROFIN>=#F_NUMEROINI)}
WARNING "Limite superiore errato"

10
cg/cglib.h

@ -6,8 +6,8 @@
#endif
#include <assoc.h>
#include "../cg/conto.h"
#include "../cg/cg2103.h" // per TCausale
#include "conto.h"
#include "cg2103.h" // per TCausale
class TCaus : public TCausale
@ -32,10 +32,11 @@ public:
};
enum tipobil { DataLimite=1, UltimaImmissione };
const int EsePre(const int EseCorr);
class TSaldo
{
real _saldo, _saldo_iniziale;
real _saldo, _saldo_iniziale, _saldoiniziale;
real _prg_dare, _prg_avere, _prg_daresca, _prg_averesca;
int _indbil;
TRectype _saldo_ep;
@ -61,8 +62,8 @@ public:
bool movimentato() const { return _movimentato; }
bool significativo() const { return _significativo; }
bool esiste_saldo() const { return _rec_presente_ec || _rec_presente_ep;}
bool esiste_saldo_ep() const { return _rec_presente_ep; }
const int EsePre (const int annocorr); // Determina esercizio precedente
int annoes () const { return _annoes; }
void set_annoes (int anno) { _annoes = anno; }
@ -82,6 +83,7 @@ public:
const real& saldo() const { return _saldo;}
const real& saldoini() const { return _saldo_iniziale;}
const real& saldoinisusaldi() const { return _saldoiniziale;}
const real& prgdare() const { return _prg_dare;}
const real& prgavere() const { return _prg_avere;}
bool prg_attuali(int,TConto&,int,real&,real&);

310
cg/cglib01.cpp

@ -23,7 +23,8 @@
TCaus::TCaus(const char* cod)
: _rec(LF_CAUSALI)
{
if (*cod) read(cod);
//if (*cod) read(cod);
read(cod);
}
@ -52,24 +53,51 @@ bool TCaus::chiusura() const
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)
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);
}
// 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());
@ -84,16 +112,15 @@ TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep)
if (g != gr || c != co) break;
if (aep)
{
if (ae != aec && ae != aep) continue;
}
// 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)
if (aep_par)
force = FALSE;
else
force = TRUE;
@ -114,6 +141,7 @@ TRectype* TSaldi_list::saldi() const
TSaldo::TSaldo() : _saldo_ep(LF_SALDI)
{
_saldo_iniziale = ZERO;
_saldoiniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_saldo = ZERO;
@ -126,32 +154,15 @@ TSaldo::TSaldo() : _saldo_ep(LF_SALDI)
TSaldo::~TSaldo()
{}
//
// Cerca l'esercizio precedente di EseCorr
// Se EseCorr e' gia' il primo ritorna 0
// senno' ritorna, astutamente, EseCorr - 1
//
const int TSaldo::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;
}
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
{
const int annoesprec = EsePre(annoes);
if (annoesprec == 0) return ZERO; // non ci sono esercizi prima del primo
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);
@ -161,11 +172,16 @@ real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
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);
real tot = pdare-pavere+pdaresca-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
@ -206,7 +222,11 @@ real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
_significativo = (saldoini != ZERO || pdaresca != ZERO || paveresca != ZERO);
if (saldoini != ZERO)
if (flag == 'A') saldoini = -saldoini;
if (flag == 'A')
{
saldoini = -saldoini;
flag = 'D';
}
if (saldoini == ZERO)
if ( indbil == 1 || indbil == 2 || indbil == 5 )
@ -255,90 +275,7 @@ void TSaldo::leggi_mov(long nr)
}
}
/********************************************
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 = ZERO;
int gruppo, conto, annoe;
long sottoconto, num_reg;
TLocalisamfile rmov(LF_RMOV, FALSE);
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;
}
***************************************************/
//per bilancio scalare 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, bool stp_prov)
{
@ -445,70 +382,8 @@ bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDat
return _movimentato;
}
/**************************************************************
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
char sezione;
int gruppo, conto, annoe;
long sottoconto;
TLocalisamfile saldi(LF_SALDI, FALSE);
bool esito = TRUE;
_saldo_iniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_saldo = ZERO;
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_iniziale = saldi.get_real(SLD_SALDO);
_prg_dare = saldi.get_real(SLD_PDARE);
_prg_avere = saldi.get_real(SLD_PAVERE);
sezione = saldi.get_char(SLD_FLAGSALINI);
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
if (annoesprec == 0) //all'ultima immissione es.in corso
{
if (indbil == 1 || indbil == 2 || indbil == 5)
if (_saldo_iniziale == ZERO)
_saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);
// 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
{
const int annoesprec = EsePre(annoes);
if (annoesprec != 0)
{
TRectype app = ricerca_progr_prec(annoe-1, gruppo, conto, sottoconto);
annoe = app.get_int (SLD_ANNOES);
_prg_dare = app.get_real(SLD_PDARE);
_prg_avere = app.get_real(SLD_PAVERE);
}
_saldo = _prg_dare - _prg_avere;
}
}
return esito;
}
*****************************************************/
//per bilancio di verifica all'ultima immissione
bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil)
{
//Si considerano i saldi e non piu' i movimenti
@ -518,7 +393,8 @@ bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil
bool esito = FALSE;
TLocalisamfile saldi(LF_SALDI, FALSE);
_saldo_iniziale = ZERO;
_saldo_iniziale = ZERO;
_saldoiniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_prg_daresca = ZERO;
@ -548,17 +424,19 @@ bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
_saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi
//non comprensivo del saldo finale es.precedente
if (indbil == 1 || indbil == 2 || indbil == 5)
if (_saldo_iniziale == ZERO)
_saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);
esito = TRUE;
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
}
return esito;
}
//per bilancio scalare all'ultima immissione
bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil)
{
//Si considerano i saldi e non piu' i movimenti
@ -593,12 +471,16 @@ bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil
_saldo_iniziale = saldi.get_real(SLD_SALDO);
_prg_dare = saldi.get_real(SLD_PDARE);
_prg_avere = saldi.get_real(SLD_PAVERE);
_prg_daresca = saldi.get_real(SLD_PDARESCA);
_prg_averesca = saldi.get_real(SLD_PAVERESCA);
//_prg_daresca = saldi.get_real(SLD_PDARESCA);
//_prg_averesca = saldi.get_real(SLD_PAVERESCA);
sezione = saldi.get_char(SLD_FLAGSALINI);
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
|| _prg_daresca != ZERO || _prg_averesca != ZERO);
/*
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
|| _prg_daresca != ZERO || _prg_averesca != ZERO);
*/
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO);
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
@ -609,7 +491,8 @@ bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil
if (_saldo_iniziale == ZERO)
_saldo_iniziale += saldofin_esprec(annoes,g,c,s);
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
//_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
return esito;
}
@ -617,7 +500,7 @@ bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil
TRectype& TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{
TLocalisamfile saldi(LF_SALDI, FALSE);
// TRectype rec(LF_SALDI);
const int oldkey = saldi.getkey();
saldi.setkey(1);
@ -722,35 +605,6 @@ bool TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prga
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;
}
**********************************************/