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

Modifiche da Parma:

Browse Source 
Bilanci, Lista Causali , Mastrini, Libro Giornale, Libreria di cg (occhio!!!!)
Aggiunto il; programma di Visualizzazione Saldi


git-svn-id: svn://10.65.10.50/trunk@391 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
nik 1994-10-17 13:41:53 +00:00
parent 12edd290f6
commit b3bb46aff7
12 changed files with 2329 additions and 997 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

589
cg/cg1500.cpp
View File

@ -94,7 +94,7 @@ class CG1500_application : public TPrintapp
real _saldo_dare_tot, _saldo_avere_tot, _mov_dare_tot, _mov_avere_tot;
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;
real _prg_saldoini_dare, _prg_saldoini_avere, _prg_inidare_ord, _prg_iniavere_ord;
TDate _datalim, _data, _datada, _dataa, _dataini, _ultima_data, _u_max;
bool _cambiato_conto_1, _cambiato_conto_2, _add_file_avere;
@ -113,6 +113,7 @@ public:
void user_destroy();
bool set_print(int);
void next_c();
virtual bool preprocess_print(int,int);
virtual void preprocess_header();
virtual bool preprocess_page(int,int);
@ -153,7 +154,7 @@ public:
void stampa_prima_colonna(int,int,long,const char*,const real&);
void stampa_seconda_colonna(int,int,long,const char*,const real&);
void stampa_totali();
void stampa_totali_uno();
void stampa_totali_uno(const real&, const real&);
void controlla_conto(int,int);
const char* DescrizioneConto(int,int,long,char); //chiama quella di TConto
TDate UltimaData(int,int,long,int);
@ -512,90 +513,87 @@ void CG1500_application::scrivig_file_temp()
TIsamtempfile* tmp = NULL;
TString nome_campo(12);
real valore;
if (_add_dare)
if (!_totali)
{
nome_campo = SLD_PDARE;
valore = _gruppo_da;
switch (_indbil)
if (_add_dare)
{
case 1:
case 2:
tmp = _tmp_saldi_att;
break;
case 3:
case 4:
tmp = _tmp_saldi_costi;
break;
case 5:
tmp = _tmp_saldi_conti_uno;
valore = _gruppo_da_ordine;
break;
default:
break;
}
tmp->zero();
tmp->put(SLD_GRUPPO,_gp);
if (tmp->read() == NOERR)
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->rewrite();
nome_campo = SLD_PDARE;
valore = _gruppo_da;
switch (_indbil)
{
case 1:
case 2:
tmp = _tmp_saldi_att;
break;
case 3:
case 4:
tmp = _tmp_saldi_costi;
break;
case 5:
tmp = _tmp_saldi_conti_uno;
valore = _gruppo_da_ordine;
break;
default:
break;
}
tmp->zero();
tmp->put(SLD_GRUPPO,_gp);
if (tmp->read() == NOERR)
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->rewrite();
}
else
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->write();
}
}
else
if (_add_avere)
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->write();
nome_campo = SLD_PAVERE;
valore = _gruppo_a;
switch (_indbil)
{
case 1:
case 2:
tmp = _tmp_saldi_pass;
break;
case 3:
case 4:
tmp = _tmp_saldi_ricavi;
break;
case 5:
tmp = _tmp_saldi_conti_due;
valore = _gruppo_a_ordine;
break;
default:
break;
}
tmp->zero();
tmp->put(SLD_GRUPPO,_gp);
if (tmp->read() == NOERR)
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->rewrite();
}
else
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->write();
}
}
//if (_indbil == 5)
// _gruppo_da_ordine = ZERO;
}
if (_add_avere)
{
nome_campo = SLD_PAVERE;
valore = _gruppo_a;
switch (_indbil)
{
case 1:
case 2:
tmp = _tmp_saldi_pass;
break;
case 3:
case 4:
tmp = _tmp_saldi_ricavi;
break;
case 5:
tmp = _tmp_saldi_conti_due;
valore = _gruppo_a_ordine;
break;
default:
break;
}
tmp->zero();
tmp->put(SLD_GRUPPO,_gp);
if (tmp->read() == NOERR)
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->rewrite();
}
else
{
tmp->put(SLD_CONTO,0);
tmp->put(SLD_SOTTOCONTO,0L);
tmp->put(nome_campo, valore);
tmp->write();
}
//if (_indbil == 5)
// _gruppo_a_ordine = ZERO;
}
_add_dare = _add_avere = FALSE;
}
@ -758,6 +756,18 @@ real CG1500_application::compensazione(bool compensa, int indbil_conto, real& sl
return saldo;
}
void CG1500_application::next_c()
{
TRecnotype recnum = _pcn->recno();
_pcn->next();
if (_pcn->eof())
{
scrivic_file_temp();
scrivig_file_temp();
}
_pcn->readat(recnum);
}
bool CG1500_application::bil_sez_contr()
{
Saldo sld;
@ -768,7 +778,7 @@ bool CG1500_application::bil_sez_contr()
real saldo;
bool compensa=FALSE, dettaglio=FALSE, cambiato=FALSE;
bool esiste_conto=FALSE, esiste_sc = FALSE;
bool da_considerare = FALSE;
bool movimentato = FALSE;
_tmp_saldi_att->open("cg01");
_prog->addstatus(1);
@ -790,7 +800,9 @@ bool CG1500_application::bil_sez_contr()
_gruppo_da_ordine = ZERO;
_gruppo_a_ordine = ZERO;
_prg_saldoini_dare = ZERO;
_prg_saldoini_avere = ZERO;
_prg_saldoini_avere = ZERO;
_prg_inidare_ord = ZERO;
_prg_iniavere_ord = ZERO;
_conto_a = ZERO;
_conto_da = ZERO;
_add_dare = FALSE;
@ -814,9 +826,9 @@ bool CG1500_application::bil_sez_contr()
scrivic_file_temp();
scrivig_file_temp();
_cp = c;
esiste_conto = TRUE;
_conto_da = ZERO;
_conto_a = ZERO;
esiste_conto = TRUE;
_conto_da = ZERO;
_conto_a = ZERO;
}
if ( ((_gp != -1) && (g != _gp)) && esiste_conto )
@ -878,99 +890,102 @@ bool CG1500_application::bil_sez_contr()
}
if (_tipo_stampa == 1) //bil. a sez. contrapposte per data limite
//if (!sld.data_limite_bilancio(_bilancio,g,c,s,_dataini,_datalim,indbil_conto,_stampa_mov_prov))
//continue;
//else saldo = sld.saldo();
da_considerare = sld.data_limite_bilancio(_bilancio,g,c,s,_dataini,_datalim,indbil_conto,_stampa_mov_prov);
movimentato = sld.data_limite_bilancio(_bilancio,g,c,s,_dataini,_datalim,indbil_conto,_stampa_mov_prov);
else
if (_tipo_stampa == 2) //bil. a sez. contrapposte all'ultima immissione es. in corso
//if (!sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto))
// continue;
//else
// saldo = sld.saldo();
da_considerare = sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto);
movimentato = sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto);
if (da_considerare)
if (!movimentato)
if (!sld.esiste_saldo() || !sld.significativo())
{
next_c();
continue;
}
saldo = sld.saldo();
if (_saldo) //se richiesto di NON stampare i conti con saldo a zero
if (saldo == ZERO)
{
next_c();
continue;
}
esiste_sc = TRUE;
_indbil = indbil_conto;
//i due flag seguenti servono solo per i conti d'ordine
_sottoc_dare = FALSE;
_sottoc_avere = FALSE;
//error_box ("saldo = %s", saldo.string());
if (saldo != ZERO)
saldo = compensazione(compensa, indbil_conto, saldo);
if (_indbil == 1 || _indbil == 2)
{
saldo = sld.saldo();
if (_saldo) //se richiesto di NON stampare i conti con saldo a zero
// if (saldo == ZERO && !sld.significativo())
if (saldo == ZERO)
{
TRecnotype recnum = _pcn->recno();
_pcn->next();
if (_pcn->eof())
{
scrivic_file_temp();
scrivig_file_temp();
}
_pcn->readat(recnum);
continue;
}
esiste_sc = TRUE;
_indbil = indbil_conto;
//i due flag seguenti servono solo per i conti d'ordine
_sottoc_dare = FALSE;
_sottoc_avere = FALSE;
//error_box ("saldo = %s", saldo.string());
if (saldo != ZERO)
saldo = compensazione(compensa, indbil_conto, saldo);
if (_indbil == 1 || _indbil == 2)
real app = sld.saldoini();
if (app > ZERO)
_prg_saldoini_dare += app;
else if (app < ZERO)
{
real app = sld.saldoini();
if (app > ZERO)
_prg_saldoini_dare += app;
else if (app < ZERO)
{
app = -app;
_prg_saldoini_avere += app;
}
}
if ( _indbil==1 || _indbil==3 )
{
_gruppo_da += saldo;
_conto_da += saldo;
_add_file_dare = TRUE;
app = -app;
_prg_saldoini_avere += app;
}
if ( _indbil==2 || _indbil==4 )
}
if (_indbil == 5)
{
real app = sld.saldoini();
if (app > ZERO)
_prg_inidare_ord += app;
else if (app < ZERO)
{
_gruppo_a += saldo;
_conto_a += saldo;
_add_file_avere = TRUE;
app = -app;
_prg_iniavere_ord += app;
}
if (_indbil==5)
{
if ( saldo >= ZERO || compensa )
{
_gruppo_da_ordine += saldo;
_conto_da += saldo;
_add_file_dare = TRUE;
_sottoc_dare = TRUE;
}
else
{
saldo = -saldo;
_gruppo_a_ordine += saldo;
_conto_a += saldo;
_add_file_avere = TRUE;
_sottoc_avere = TRUE;
}
scrivig_file_temp();
}
if ( (dettaglio) && ( (tipo_conto != 'C') && (tipo_conto != 'F') ) )
scrivis_file_temp(g, c, s, saldo);
_gp = g;
_cp = c;
}
if ( _indbil==1 || _indbil==3 )
{
_gruppo_da += saldo;
_conto_da += saldo;
_add_file_dare = TRUE;
}
if ( _indbil==2 || _indbil==4 )
{
_gruppo_a += saldo;
_conto_a += saldo;
_add_file_avere = TRUE;
}
if (_indbil==5)
{
if ( saldo >= ZERO || compensa )
{
_gruppo_da_ordine += saldo;
_conto_da += saldo;
_add_file_dare = TRUE;
_sottoc_dare = TRUE;
}
else
{
saldo = -saldo;
_gruppo_a_ordine += saldo;
_conto_a += saldo;
_add_file_avere = TRUE;
_sottoc_avere = TRUE;
}
scrivig_file_temp();
}
if ( (dettaglio) && ( (tipo_conto != 'C') && (tipo_conto != 'F') ) )
scrivis_file_temp(g, c, s, saldo);
_gp = g;
_cp = c;
// } // da_considerare
TRecnotype recnum = _pcn->recno();
_pcn->next();
@ -987,29 +1002,37 @@ bool CG1500_application::bil_sez_contr()
bool CG1500_application::ricerca_sottoc_clifo(int g,int c, bool compensa, int indbil_conto,real& saldo)
{
Saldo sld;
TSaldo sld;
int aep=0;
long s, items;
bool esiste_sc = FALSE;
bool movimentato = FALSE;
if (_annoes) aep = _annoes-1;
sld.set_annoes(_annoes);
_listacf = new TSaldi_list(g, c, _annoes);
long s;
TRecnotype items = _listacf->items();
bool esiste_sc = FALSE;
_listacf = new TSaldi_list(g, c, _annoes, aep);
items = _listacf->items();
for (int i = 0; i < items; i++)
{
const TRectype& r = _listacf->saldi(i);
s = r.get_long(SLD_SOTTOCONTO);
const TRectype* r = _listacf->saldi();
if (r == NULL) break;
s = r->get_long(SLD_SOTTOCONTO);
if (_tipo_stampa == 1) //bil. a sez. contrapposte per data limite
{
if (!sld.data_limite_bilancio(_bilancio,g,c,s,_dataini,_datalim,indbil_conto,_stampa_mov_prov)) continue;
else saldo = sld.saldo();
}
movimentato = sld.data_limite_bilancio(_bilancio,g,c,s,_dataini,_datalim,indbil_conto,_stampa_mov_prov);
else if (_tipo_stampa == 2) //bil. a sez. contrapposte all'ultima immissione es. in corso
{
if (!sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto)) continue;
else saldo = sld.saldo();
}
movimentato = sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto);
if (!movimentato)
if (!sld.esiste_saldo() || !sld.significativo())
continue;
saldo = sld.saldo();
if (_saldo) //se richiesto di non stampare i conti con saldo a zero
if (saldo == 0)
continue;
@ -1038,6 +1061,18 @@ bool CG1500_application::ricerca_sottoc_clifo(int g,int c, bool compensa, int in
}
}
if (_indbil == 5)
{
real app = sld.saldoini();
if (app > ZERO)
_prg_inidare_ord += app;
else if (app < ZERO)
{
app = -app;
_prg_iniavere_ord += app;
}
}
if ( (_indbil==1) || (_indbil==3) )
{
_gruppo_da += saldo;
@ -1257,7 +1292,7 @@ bool CG1500_application::bil_verifica()
//if (!sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto))
// if (_stampav == 1)
// continue;
movimentato = sld.ultima_immissione_bilancio(_annoes,g,c,s,indbil_conto);
movimentato = sld.ultima_immissione_verifica(_annoes,g,c,s,indbil_conto);
if (movimentato || _stampav != 1)
{
@ -1477,8 +1512,10 @@ bool CG1500_application::ricerca_cf(int g,int c,char tipocf,real& saldo_finale,r
for (int i = 0; i < items; i++)
{
const TRectype& r = _lista->saldi(i);
s = r.get_long(SLD_SOTTOCONTO);
const TRectype* r = _lista->saldi();
if (r == NULL) break;
s = r->get_long(SLD_SOTTOCONTO);
saldo_finale = ZERO; //saldo finale relativo a ciascun sottoconto
@ -1503,7 +1540,7 @@ bool CG1500_application::ricerca_cf(int g,int c,char tipocf,real& saldo_finale,r
}
else
{
if (!sld.ultima_immissione_bilancio(_annoes,g,c,s,_indbil))
if (!sld.ultima_immissione_verifica(_annoes,g,c,s,_indbil))
if (_stampav == 1)
continue;
@ -1802,7 +1839,7 @@ void CG1500_application::crea_sort_clifo()
//if (!sld.ultima_immissione_bilancio(_annoes,g,c,codcf,_indbil))
// if (_stampac == 1)
// continue;
movimentato = sld.ultima_immissione_bilancio(_annoes,g,c,codcf,_indbil);
movimentato = sld.ultima_immissione_verifica(_annoes,g,c,codcf,_indbil);
if (movimentato || _stampac != 1)
{
saldo_iniziale = sld.saldoini();
@ -2027,7 +2064,7 @@ bool CG1500_application::preprocess_page(int file, int counter)
{
if (_prima_volta)
{
stampa_totali_uno();
stampa_totali_uno(_prg_saldoini_dare,_prg_saldoini_avere);
_eof3 = _tmp_saldi_costi->first();
_eof4 = _tmp_saldi_ricavi->first();
}
@ -2149,8 +2186,7 @@ void CG1500_application::controlla_conto(int file1,int file2)
if (!file1)
if (_cambiato_conto_1)
{
if (!(_totali && _conto_dare==0 && _sottoconto_dare == 0l))
set_row(_i,"@66g%c", dep);
set_row(_i,"@66g%c", dep);
_cambiato_conto_1 = FALSE;
}
else
@ -2158,29 +2194,31 @@ void CG1500_application::controlla_conto(int file1,int file2)
stampa_prima_colonna(_gruppo_dare, _conto_dare, _sottoconto_dare,
_descr_dare,_saldo_dare);
_cambiato_conto_1 = TRUE;
if ( (_conto_dare == 0) && (_sottoconto_dare == 0) )
_tot_dare += _saldo_dare;
if (!_totali)
if ( (_conto_dare == 0) && (_sottoconto_dare == 0) )
_tot_dare += _saldo_dare;
if (_totali)
if (_sottoconto_dare == 0)
_tot_dare += _saldo_dare;
}
if (!file2)
if (_cambiato_conto_2)
{
//if (!(_totali && _conto_avere==0 && _sottoconto_avere == 0l))
if (_totali && _conto_avere==0 && _sottoconto_avere==0l)
_cambiato_conto_2 = FALSE;
else
{
set_row(_i,"@66g%c", dep);
_cambiato_conto_2 = FALSE;
}
set_row(_i,"@66g%c", dep);
_cambiato_conto_2 = FALSE;
}
else
{
stampa_seconda_colonna(_gruppo_avere, _conto_avere, _sottoconto_avere,
_descr_avere, _saldo_avere);
_cambiato_conto_2 = TRUE;
if ( (_conto_avere == 0) && (_sottoconto_avere == 0) )
_tot_avere += _saldo_avere;
_cambiato_conto_2 = TRUE;
if (!_totali)
if ( (_conto_avere == 0) && (_sottoconto_avere == 0) )
_tot_avere += _saldo_avere;
if (_totali)
if (_sottoconto_avere == 0)
_tot_avere += _saldo_avere;
}
}
@ -2249,7 +2287,8 @@ void CG1500_application::set_page(int file, int counter)
if (_eof5 && _eof6)
{
_stampato = TRUE;
stampa_totali();
//stampa_totali();
stampa_totali_uno(_prg_inidare_ord,_prg_iniavere_ord);
}
}
_salto_pagina1 = TRUE;
@ -2261,7 +2300,9 @@ void CG1500_application::set_page(int file, int counter)
{
controlla_conto(_eof5,_eof6);
if (_eof5 && _eof6)
if (!_stampato) stampa_totali();
if (!_stampato)
//stampa_totali();
stampa_totali_uno(_prg_inidare_ord,_prg_iniavere_ord);
}
}
}
@ -2606,75 +2647,81 @@ void CG1500_application::stampa_totali()
}
//per Attivita'/Passivita' stampo anche lo sbilancio es. precedente
void CG1500_application::stampa_totali_uno()
void CG1500_application::stampa_totali_uno(const real& r1,const real& r2)
{
TString dep = "";
real pareggio;
real sbilancio = _tot_dare - _prg_saldoini_dare - (_tot_avere - _prg_saldoini_avere);
real sbilprec = _prg_saldoini_avere - _prg_saldoini_dare;
if (sbilancio > ZERO) //ho un utile => va stampato tra le passivita'
real sbilancio = _tot_dare - r1 - (_tot_avere - r2);
real sbilprec = r2 - r1;
/*
if (sbilancio > ZERO) //ho un utile => va stampato tra le passivita'
{
sbilprec = -sbilprec;
pareggio = _tot_avere + sbilancio + sbilprec;
}
else if (sbilancio < ZERO) //ho una perdita => va stampato tra le attivita' cambiato di segno
{
sbilancio = -sbilancio;
pareggio = _tot_dare + sbilancio + sbilprec;
}
*/
if (_prima_volta) //ho finito di stampare le attivita'/passivita'
_prima_volta = FALSE;
else
_seconda_volta = FALSE;
_gc_prec_dare = _gc_corr_avere = "";
_cambiato_conto_1 = TRUE;
_cambiato_conto_2 = TRUE;
set_row(_i++, (const char*)dep);
set_row(_i++, (const char*)dep);
set_row(_i++, (const char*)dep);
set_row(_i++, (const char*)dep);
set_row(_i++, "@35gTOTALE@45g%r@103gTOTALE@113g%r",
&_tot_dare, &_tot_avere);
if (sbilancio > ZERO) //ho un utile => va stampato tra le passivita'
{
sbilprec = -sbilprec;
pareggio = _tot_avere + sbilancio + sbilprec;
}
else if (sbilancio < ZERO) //ho una perdita => va stampato tra le attivita' cambiato di segno
{
sbilancio = -sbilancio;
pareggio = _tot_dare + sbilancio + sbilprec;
}
if (_prima_volta) //ho finito di stampare le attivita'/passivita'
_prima_volta = FALSE;
else
_seconda_volta = FALSE;
_gc_prec_dare = _gc_corr_avere = "";
_cambiato_conto_1 = TRUE;
_cambiato_conto_2 = TRUE;
set_row(_i++, (const char*)dep);
set_row(_i++, (const char*)dep);
set_row(_i++, (const char*)dep);
set_row(_i++, (const char*)dep);
set_row(_i++, "@35gTOTALE@45g%r@103gTOTALE@113g%r",
&_tot_dare, &_tot_avere);
if (sbilancio > ZERO)
{
if (sbilprec != ZERO)
set_row(_i++, "@79gSBILANCIO ESERCIZIO PRECEDENTE@113g%r",
&sbilprec);
set_row(_i++, "@81gSBILANCIO ESERCIZIO IN CORSO@113g%r",
&sbilancio);
set_row(_i++, "@92gTOTALE A PAREGGIO@113g%r",&pareggio);
}
else if (sbilancio < ZERO)
{
if (sbilprec != ZERO)
set_row(_i++, "@11gSBILANCIO ESERCIZIO PRECEDENTE@45g%r",
&sbilprec);
set_row(_i++, "@13gSBILANCIO ESERCIZIO IN CORSO@45g%r",
&sbilancio);
set_row(_i++, "@24gTOTALE A PAREGGIO@45g%r", &pareggio);
}
else //sbilancio es. in corso == 0
{
sbilprec = -sbilprec;
if (sbilprec > ZERO) //va stampato sotto le passivita'
{
pareggio = _tot_avere + sbilprec;
set_row(_i++, "@79gSBILANCIO ESERCIZIO PRECEDENTE@113g%r",
&sbilprec);
set_row(_i++, "@92gTOTALE A PAREGGIO@113g%r", &pareggio);
pareggio = _tot_avere + sbilancio + sbilprec;
if (sbilprec != ZERO)
set_row(_i++, "@79gSBILANCIO ESERCIZIO PRECEDENTE@113g%r",
&sbilprec);
set_row(_i++, "@81gSBILANCIO ESERCIZIO IN CORSO@113g%r",
&sbilancio);
set_row(_i++, "@92gTOTALE A PAREGGIO@113g%r",&pareggio);
}
else if (sbilprec < ZERO)
{
sbilprec = -sbilprec;
pareggio = _tot_dare + sbilprec;
set_row(_i++, "@79gSBILANCIO ESERCIZIO PRECEDENTE@113g%r",
&sbilprec);
set_row(_i++, "@92gTOTALE A PAREGGIO@113g%r",&pareggio);
}
}
_tot_dare = ZERO;
_tot_avere = ZERO;
else if (sbilancio < ZERO) //ho una perdita => va stampato tra le attivita'
{
sbilancio = -sbilancio;
pareggio = _tot_dare + sbilancio + sbilprec;
if (sbilprec != ZERO)
set_row(_i++, "@11gSBILANCIO ESERCIZIO PRECEDENTE@45g%r",
&sbilprec);
set_row(_i++, "@13gSBILANCIO ESERCIZIO IN CORSO@45g%r",
&sbilancio);
set_row(_i++, "@24gTOTALE A PAREGGIO@45g%r", &pareggio);
}
else //sbilancio es. in corso == 0
{
sbilprec = -sbilprec;
if (sbilprec > ZERO) //va stampato sotto le passivita'
{
pareggio = _tot_avere + sbilprec;
set_row(_i++, "@79gSBILANCIO ESERCIZIO PRECEDENTE@113g%r",
&sbilprec);
set_row(_i++, "@92gTOTALE A PAREGGIO@113g%r", &pareggio);
}
else if (sbilprec < ZERO)
{
sbilprec = -sbilprec;
pareggio = _tot_dare + sbilprec;
set_row(_i++, "@11gSBILANCIO ESERCIZIO PRECEDENTE@45g%r",
&sbilprec);
set_row(_i++, "@24gTOTALE A PAREGGIO@45g%r",&pareggio);
}
}
_tot_dare = ZERO;
_tot_avere = ZERO;
}
void CG1500_application::stampa_prima_colonna(int g, int c, long s,

924
cg/cg1600.cpp
View File

File diff suppressed because it is too large Load Diff

26
cg/cg1700.cpp
View File

@ -173,27 +173,41 @@ bool CG1700_application::preprocess_print(int file, int counter)
bool CG1700_application::preprocess_page(int file,int count)
{
TString cau_descr, rcau_descr;
TString cau_reg (3);
bool cau_alleg, cau_rfatt, cau_intra, cau_val;
reset_print();
switch (file)
{
case LF_CAUSALI:
cau_descr = current_cursor()->file(LF_CAUSALI).get(CAU_DESCR);
cau_descr = current_cursor()->file(LF_CAUSALI).get(CAU_DESCR);
cau_reg = current_cursor()->file(LF_CAUSALI).get(CAU_REG);
cau_alleg = current_cursor()->file(LF_CAUSALI).get_bool(CAU_ALLEG);
cau_rfatt = current_cursor()->file(LF_CAUSALI).get_bool(CAU_RITFATT);
cau_intra = current_cursor()->file(LF_CAUSALI).get_bool(CAU_INTRACOM);
cau_val = current_cursor()->file(LF_CAUSALI).get_bool(CAU_MOVVAL);
*_descr_causale = (const char*) cau_descr;
setta_righe_descr(_descr_causale,causale);
set_row(1, "@0g@3s", FLD(LF_CAUSALI,CAU_CODCAUS));
set_row(1, "@30g@2s", FLD(LF_CAUSALI,CAU_TIPODOC));
set_row(1, "@84g@3s", FLD(LF_CAUSALI,CAU_REG));
set_row(1, "@89g@f", FLD(LF_CAUSALI,CAU_ALLEG));
if (cau_reg.not_empty())
//set_row(1, "@89g@f", FLD(LF_CAUSALI,CAU_ALLEG));
if (cau_alleg)
set_row(1, "@89gNo");
else set_row(1, "@89gSi");
set_row(1, "@95g@1s", FLD(LF_CAUSALI,CAU_M770));
set_row(1, "@99g@1s", FLD(LF_CAUSALI,CAU_COLLCESP));
set_row(1, "@104g@1n", FLD(LF_CAUSALI,CAU_TIPOMOV));
set_row(1, "@108g@f", FLD(LF_CAUSALI,CAU_NUMDOC));
set_row(1, "@113g@f", FLD(LF_CAUSALI,CAU_DATADOC));
set_row(1, "@118g@3s", FLD(LF_CAUSALI,CAU_CODCAUSIM));
set_row(1, "@123g@f", FLD(LF_CAUSALI,CAU_INTRACOM));
set_row(1, "@126g@f", FLD(LF_CAUSALI,CAU_MOVVAL));
set_row(1, "@130g@f", FLD(LF_CAUSALI,CAU_RITFATT));
if (cau_intra)
set_row(1, "@123g@f", FLD(LF_CAUSALI,CAU_INTRACOM));
if (cau_val)
set_row(1, "@126g@f", FLD(LF_CAUSALI,CAU_MOVVAL));
if (cau_rfatt)
set_row(1, "@130g@f", FLD(LF_CAUSALI,CAU_RITFATT));
break;
case LF_RCAUSALI:
rcau_descr = current_cursor()->file(LF_RCAUSALI).get(RCA_DESC);
@ -251,7 +265,7 @@ void CG1700_application::user_create()
{
_msk = new TMask("cg1700a");
_rel = new TRelation (LF_CAUSALI);
_rel->add(LF_RCAUSALI,"CODCAUS=CODCAUS",1);
_rel->add(LF_RCAUSALI,"CODCAUS==CODCAUS",1);
_cur = new TCursor (_rel,"", 1);
add_cursor(_cur);

177
cg/cg3200.cpp
View File

@ -96,6 +96,7 @@ public:
void calcola_progressivi();
void calcola_progressivi_al();
void stampa_progressivi();
void stampa_progre_riporto();
void documenti_iva();
void ricerca_regiva();
void descrizione_causale();
@ -481,7 +482,8 @@ bool CG3200_application::preprocess_page(int file, int counter)
_gruppo = atoi(current_cursor()->curr(LF_SALDI).get(SLD_GRUPPO));
_conto = atoi(current_cursor()->curr(LF_SALDI).get(SLD_CONTO));
_sottoc = atol(current_cursor()->curr(LF_SALDI).get(SLD_SOTTOCONTO));
annoes = atoi(current_cursor()->curr(LF_SALDI).get(SLD_ANNOES));
annoes = atoi(current_cursor()->curr(LF_SALDI).get(SLD_ANNOES));
conto();
if (annoes != _anno_corrente && annoes != _anno_precedente)
return FALSE;
@ -493,22 +495,22 @@ bool CG3200_application::preprocess_page(int file, int counter)
_c_prec = _conto;
_s_prec = _sottoc;
_saldo_periodo =0;
_totale_periodo_dare =0;
_totale_periodo_avere =0;
_saldo_progre =0;
_totprogre_dare =0;
_totprogre_avere =0;
_saldo_progre_al =0;
_totprogre_dare_al =0;
_totprogre_avere_al =0;
_progredare =0;
_progreavere =0;
_totale_prima_dare =0;
_totale_prima_avere =0;
_saldo_movimenti =0;
_saldo_progressivi =0;
_saldo_progre_prec =0;
_saldo_periodo = ZERO;
_totale_periodo_dare = ZERO;
_totale_periodo_avere = ZERO;
_saldo_progre = ZERO;
_totprogre_dare = ZERO;
_totprogre_avere = ZERO;
_saldo_progre_al = ZERO;
_totprogre_dare_al = ZERO;
_totprogre_avere_al = ZERO;
_progredare = ZERO;
_progreavere = ZERO;
_totale_prima_dare = ZERO;
_totale_prima_avere = ZERO;
_saldo_movimenti = ZERO;
_saldo_progressivi = ZERO;
_saldo_progre_prec = ZERO;
if (_tipostampa == 2)
saldi_zero();
else
@ -520,6 +522,7 @@ bool CG3200_application::preprocess_page(int file, int counter)
{
_puoi_stampare = TRUE;
calcola_progressivi();
stampa_progre_riporto();
}
else
{
@ -536,8 +539,11 @@ bool CG3200_application::preprocess_page(int file, int counter)
_puoi_stampare = FALSE;
return FALSE;
}
else
else
{
_puoi_stampare = TRUE;
stampa_progre_riporto();
}
}
break;
@ -906,6 +912,23 @@ bool CG3200_application::set_print(int)
_anno_precedente = _anno_corrente - 1;
_saldo_periodo = ZERO;
_totale_periodo_dare = ZERO;
_totale_periodo_avere = ZERO;
_saldo_progre = ZERO;
_totprogre_dare = ZERO;
_totprogre_avere = ZERO;
_saldo_progre_al = ZERO;
_totprogre_dare_al = ZERO;
_totprogre_avere_al = ZERO;
_progredare = ZERO;
_progreavere = ZERO;
_totale_prima_dare = ZERO;
_totale_prima_avere = ZERO;
_saldo_movimenti = ZERO;
_saldo_progressivi = ZERO;
_saldo_progre_prec = ZERO;
// Scelta del formato e del numero di mastrini per pagina 1 o 2
if (nummast == 1)
@ -1075,7 +1098,7 @@ void CG3200_application::crea_intestazione()
set_header (3, "@16g%d", _conto);
set_header (3, "@20g%d", _sottoc);
conto();
// conto();
if (_tmcf == 'C')
_tipo_mask = 1;
@ -1111,7 +1134,8 @@ void CG3200_application::crea_intestazione()
set_header (8,"Data@11gnumero@19gDocumento@38gCod.Causale@68gDescrizione@108gDare@124gAvere@136gSaldo progress.@154gSaldo movim.@172gPartita@185gIva@189gProtocollo");
sep1.fill('-');
set_header (9,"@1g%s", (const char *) sep1);
}
}
/*
if (_stampa_progressivi_si)
{
stampa_progressivi();
@ -1149,9 +1173,54 @@ void CG3200_application::crea_intestazione()
{
sep1 ="";
set_header(11,"@1g%s",(const char*) sep1);
}
}
*/
}
void CG3200_application::stampa_progre_riporto()
{
TString sep(132),sep1(198);
if (_stampa_progressivi_si)
{
stampa_progressivi();
_riporto_dare = _progredare;
_riporto_avere = _progreavere;
_stampa_progressivi_si = FALSE;
}
else
{
_riporto_dare += _riporto_parziale_dare;
_riporto_avere += _riporto_parziale_avere;
if (_numcarat == 1)
{
TString string = _riporto_dare.string("###############");
set_row (1,"@32gA RIPORTO@85g%15s",(const char*) string);
string = _riporto_avere.string("###############");
set_row (1,"@101g%15s",(const char*) string);
}
if (_numcarat == 2)
{
TString string = _riporto_dare.string("###############");
set_row (1,"@32gA RIPORTO@102g%15s",(const char*) string);
string = _riporto_avere.string("###############");
set_row (1,"@119g%15s",(const char*) string);
}
_riporto_parziale_dare = 0;
_riporto_parziale_avere = 0;
}
if (_numcarat == 1)
{
sep ="";
set_row(2,"@1g%s",(const char*) sep);
}
else if (_numcarat == 2)
{
sep1 ="";
set_row(2,"@1g%s",(const char*) sep1);
}
}
void CG3200_application::calcola_progressivi_al()
{
long record,sottoc,annoes;
@ -1220,13 +1289,13 @@ void CG3200_application::calcola_progressivi()
char salini;
// TRectype record(saldi.curr());
saldo = 0.00;
pdarep = 0.00;
paverep = 0.00;
pdaresca = 0.00;
paveresca = 0.00;
pdarescap = 0.00;
paverescap = 0.00;
saldo = ZERO;
pdarep = ZERO;
paverep = ZERO;
pdaresca = ZERO;
paveresca = ZERO;
pdarescap = ZERO;
paverescap = ZERO;
// Ricerca sull'archivio saldi dei record con gruppo,conto,sottoconto
// uguali a quelli di rmov per il calcolo dei progressivi precedenti
@ -1273,9 +1342,9 @@ void CG3200_application::calcola_progressivi()
if (annoes_saldi == _anno_precedente)
{
pdarescap = saldi.get_real(SLD_PDARESCA);
pdarep = saldi.get_real(SLD_PDARE);
pdarep = saldi.get_real(SLD_PDARE);
paverescap = saldi.get_real(SLD_PAVERESCA);
paverep = saldi.get_real(SLD_PAVERE);
paverep = saldi.get_real(SLD_PAVERE);
}
// Se il saldo dell'esercizio attuale e' diverso da 0 allora significa che
@ -1289,18 +1358,18 @@ void CG3200_application::calcola_progressivi()
{
if (saldo != ZERO)
{
if (salini == 'D')
{
progredare_eseprec = saldo;// + pdarescap + pdarep;
if (salini == 'D')
{
progredare_eseprec = saldo;// + pdarescap + pdarep;
progdare_prec = saldo;
// progreavere_eseprec = paverescap;// + paverep;
}
else if (salini == 'A')
{
{
// progredare_eseprec = pdarescap;// + pdarep;
progreavere_eseprec = saldo;// + paverescap + paverep;
progreavere_eseprec = saldo;// + paverescap + paverep;
progavere_prec = saldo;
}
}
}
else
{
@ -1308,24 +1377,24 @@ void CG3200_application::calcola_progressivi()
//Se il saldo dell'esercizio attuale non e' diverso da zero, allora il saldo
// finale dell'esercizio precedente devo calcolarmelo tenendo conto dell'indbil
if ((_indbil == 1) || (_indbil == 2) || (_indbil == 5))
{
saldo = _sld.saldofin_esprec(_anno_corrente,_gruppo,_conto,_sottoc);
if ((_indbil == 1) || (_indbil == 2) || (_indbil == 5))
{
saldo = _sld.saldofin_esprec(_anno_corrente,_gruppo,_conto,_sottoc);
if (saldo> ZERO)
{
progredare_eseprec = saldo;// + pdarescap + pdarep;
if (saldo> ZERO)
{
progredare_eseprec = saldo;// + pdarescap + pdarep;
progdare_prec = saldo;
// progreavere_eseprec = paverescap + paverep;
}
}
else if (saldo < ZERO)
{
{
// progredare_eseprec = pdarescap + pdarep;
saldo = -saldo;
progreavere_eseprec = saldo;// + paverescap + paverep;
progavere_prec = saldo;
}
}
progreavere_eseprec = saldo;// + paverescap + paverep;
progavere_prec = saldo;
}
}
}
}
} // FOR
@ -1366,19 +1435,19 @@ void CG3200_application::stampa_progressivi()
if (_numcarat == 1)
{
TString string = _saldo_progre_prec.string("###############");
set_header (10,"@32gPROGRESSIVI PRECEDENTI@69g%15s",(const char*) string);
set_row (1,"@32gPROGRESSIVI PRECEDENTI@69g%15s",(const char*) string);
string = _progredare.string("###############");
set_header (10,"@85g%15s",(const char*) string);
set_row (1,"@85g%15s",(const char*) string);
string = _progreavere.string("###############");
set_header (10,"@101g%15s",(const char*) string);
set_row (1,"@101g%15s",(const char*) string);
}
if (_numcarat == 2)
{
TString string = _progredare.string("###############");
set_header (10,"@32gPROGRESSIVI PRECEDENTI@102g%15s",(const char*)string);
set_row (1,"@32gPROGRESSIVI PRECEDENTI@102g%15s",(const char*)string);
string = _progreavere.string("###############");
set_header (10,"@119g%15s",(const char*) string);
set_row (1,"@119g%15s",(const char*) string);
}
}
// Se la ricerca selezionata nella maschera e' per clienti, oppure fornitori, // allora ricerco su CLIFO i relativi dati, e su PCON il relativo gruppo,conto,// sottoconto e IV direttiva CEE

71
cg/cg3200a.uml
View File

@ -126,6 +126,75 @@ BEGIN
GROUP 1
END
NUMBER F_SOTTOCINI_CLIENTE 6
BEGIN
PROMPT 48 5 ""
USE LF_CLIFO
CHECKTYPE NORMAL
INPUT TIPOCF "C"
INPUT CODCF F_SOTTOCINI_CLIENTE
DISPLAY "Codice" CODCF
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
OUTPUT F_SOTTOCINI_CLIENTE CODCF
OUTPUT F_DESCRINI_CLIENTE RAGSOC
MESSAGE COPY,F_SOTTOCINI_CONTO
FLAGS "R"
GROUP 2
END
STRING F_DESCRINI_CLIENTE 50
BEGIN
PROMPT 4 6 "Ragione sociale C "
FIELD LF_CLIFO->RAGSOC
USE LF_CLIFO KEY 2
INPUT TIPOCF "C"
INPUT RAGSOC F_DESCRINI_CLIENTE
DISPLAY "Ragione Sociale Cliente@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Codice" CODCF
COPY OUTPUT F_SOTTOCINI_CLIENTE
MESSAGE COPY,F_DESCRINI_CONTO
CHECKTYPE NORMAL
GROUP 2
END
NUMBER F_SOTTOCINI_FORN 6
BEGIN
PROMPT 48 5 ""
USE LF_CLIFO
CHECKTYPE NORMAL
INPUT TIPOCF "F"
INPUT CODCF F_SOTTOCINI_FORN
DISPLAY "Codice" CODCF
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
OUTPUT F_SOTTOCINI_FORN CODCF
OUTPUT F_DESCRINI_FORN RAGSOC
FLAGS "R"
GROUP 3
MESSAGE COPY,F_SOTTOCINI_CONTO
END
STRING F_DESCRINI_FORN 50
BEGIN
PROMPT 4 6 "Ragione Sociale F "
USE LF_CLIFO KEY 2
INPUT TIPOCF "F"
INPUT RAGSOC F_DESCRINI_FORN
DISPLAY "Ragione Sociale Fornitore@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Codice" CODCF
COPY OUTPUT F_DESCRINI_CONTO
MESSAGE COPY,F_DESCRINI_CONTO
CHECKTYPE NORMAL
GROUP 3
END
NUMBER F_GRUPPOFINE 3
BEGIN
PROMPT 4 7 "A Gruppo - Conto - Sottoconto "
@ -351,7 +420,7 @@ END
LIST F_STAMPANUM 15
BEGIN
PROMPT 4 15 "Stampa numerazione "
ITEM "1|Registrazione"
ITEM "1|Operazione"
ITEM "2|Riga giornale"
END

39
cg/cg3400.cpp
View File

@ -29,7 +29,8 @@
#include "cg3400b.h"
HIDDEN const char* REAL_PICTURE = "###.###.###.###";
HIDDEN const char* REAL_TOT_PIC = "##.###.###.###.###.###";
HIDDEN const char* REAL_TOT_PIC = "#.###.###.###.###";
HIDDEN const char* RIP_TOT_PIC = "##.###.###.###.###.###";
HIDDEN const int RIGHE_MODULO = 66;
HIDDEN const int RIGHE_FOOTER = 10;
@ -425,12 +426,10 @@ void CG3400_application::set_page_132 (int file, int counter)
set_row (r, "#-3ld", &_nprog_mov);
else
set_row (r, "@3,rn", FLD(LF_RMOV, RMV_NUMREG));
set_row (r, "@4g@d@13g@pn@pn@pn",
FLD(LF_RMOV, RMV_DATAREG),
FLD(LF_RMOV, RMV_GRUPPO, "@@."),
FLD(LF_RMOV, RMV_CONTO , "@@."),
FLD(LF_RMOV, RMV_SOTTOCONTO, "@@@@@@")
);
set_row (r, "@4g@d", FLD(LF_RMOV, RMV_DATAREG));
set_row (r, "@13g@pn", FLD(LF_RMOV, RMV_GRUPPO, "@@."));
set_row (r, "@pn", FLD(LF_RMOV, RMV_CONTO , "@@."));
set_row (r, "@pn", FLD(LF_RMOV, RMV_SOTTOCONTO, "@@@@@@"));
}
break;
@ -516,8 +515,8 @@ void CG3400_application::postclose_print()
{
_pagina_da = -1;
aggiorna_mov ();
aggiorna_tabreg (_pagina_da, stampate);
}
aggiorna_tabreg (_pagina_da, stampate);
}
}
@ -624,7 +623,8 @@ int CG3400_application::set_header_198()
if (_stampa_intesta) r = stampa_intestazione_ditta();
set_header(r, "@bCodice libro:@r %s %s @bdalla data:@r %s @balla data:@r %s @bEsercizio:@r %04d",
// set_header(r, "@bCodice libro:@r %s %s @bdalla data:@r %s @balla data:@r %s @bEsercizio:@r %04d",
set_header(r, "Codice libro: %s %s dalla data: %s alla data: %s Esercizio: %04d",
(const char *) _reg_cod, (const char *) _reg_descr,
(const char *) data_da, (const char *) data_a, _ae);
r++;
@ -687,7 +687,8 @@ int CG3400_application::set_header_132()
set_header(r, riga);
#endif
set_header(r++, "@bCodice libro:@r %s %s @50g@bdalla data:@r %s @balla data:@r %s @bEsercizio:@r %04d",
// set_header(r++, "@bCodice libro:@r %s %s @bdalla data:@r %s @balla data:@r %s @bEsercizio:@r %04d",
set_header(r++, "Codice libro: %s %s @69gdalla data: %s alla data: %s Esercizio: %04d",
(const char *) _reg_cod, (const char *) _reg_descr,
(const char *) data_da, (const char *) data_a, _ae);
@ -746,11 +747,11 @@ void CG3400_application::preprocess_header()
riporto_dare = _tot_dare_progr + _tot_dare_progr_ap;
riporto_avere = _tot_avere_progr + _tot_avere_progr_ap;
TString dare(riporto_dare.string(REAL_TOT_PIC));
TString avere(riporto_avere.string(REAL_TOT_PIC));
TString dare (riporto_dare.string(RIP_TOT_PIC));
TString avere(riporto_avere.string(RIP_TOT_PIC));
if (_stampa_width == 132)
frm = "@b@78g";
frm = "@b@84g";
else
frm = "@b@100g";
@ -1072,21 +1073,21 @@ void CG3400_application::setta_righe_descr(TParagraph_string* str, enum descr de
{
case causale: // lunga 20
if (_libro_giornale_iva_unico)
frm = "@i@10g%.20s@r";
frm = "@10g%.20s";
else
frm = "@i@48g%.20s@r";
frm = "@48g%.20s";
break;
case conto: // lunga 21
if (_libro_giornale_iva_unico)
frm = "@i@69g%s@r";
frm = "@69g%s";
else
frm = "@i@26g%s@r";
frm = "@26g%s";
break;
case operazione: // lunga 28
if (_libro_giornale_iva_unico)
frm = "@i@31g%s@r";
frm = "@31g%s";
else
frm = "@i@69g%s@r";
frm = "@69g%s";
break;
default:
break;

1
cg/cg3400a.uml
View File

@ -19,6 +19,7 @@ BEGIN
// OUTPUT DATA_DA D0
// OUTPUT DATA_A D1
// CHECKTYPE NORMAL
FLAGS "U"
END
NUMBER ANNO_ESER 4

467
cg/cg5200.cpp Executable file
View File

@ -0,0 +1,467 @@
// cg5200.cpp - Visualizzazione saldi
#include <applicat.h>
#include <msksheet.h>
#include <relapp.h>
#include <brwapp.h>
#include <tabutil.h>
#include <config.h>
#include <utility.h>
#include <urldefid.h>
#include <cglib.h>
#include <saldi.h>
#include <clifo.h>
#include <pconti.h>
#include "cg5200.h"
HIDDEN const char* REAL_PICTURE = "###.###.###.###";
class TRiga_array : public TArray
{
public:
bool add_riga(const TRectype& rec_saldi);
};
bool TRiga_array::add_riga(const TRectype& rec_saldi)
{
bool found = FALSE;
int annoes, annoesr;
char flag, flagr;
TDate udata, udatar;
long unum, unumr;
real pdaresca,paveresca,pdare,pavere,saldoini,pdarepro,paverepro;
real pdarescar,paverescar,pdarer,paverer,saldoinir,pdarepror,paverepror;
for (int i = 0; i < items(); i++)
{
TRectype& r = (TRectype&)(*this)[i];
annoes = r.get_int(SLD_ANNOES);
annoesr = rec_saldi.get_int(SLD_ANNOES);
if ( annoes == annoesr )
{
pdaresca = r.get_real(SLD_PDARESCA);
paveresca = r.get_real(SLD_PAVERESCA);
flag = r.get_char(SLD_FLAGSALINI);
pdare = r.get_real(SLD_PDARE);
pavere = r.get_real(SLD_PAVERE);
saldoini = r.get_real(SLD_SALDO);
pdarepro = r.get_real(SLD_PDAREPRO);
paverepro = r.get_real(SLD_PAVEREPRO);
udata = r.get(SLD_DATAULMOV);
unum = r.get_long(SLD_NUMULTMOV);
pdarescar = rec_saldi.get_real(SLD_PDARESCA);
pdarescar += pdaresca;
paverescar = rec_saldi.get_real(SLD_PAVERESCA);
paverescar+= paveresca;
flagr = rec_saldi.get_char(SLD_FLAGSALINI);
pdarer = rec_saldi.get_real(SLD_PDARE);
pdarer += pdare;
paverer = rec_saldi.get_real(SLD_PAVERE);
paverer += pavere;
saldoinir = rec_saldi.get_real(SLD_SALDO);
udatar = rec_saldi.get(SLD_DATAULMOV);
unumr = rec_saldi.get_long(SLD_NUMULTMOV);
udatar = fnc_max(udatar,udata);
unumr = (unum > unumr) ? unum : unumr;
if (flagr == 'D')
saldoinir += saldoini;
else if (flagr == 'A')
saldoinir -= saldoini;
pdarepror = rec_saldi.get_real(SLD_PDAREPRO);
pdarepror += pdarepro;
paverepror = rec_saldi.get_real(SLD_PAVEREPRO);
paverepror += paverepro;
found = TRUE;
r.put(SLD_ANNOES, annoes);
r.put(SLD_PDARESCA, pdarescar);
r.put(SLD_PAVERESCA,paverescar);
r.put(SLD_PDARE, pdarer);
r.put(SLD_PAVERE,paverer);
r.put(SLD_SALDO, saldoinir);
r.put(SLD_PDAREPRO, pdarepror);
r.put(SLD_PAVEREPRO,paverepro);
r.put(SLD_DATAULMOV, udatar);
r.put(SLD_NUMULTMOV, unumr);
}
}
if (!found)
{
TRectype* r = new TRectype(rec_saldi);//ci copia anche i valori di rec_saldi
add(r);
}
return found;
}
bool gruppo_handler (TMask_field& f, KEY k);
bool sottoc_handler (TMask_field& f, KEY k);
class CG5200_application : public TBrowse_application
{
friend bool gruppo_handler (TMask_field& f, KEY k);
friend bool sottoc_handler (TMask_field& f, KEY k);
TMask* _msk;
TLocalisamfile* _pcon,* _clifo;
TCursor * _cur;
TRelation * _rel,* _rel1;
TRiga_array _riga;
int _items, _anno, _g, _c;
long _s;
bool _saldo_conto, _saldo_gruppo, _saldo_sottoc;
protected:
virtual bool user_create();
virtual bool user_destroy();
virtual TRelation* get_relation() const { return _rel; }
virtual TMask* get_mask(int mode) { return _msk; }
virtual bool changing_mask(int mode) {return FALSE; }
virtual int read(TMask& m);
public:
void add_r(int,int,real&,real&,real&,char,real&,real&,
real&,real&,TDate&,long,real&,real&,real&);
void compilasheet();
bool fai_filtro();
TMask* main_mask() const {return _msk;}
TSheet_field& ss() const { return (TSheet_field&)_msk->field(F_SHEET_SALDI);}
CG5200_application() {}
};
HIDDEN CG5200_application * app() { return (CG5200_application*) MainApp(); }
bool CG5200_application::fai_filtro()
{
TSaldo sld;
int annop = 0;
char tipo;
_saldo_gruppo = _saldo_conto = _saldo_sottoc = FALSE;
TMask* m = app()->main_mask();
tipo = m->get(F_TIPOCF)[0];
_anno = m->get_int(F_ANNO);
_g = m->get_int(F_GRUPPO);
_c = m->get_int(F_CONTO);
if (tipo == ' ')
_s = m->get_long(F_SOTTOCONTO);
else if (tipo == 'C')
_s = m->get_long(F_SOTTOC_CLIENTE);
else _s = m->get_long(F_SOTTOC_FORN);
if (_c == 0)
_saldo_gruppo = TRUE;
else if (_s == 0l)
_saldo_conto = TRUE;
else _saldo_sottoc = TRUE;
TLocalisamfile& saldi = _rel1->lfile();
TRectype from (saldi.curr());
TRectype to (saldi.curr());
from.zero();
to.zero();
if (_anno != 0)
annop = sld.EsePre(_anno);
if (annop != 0)
from.put(SLD_ANNOES,annop);
else if (_anno != 0)
from.put(SLD_ANNOES,_anno);
else from.put(SLD_ANNOES,0);
from.put(SLD_GRUPPO,_g);
if (_c != 0)
from.put(SLD_CONTO, _c);
if (_s != 0l)
from.put(SLD_SOTTOCONTO, _s);
if (_anno != 0)
to.put(SLD_ANNOES,_anno);
else to.put(SLD_ANNOES, 9999);
to.put(SLD_GRUPPO,_g);
if (_c != 0)
to.put(SLD_CONTO,_c);
if (_s != 0l)
to.put(SLD_SOTTOCONTO,_s);
if ( _saldo_gruppo || _saldo_conto )
_cur->setkey(1);
if (_saldo_sottoc)
_cur->setkey(2);
_cur->setregion(from,to);
return TRUE;
}
bool gruppo_handler(TMask_field& f, KEY key)
{
if ( key == K_TAB && f.mask().is_running() )
{
const TMask& m = f.mask();
const int gruppo = m.get_int(F_GRUPPO);
const int conto = m.get_int(F_CONTO);
const long sottoc = m.get_long(F_SOTTOCONTO);
TLocalisamfile& pconti = app()->get_relation()->lfile();
if (gruppo == 0)
{
if (conto != 0 || sottoc != 0)
return f.warning_box("Codice conto impossibile!");
else
return f.error_box("E' obbligatorio l'inserimento del gruppo");
}
if (conto > 0 && sottoc == 0) // conto => ricerca gruppo
{
pconti.zero() ;
pconti.put(PCN_GRUPPO, gruppo) ;
pconti.setkey(1) ;
pconti.read(_isequal, _nolock );
if (pconti.bad())
return f.warning_box ("Non esiste il gruppo relativo a questo conto");
}
if (sottoc > 0) // sottoconto => ricerca conto
{
pconti.zero() ;
pconti.put(PCN_GRUPPO, gruppo) ;
pconti.put(PCN_CONTO, conto) ;
pconti.setkey(1) ;
pconti.read(_isequal, _nolock );
if (pconti.bad())
return f.warning_box ("Non esiste il conto relativo a questo sottoconto");
else
{
TString tmcf = pconti.get(PCN_TMCF);
if (tmcf.not_empty())
return f.warning_box ("Non puoi inserire un sottoconto di un conto relativo ad un cliente/fornitore");
}
}
}
return TRUE;
}
bool sottoc_handler(TMask_field& f, KEY key)
{
if (key == K_TAB)
{
const short id = f.dlg();
TLocalisamfile clifo (LF_CLIFO);
int gruppo = f.mask().get_int(F_GRUPPO);
if (gruppo == 0) return TRUE;
int conto = f.mask().get_int(F_CONTO);
long sottoconto = f.mask().get_long(id);
if (sottoconto != 0 && conto == 0) return f.error_box("Manca il CONTO");
if (id == F_SOTTOC_CLIENTE || id == F_SOTTOC_FORN)
{
char tmcf = f.mask().get(F_TIPOCF)[0];
clifo.zero() ;
clifo.put(CLI_TIPOCF,tmcf);
clifo.put(CLI_CODCF,sottoconto);
clifo.setkey(1) ;
clifo.read(_isequal, _nolock );
if (clifo.bad())
return f.warning_box ("Registrazione assente");
}
f.mask().stop_run(K_AUTO_ENTER);
}
return TRUE;
}
bool CG5200_application::user_create()
{
_msk = new TMask("cg5200a");
_msk->set_handler(F_GRUPPO, gruppo_handler);
_msk->set_handler(F_SOTTOCONTO, sottoc_handler);
_msk->set_handler(F_SOTTOC_CLIENTE, sottoc_handler);
_msk->set_handler(F_SOTTOC_FORN, sottoc_handler);
_pcon = new TLocalisamfile(LF_PCON);
_clifo = new TLocalisamfile(LF_CLIFO);
_rel = new TRelation(LF_PCON);
_rel1 = new TRelation(LF_SALDI);
_cur = new TCursor(_rel1, "", 2);
set_search_field(F_GRUPPO);
TSheet_field& cs = ss();
return TRUE;
}
bool CG5200_application::user_destroy()
{
delete _msk;
delete _pcon;
delete _clifo;
delete _rel;
delete _rel1;
delete _cur;
return TRUE;
}
int CG5200_application::read(TMask& m)
{
m.autoload(_rel);
fai_filtro();
compilasheet();
ss().force_update();
return NOERR;
}
void CG5200_application::add_r(int numrig,int a,real& pds,real& pas,real& sc,char f,real& si,real& pd,
real& pa,real& s,TDate& d,long n,real& pdp,real& pap,real& sp)
{
TSheet_field& cs = ss();
TString dep (18);
if (sc > ZERO)
dep << sc.string(REAL_PICTURE) << " D";
else if (sc < ZERO)
{
sc = -sc;
dep << sc.string(REAL_PICTURE) << " A";
}
TToken_string& riga = cs.row(numrig);
riga.add(a, 0);
riga.add(pds.string(),1);
riga.add(pas.string(),2);
riga.add(dep,3);
dep = "";
if (si != ZERO)
dep << si.string(REAL_PICTURE) << " " << f;
riga.add(dep,4);
riga.add(pd.string(),5);
riga.add(pa.string(),6);
dep = "";
if (s > ZERO)
dep << s.string(REAL_PICTURE) << " D";
else if (s < ZERO)
{
s = -s;
dep << s.string(REAL_PICTURE) << " A";
}
riga.add(dep,7);
riga.add(d.string(),8);
riga.add(n,9);
riga.add(pdp.string(),10);
riga.add(pap.string(),11);
dep = "";
if (sp > ZERO)
dep << sp.string(REAL_PICTURE) << " D";
else if (sp < ZERO)
{
sp = -sp;
dep << sp.string(REAL_PICTURE) << " A";
}
riga.add(dep,12);
}
void CG5200_application::compilasheet()
{
char flagsal = ' ';
real saldo = ZERO;
real saldosca = ZERO;
real saldopro = ZERO;
real saldo_gc = ZERO;
real saldoini_gc = ZERO;
real saldosca_gc = ZERO;
real saldopro_gc = ZERO;
real prg_dare_gc = ZERO;
real prg_avere_gc = ZERO;
real prg_daresca_gc = ZERO;
real prg_averesca_gc = ZERO;
real prg_darepro_gc = ZERO;
real prg_averepro_gc = ZERO;
real saldoini = ZERO;
real pdare = ZERO;
real pavere = ZERO;
real pdaresca = ZERO;
real paveresca = ZERO;
real pdarepro = ZERO;
real paverepro = ZERO;
int gruppo, conto, anno;
long sottoconto;
long ultimo_num = 0l;
TDate ultima_data = 0;
ss().reset();
_riga.destroy();
TRecnotype items = _cur->items();
*_cur = 0l;
for (int i = 0; i < items; i++,++(*_cur))
{
anno = _cur->curr().get_int(SLD_ANNOES);
gruppo = _cur->curr().get_int(SLD_GRUPPO);
conto = _cur->curr().get_int(SLD_CONTO);
sottoconto = _cur->curr().get_long(SLD_SOTTOCONTO);
if (gruppo != _g) continue;
if (_saldo_conto && conto != _c) continue;
if (_saldo_conto || _saldo_gruppo)
_riga.add_riga(_cur->curr());
if (_saldo_sottoc)
{
flagsal = _cur->curr().get_char(SLD_FLAGSALINI);
saldoini = _cur->curr().get_real(SLD_SALDO);
pdare = _cur->curr().get_real(SLD_PDARE);
pavere = _cur->curr().get_real(SLD_PAVERE);
pdaresca = _cur->curr().get_real(SLD_PDARESCA);
paveresca = _cur->curr().get_real(SLD_PAVERESCA);
pdarepro = _cur->curr().get_real(SLD_PDAREPRO);
paverepro = _cur->curr().get_real(SLD_PAVEREPRO);
ultima_data = _cur->curr().get(SLD_DATAULMOV);
ultimo_num = _cur->curr().get_long(SLD_NUMULTMOV);
if (flagsal == 'D')
saldo = pdare + saldoini - pavere;
else
saldo = pdare - saldoini - pavere;
saldosca = pdaresca - paveresca;
saldopro = pdarepro - paverepro;
add_r(i,anno,pdaresca,paveresca,saldosca,flagsal,saldoini,pdare,pavere,saldo,ultima_data,ultimo_num,pdarepro,paverepro,saldopro);
}
}
if (_saldo_gruppo || _saldo_conto)
{
for (int j = 0; j < _riga.items(); j++)
{
TRectype& riga = (TRectype&)_riga[j];
anno = riga.get_int(SLD_ANNOES);
pdaresca = riga.get_real(SLD_PDARESCA);
paveresca = riga.get_real(SLD_PAVERESCA);
saldosca = pdaresca - paveresca;
saldoini = riga.get_real(SLD_SALDO);
pdare = riga.get_real(SLD_PDARE);
pavere = riga.get_real(SLD_PAVERE);
saldo = pdare - pavere + saldoini;
if (saldoini > ZERO)
flagsal = 'D';
else if (saldoini < ZERO)
{
flagsal = 'A';
saldoini = -saldoini;
}
pdarepro = riga.get_real(SLD_PDAREPRO);
paverepro = riga.get_real(SLD_PAVEREPRO);
saldopro = pdarepro - paverepro;
ultima_data = riga.get(SLD_DATAULMOV);
ultimo_num = riga.get_long(SLD_NUMULTMOV);
add_r(j,anno,pdaresca,paveresca,saldosca,flagsal,saldoini,pdare,pavere,saldo,ultima_data,ultimo_num,pdarepro,paverepro,saldopro);
}
_riga.destroy();
}
}
int cg5200(int argc, char* argv[])
{
CG5200_application a;
a.run(argc, argv, "Visualizzazione saldi");
return 0;
}

11
cg/cg5200.h Executable file
View File

@ -0,0 +1,11 @@
#define F_ANNO 101
#define F_TIPOCF 102
#define F_GRUPPO 103
#define F_CONTO 104
#define F_SOTTOCONTO 105
#define F_DESCR_CONTO 106
#define F_SOTTOC_CLIENTE 107
#define F_DESCR_CLIENTE 108
#define F_SOTTOC_FORN 109
#define F_DESCR_FORN 110
#define F_SHEET_SALDI 111

340
cg/cg5200a.uml Executable file
View File

@ -0,0 +1,340 @@
#include "cg5200.h"
TOOLBAR "" 0 20 0 2
#include <browbar.h>
ENDPAGE
PAGE "Visualizzazione saldi" -1 -1 78 18
NUMBER F_ANNO 4
BEGIN
PROMPT 4 1 "Anno esercizio "
KEY 1
USE ESC
CHECKTYPE NORMAL
INPUT CODTAB[1,4] F_ANNO
DISPLAY "Anno" CODTAB[1,4]
DISPLAY "Data inizio esercizio" D0
DISPLAY "Data fine esercizio" D1
OUTPUT F_ANNO CODTAB[1,4]
FLAGS "RZ"
END
GROUPBOX DLG_NULL 73 4
BEGIN
PROMPT 3 2 ""
//FLAGS "R"
END
LIST F_TIPOCF 9
BEGIN
PROMPT 4 3 "Tipo "
FLAGS "U"
ITEM " |Conto" MESSAGE HIDE,2@|HIDE,3@|SHOW,1@
ITEM "C|Cliente" MESSAGE HIDE,1@|HIDE,3@|SHOW,2@
ITEM "F|Fornitore" MESSAGE HIDE,1@|HIDE,2@|SHOW,3@
KEY 1
END
NUMBER F_GRUPPO 3
BEGIN
PROMPT 26 3 "Gruppo "
USE LF_PCON KEY 1 SELECT CONTO=""
FIELD LF_PCON->GRUPPO
KEY 1
INPUT GRUPPO F_GRUPPO
DISPLAY "Gruppo" GRUPPO
DISPLAY "Descrizione@50" DESCR
OUTPUT F_GRUPPO GRUPPO
CHECKTYPE NORMAL
FLAGS "R"
END
NUMBER F_CONTO 3
BEGIN
PROMPT 40 3 "Conto "
USE LF_PCON SELECT (CONTO!="") && (SOTTOCONTO="")
FIELD LF_PCON->CONTO
KEY 1
INPUT GRUPPO F_GRUPPO
INPUT CONTO F_CONTO
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Descrizione@50" DESCR
OUTPUT F_TIPOCF TMCF
OUTPUT F_GRUPPO GRUPPO
OUTPUT F_CONTO CONTO
OUTPUT F_DESCR_CONTO DESCR
FLAGS "R"
CHECKTYPE NORMAL
WARNING "Conto inesistente o mancante"
//MESSAGE DIRTY,F_SOTTOCONTO|DIRTY,F_SOTTOC_CLIENTE|DIRTY,F_SOTTOC_FORN
END
NUMBER F_SOTTOCONTO 6
BEGIN
PROMPT 54 3 "Sottoconto "
USE LF_PCON SELECT SOTTOCONTO!=""
FIELD LF_PCON->SOTTOCONTO
KEY 1
INPUT GRUPPO F_GRUPPO
INPUT CONTO F_CONTO
INPUT SOTTOCONTO F_SOTTOCONTO
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Sottoconto" SOTTOCONTO
DISPLAY "Descrizione@50" DESCR
OUTPUT F_GRUPPO GRUPPO
OUTPUT F_CONTO CONTO
OUTPUT F_SOTTOCONTO SOTTOCONTO
OUTPUT F_DESCR_CONTO DESCR
//MESSAGE COPY,F_SOTTOC_FORN //li gestisco da programma senno' fanno casino
//MESSAGE COPY,F_SOTTOC_CLIENTE
FLAGS "R"
CHECKTYPE NORMAL
GROUP 1
VALIDATE AUTOEXIT_FUNC 3 F_GRUPPO F_CONTO F_SOTTOCONTO
WARNING "Conto inesistente"
END
NUMBER F_SOTTOC_CLIENTE 6
BEGIN
PROMPT 54 3 "Cliente "
USE LF_CLIFO
//FIELD LF_CLIFO->CODCF
INPUT TIPOCF "C"
INPUT CODCF F_SOTTOC_CLIENTE
DISPLAY "Codice" CODCF
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
OUTPUT F_SOTTOC_CLIENTE CODCF
OUTPUT F_DESCR_CLIENTE RAGSOC
//MESSAGE COPY,F_SOTTOCONTO
//MESSAGE COPY,F_SOTTOC_FORN
FLAGS "R"
KEY 1
CHECKTYPE NORMAL
GROUP 2
VALIDATE AUTOEXIT_FUNC 3 F_GRUPPO F_CONTO F_SOTTOC_CLIENTE
WARNING "Conto inesistente"
END
NUMBER F_SOTTOC_FORN 6
BEGIN
PROMPT 54 3 "Fornitore "
USE LF_CLIFO
//FIELD LF_CLIFO->CODCF
INPUT TIPOCF "F"
INPUT CODCF F_SOTTOC_FORN
DISPLAY "Codice" CODCF
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
OUTPUT F_SOTTOC_FORN CODCF
OUTPUT F_DESCR_FORN RAGSOC
FLAGS "R"
KEY 1 //serve per l'autopremimento
CHECKTYPE NORMAL
//MESSAGE COPY,F_SOTTOCONTO
//MESSAGE COPY,F_SOTTOC_CLIENTE
GROUP 3
VALIDATE AUTOEXIT_FUNC 3 F_GRUPPO F_CONTO F_SOTTOC_FORN
WARNING "Conto inesistente"
END
STRING F_DESCR_CONTO 50
BEGIN
PROMPT 4 4 "Descrizione "
USE LF_PCON KEY 2
INPUT DESCR F_DESCR_CONTO
DISPLAY "Descrizione@50" DESCR
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Sottoconto" SOTTOCONTO
COPY OUTPUT F_SOTTOCONTO
MESSAGE COPY,F_DESCR_CLIENTE
MESSAGE COPY,F_DESCR_FORN
KEY 1
CHECKTYPE NORMAL
GROUP 1
END
STRING F_DESCR_CLIENTE 50
BEGIN
PROMPT 4 4 "Cliente "
USE LF_CLIFO KEY 2
INPUT TIPOCF "C"
INPUT RAGSOC F_DESCR_CLIENTE
DISPLAY "Ragione Sociale Cliente@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Codice" CODCF
COPY OUTPUT F_SOTTOC_CLIENTE
MESSAGE COPY,F_DESCR_CONTO
MESSAGE COPY,F_DESCR_FORN
KEY 1
CHECKTYPE NORMAL
GROUP 2
END
STRING F_DESCR_FORN 50
BEGIN
PROMPT 4 4 "Fornitore "
USE LF_CLIFO KEY 2
INPUT TIPOCF "F"
INPUT RAGSOC F_DESCR_FORN
DISPLAY "Ragione Sociale Fornitore@50" RAGSOC
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Codice" CODCF
COPY OUTPUT F_SOTTOC_FORN
MESSAGE COPY,F_DESCR_CONTO
MESSAGE COPY,F_DESCR_CLIENTE
KEY 1
CHECKTYPE NORMAL
GROUP 3
END
SPREADSHEET F_SHEET_SALDI
BEGIN
PROMPT 2 6 ""
ITEM "Es."
ITEM "Progr.Mov.Elim.: Dare"
ITEM " Avere"
ITEM " Saldo"
ITEM " Saldo iniziale"
ITEM "Progr.Att.: Dare"
ITEM " Avere"
ITEM " Saldo"
ITEM "Ult.Op.: Data"
ITEM " Numero"
ITEM "Progr.Mov.Prov.: Dare"
ITEM " Avere"
ITEM " Saldo"
END
ENDPAGE
ENDMASK
PAGE "" -1 -1 71 20
NUMBER 101 4
BEGIN
PROMPT 1 1 "Anno esercizio "
FLAGS "R"
END
NUMBER 102 15
BEGIN
PROMPT 1 4 "Progr.Mov.Eliminati: Dare "
FLAGS "R"
PICTURE "."
END
NUMBER 103 15
BEGIN
PROMPT 42 4 "Avere "
FLAGS "R"
PICTURE "."
END
STRING 104 17
BEGIN
PROMPT 60 4 "Saldo "
FLAGS "R"
END
/*
NUMBER 105 15
BEGIN
PROMPT 1 5 "Progr.Attuali: Saldo Iniziale "
FLAGS "R"
END
STRING 105 1
BEGIN
PROMPT 1 5 "Segno "
END
*/
STRING 105 15
BEGIN
PROMPT 1 5 "Saldo Iniziale "
FLAGS "R"
END
NUMBER 106 15
BEGIN
PROMPT 42 5 "Progr.Attuali: Dare "
FLAGS "R"
PICTURE "."
END
NUMBER 107 15
BEGIN
PROMPT 60 5 "Avere "
FLAGS "R"
PICTURE "."
END
STRING 108 17
BEGIN
PROMPT 1 6 "Saldo "
FLAGS "R"
END
DATE 109
BEGIN
PROMPT 1 8 "Ultima data operazione "
FLAGS "R"
END
NUMBER 110 7
BEGIN
PROMPT 1 9 "Ultimo numero operazione "
FLAGS "R"
END
NUMBER 111 15
BEGIN
PROMPT 1 6 "Progr.Mov.Provvisori: Dare "
FLAGS "R"
PICTURE "."
END
NUMBER 112 15
BEGIN
PROMPT 42 6 "Avere "
FLAGS "R"
PICTURE "."
END
STRING 113 17
BEGIN
PROMPT 60 6 "Saldo "
FLAGS "R"
END
BUTTON DLG_OK 9 2
BEGIN
PROMPT -13 -1 ""
END
BUTTON DLG_CANCEL 9 2
BEGIN
PROMPT -23 -1 ""
END
BUTTON DLG_NULL 9 2
BEGIN
PROMPT -33 -1 "Azzera"
MESSAGE RESET,1@
END
ENDPAGE
ENDMASK

68
cg/cglib.h
View File

@ -14,52 +14,66 @@
#include <assoc.h>
#include "conto.h"
TLocalisamfile * get_descr_cf(TLocalisamfile * pconti,
TLocalisamfile * clifo , int g, int c, long s);
//TLocalisamfile * get_descr_cf(TLocalisamfile * pconti,TLocalisamfile * clifo , int g, int c, long s);
class TSaldi_list : public TArray
class TSaldi_list : public TAssoc_array
{
public:
TSaldi_list(int g, int c, int anno);
TRectype& saldi(int i)const { return(TRectype&)this->operator[](i); }
TSaldi_list (int g, int c, int aec, int aep=0);
TRectype* saldi() const;
};
#define Saldo TSaldo
class Saldo
enum tipobil { DataLimite=1, UltimaImmissione };
class TSaldo
{
real _saldo, _saldo_iniziale, _prg_dare, _prg_avere;
int _indbil;
TRectype* _rec;
real _saldo, _saldo_iniziale;
real _prg_dare, _prg_avere, _prg_daresca, _prg_averesca;
int _indbil;
TRectype* _saldo_ep;
int _annoes;
TDate _inizioEs, _fineEs;
TString16 _codcaus;
TDate _datareg;
TDate _datacomp;
TString _provv;
bool _significativo;
bool _movimentato;
bool _movimentato;
bool _significativo;
bool _rec_presente_ec;
bool _rec_presente_ep;
protected:
void InFinEs(int);
void InFinEs(int);
void leggi_mov(long numreg); // Leggi testata
real calcola_saldo_iniziale(int g, int c, long s, int indbil);
public:
bool movimentato() const { return _movimentato==TRUE; }
bool significativo() const { return _significativo==TRUE; }
const int EsePre (const int annocorr);
int annoes () const { return _annoes; }
void set_annoes (int anno) { _annoes = anno; }
void leggi_mov(long);
bool causale_mov(long, const TDate&, const TDate&, TString&);
const char* causale_chiusura_es();
const char* causale_apertura_es();
bool calcola_data_limite(int,int,int,long,const TDate&,const TDate&,int,bool,
const TDate&,const TDate&,const TDate&,bool);
bool calcola_ultima_immissione(int, int, int, int, long, int);
bool movimentato() const { return _movimentato; }
bool significativo() const { return _significativo; }
bool esiste_saldo() const { return _rec_presente_ec || _rec_presente_ep;}
const int EsePre (const int annocorr); // Determina esercizio precedente
int annoes () const { return _annoes; }
void set_annoes (int anno) { _annoes = anno; }
bool causale_mov(long, const TDate&, const TDate&, TString&);
const char* causale_chiusura_es();
const char* causale_apertura_es();
bool ultima_immissione_bilancio(int anno,int g,int c,long s,int indbil);
bool ultima_immissione_verifica(int anno,int g,int c,long s,int indbil);
bool data_limite_bilancio(int,int,int,long,const TDate&,const TDate&,int,bool);
real calcola_saldo_iniziale(int, int, long, int);
bool calcola_clifo(int, int, int, int, int);
TRectype& ricerca_progr_prec(int, int, int, long);
real saldofin_esprec(int,int,int,long);
bool prg_attuali(int,TConto&,real&,real&);
bool prg_mov_eliminati(int,TConto&,real&,real&);
real saldo() const {return _saldo;}
real saldoini() const {return _saldo_iniziale;}
real prgdare() const {return _prg_dare;}
@ -91,7 +105,7 @@ class TSaldo_agg : public TObject
int _anno_es; // anno esercizio
TDate _data_ulmov; // data ultimo movimento
long _num_ulmov; // numero ultimo movimento
TRectype * _rec; // record corrente sui saldi
TRectype * _rec; // record corrente sui saldi
TConto& tconti() { return *(TConto*)_tab_conti.get(); }
public:

613
cg/cglib01.cpp
View File

@ -17,50 +17,91 @@
#include "cglib.h"
const MAXSTR = 128;
static char __tmp [MAXSTR];
static TFixed_string tmp (__tmp, MAXSTR);
HIDDEN TString256 tmp;
TSaldi_list::TSaldi_list(int g, int c, int anno)
// aep e' l'esercizio precedente
TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep)
{
TLocalisamfile cf(LF_SALDI);
TLocalisamfile cf(LF_SALDI, FALSE);
bool force;
TString16 key;
destroy();
cf.setkey(1);
cf.zero();
cf.put(SLD_ANNOES,anno);
cf.put(SLD_GRUPPO,g);
cf.put(SLD_CONTO,c);
TRectype rec(cf.curr());
cf.read(_isgteq);
for ( ;!cf.eof();cf.next())
if (aep)
cf.setkey(2);
else
{
if (cf.curr() > rec) break;
TRectype r(cf.curr());
add(r);
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)
force = FALSE;
else
force = TRUE;
add((const char*) key, r, force);
}
}
Saldo::Saldo()
{
_saldo_iniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_saldo = ZERO;
_annoes = 0;
_indbil = 0;
_rec = new TRectype(LF_SALDI);
TRectype* TSaldi_list::saldi() const
{
TObject* o = ((TAssoc_array*)this)->get();
if (o == NULL)
return (TRectype*)NULL;
else
return (TRectype*)o;
}
Saldo::~Saldo()
{
TSaldo::TSaldo()
{
_saldo_iniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_saldo = ZERO;
_annoes = 0;
_indbil = 0;
_saldo_ep = new TRectype(LF_SALDI);
_movimentato = _significativo = FALSE;
_rec_presente_ec = _rec_presente_ep = FALSE;
}
TSaldo::~TSaldo()
{
delete _saldo_ep;
}
//
// Cerca l'esercizio precedente di EseCorr
// Se EseCorr e' gia' il primo ritorna 0
// senno' ritorna, astutamente, EseCorr - 1
//
const int Saldo::EsePre(const int EseCorr)
const int TSaldo::EsePre(const int EseCorr)
{
TTable ese("ESC");
TString16 first;
@ -74,11 +115,11 @@ const int Saldo::EsePre(const int EseCorr)
if (codtab == first)
return 0;
return EseCorr - 1;
}
real Saldo::saldofin_esprec(int annoes, int g, int c, long s)
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
{
real saldo,pdare,pavere,pdaresca,paveresca;
char flag;
@ -92,79 +133,88 @@ real Saldo::saldofin_esprec(int annoes, int g, int c, long s)
saldo = app.get_real(SLD_SALDO);
pdare = app.get_real(SLD_PDARE);
pavere = app.get_real(SLD_PAVERE);
pdaresca = app.get_real(SLD_PDARE);
paveresca = app.get_real(SLD_PAVERE);
pdaresca = app.get_real(SLD_PDARESCA);
paveresca = app.get_real(SLD_PAVERESCA);
_significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO
|| pdaresca != ZERO || paveresca != ZERO);
_significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO);
if (flag == 'D')
return pdare-pavere+saldo;
return pdare-pavere+saldo+pdaresca-paveresca;
else
return pdare-pavere-saldo;
return pdare-pavere-saldo+pdaresca-paveresca;
}
real Saldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
{
real saldoini, pdaresca, paveresca;
real saldoini, pdaresca, paveresca, pdare, pavere;
char flag;
TLocalisamfile saldi(LF_SALDI, FALSE);
_significativo = TRUE;
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_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,_annoes);
saldi.read();
if (saldi.bad()) saldi.zero();
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);
//pdare = saldi.get_real(SLD_PDARE);
//pavere = saldi.get_real(SLD_PAVERE);
pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA);
_significativo = (saldoini != ZERO || pdaresca != ZERO || paveresca != ZERO);
if (saldoini != ZERO)
if (flag == 'A') saldoini = -saldoini;
if (flag == 'A') saldoini = -saldoini;
if (saldoini == ZERO)
if ( indbil == 1 || indbil == 2 || indbil == 5 )
{
saldoini = saldofin_esprec(_annoes, g, c, s);
flag = 'D'; // Il segno DEVE essere quello del saldo precedente
}
if ( indbil == 1 || indbil == 2 || indbil == 5 )
{
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 pdaresca-paveresca+saldoini;
return pdaresca-paveresca+saldoini;
else
return pdaresca-paveresca-saldoini;
return pdaresca-paveresca-saldoini;
}
const char* Saldo::causale_chiusura_es()
const char* TSaldo::causale_chiusura_es()
{
TConfig conf(CONFIG_DITTA);
tmp = conf.get("CoCaCh");
return __tmp;
return tmp;
}
const char* Saldo::causale_apertura_es()
const char* TSaldo::causale_apertura_es()
{
TConfig conf(CONFIG_DITTA);
tmp = conf.get("CoCaAp");
return __tmp;
return tmp;
}
void Saldo::leggi_mov(long nr)
void TSaldo::leggi_mov(long nr)
{
TLocalisamfile mov(LF_MOV, FALSE);
@ -180,14 +230,15 @@ void Saldo::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)
{
/********************************************
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;
@ -195,83 +246,91 @@ bool Saldo::calcola_data_limite(int annoes, int g, int c, long s, const TDate& d
rmov.zero();
rmov.put(RMV_GRUPPO,g);
if (c != 0)
rmov.put(RMV_CONTO,c);
rmov.put(RMV_CONTO,c);
if (s != 0)
rmov.put(RMV_SOTTOCONTO,s);
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);
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;
//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 ((!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);
}
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;
//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;
if ( (data_rmv < data_inf) || (data_rmv > data_sup) )
continue;
sezione = rmov.get(RMV_SEZIONE);
importo = rmov.get_real(RMV_IMPORTO);
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;
if (importo.is_zero())
continue;
esito = TRUE;
if (sezione == "D") dep += importo;
else dep -= importo;
}
_saldo = dep;
return esito;
}
}
***************************************************/
bool Saldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf,
const TDate& data_sup, int indbil, bool stp_prov)
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)
{
TString16 gcs_corr, gcs_prec;
real importo, dep = ZERO;
int gruppo, conto, annoe;
long sottoconto, num_reg;
TDate data_mov;
char sezione;
bool buono = FALSE;
_saldo_iniziale = ZERO;
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;
gcs_prec = "";
rmov.setkey(2);
rmov.zero();
rmov.put(RMV_GRUPPO,g);
@ -279,9 +338,7 @@ bool Saldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate
rmov.put(RMV_SOTTOCONTO,s);
TRectype rec(rmov.curr());
rmov.read(_isgteq);
for ( ; !rmov.eof(); rmov.next())
for (rmov.read(_isgteq); !rmov.eof(); rmov.next())
{
if (rmov.curr() != rec) break;
@ -290,10 +347,13 @@ bool Saldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate
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);
leggi_mov(num_reg);
if (bilancio == 1)
// Leggo la testata
leggi_mov(num_reg);
if (bilancio == DataLimite)
data_mov = _datacomp;
else
{
@ -303,51 +363,57 @@ bool Saldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate
data_mov = _datacomp;
}
if (data_mov < data_inf || data_mov > data_sup)
continue;
// se la causale del movimento e' uguale a quella di chiusura,
// il movimento non va considerato
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;
//se non e' richiesta stampa mov. provvisori li scarto
if (!stp_prov && _provv.trim().not_empty())
continue;
// "I mov. di puro riferimento (= con importo = 0) vanno scartati"
if (importo == ZERO) continue;
if (_codcaus.not_empty())
if (_codcaus == causale_chiusura_es()) continue;
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(gruppo,conto,sottoconto,indbil);
_saldo = calcola_saldo_iniziale(gruppo,conto,sottoconto,indbil);
}
#ifdef DBG
TString dep1(dep.string());
TString dep1(_saldo.string());
#endif
sezione = rmov.get_char(RMV_SEZIONE);
importo = rmov.get_real(RMV_IMPORTO);
if (importo == ZERO)
continue;
buono = TRUE;
_movimentato = TRUE;
if (sezione == 'D')
dep += importo;
_saldo += importo;
else
dep -= importo;
_saldo -= importo;
}
#ifdef DBG
TString dep2(dep.string());
TString dep2(_saldo.string());
#endif
_saldo = dep;
return buono;
// Se non movimentato vado a vedere il saldo
if (!_movimentato)
_saldo = calcola_saldo_iniziale(g,c,s,indbil);
return _movimentato;
}
bool Saldo::calcola_ultima_immissione(int annoes, int annoesprec, int g, int c,
long s, int indbil)
{
/**************************************************************
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;
@ -366,48 +432,49 @@ long s, int indbil)
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);
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 (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
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;
}
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;
}
}
*****************************************************/
bool Saldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil)
bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil)
{
//Si considerano i saldi e non piu' i movimenti
char sezione;
@ -419,6 +486,8 @@ bool Saldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil)
_saldo_iniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_prg_daresca = ZERO;
_prg_averesca = ZERO;
_saldo = ZERO;
saldi.zero();
@ -427,7 +496,7 @@ bool Saldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil)
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);
@ -439,83 +508,134 @@ bool Saldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil)
_prg_avere = saldi.get_real(SLD_PAVERE);
sezione = saldi.get_char(SLD_FLAGSALINI);
if (_prg_dare == 0 && _prg_avere == 0)
return esito;
if (_prg_dare == ZERO && _prg_avere == ZERO)
return esito;
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
// if (indbil == 3 || indbil == 4)
// return esito;
if (indbil == 1 || indbil == 2 || indbil == 5)
if (_saldo_iniziale == ZERO)
_saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);
if (_saldo_iniziale == ZERO)
_saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);
// i tre valori precedenti vengono utilizzati per la stampa bilancio
// di verifica
esito = TRUE;
_saldo = _saldo_iniziale + _prg_dare - _prg_avere;
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
}
return esito;
}
TRectype& Saldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
bool TSaldo::ultima_immissione_bilancio(int annoes,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;
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;
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);
_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);
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
_rec_presente_ec = esito;
}
if (indbil == 1 || indbil == 2 || indbil == 5)
if (_saldo_iniziale == ZERO)
_saldo_iniziale += saldofin_esprec(annoes,g,c,s);
_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
return esito;
}
TRectype& TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{
TLocalisamfile saldi(LF_SALDI, FALSE);
// TRectype rec(LF_SALDI);
// TRectype rec(LF_SALDI);
const int oldkey = saldi.getkey();
saldi.setkey(1);
saldi.zero();
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.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
if (saldi.read() != NOERR) saldi.zero();
if (saldi.read() == NOERR)
_rec_presente_ep = TRUE;
else
{
saldi.zero();
_rec_presente_ep = FALSE;
}
*_rec = saldi.curr();
*_saldo_ep = saldi.curr();
saldi.setkey(oldkey);
return *_rec;
return *_saldo_ep;
}
//calcolo dei progressivi attuali
bool Saldo::prg_attuali(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
bool TSaldo::prg_attuali(int annoes,TConto& conto,real& prgdare,real& prgavere)
{
real saldoini, pdare, pavere, pdaresca, paveresca;
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);
if (conto.conto() != 0)
saldi.put(SLD_CONTO,c);
if (conto.sottoconto() != 0)
saldi.put(SLD_SOTTOCONTO,s);
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];
flagsalini = saldi.get_char(SLD_FLAGSALINI);
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;
@ -530,33 +650,27 @@ bool Saldo::prg_attuali(int annoes,TConto& conto,int indbil,real& prgdare,real&
return TRUE;
}
bool Saldo::prg_mov_eliminati(int annoes,TConto& conto,int indbil,real& prgdare,real& prgavere)
bool TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prgavere)
{
real saldoini, pdaresca, paveresca;
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,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_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);
if ( (indbil == 1) || (indbil == 2) || (indbil == 5) )
if (saldoini == ZERO)
{
saldoini = saldofin_esprec(annoes,conto.gruppo(),conto.conto(),conto.sottoconto());
if (saldoini > ZERO)
flagsalini = 'D';
else flagsalini = 'A';
}
pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA);
if (flagsalini == 'D')
@ -573,9 +687,10 @@ bool Saldo::prg_mov_eliminati(int annoes,TConto& conto,int indbil,real& prgdare,
return TRUE;
}
TLocalisamfile * get_descr_cf (TLocalisamfile * pconti,
TLocalisamfile * clifo, int g, int c, long s)
{
/************************************
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);
@ -584,7 +699,7 @@ TLocalisamfile * get_descr_cf (TLocalisamfile * pconti,
pconti->read();
if (pconti->good())
return pconti;
return pconti;
TString tipocf = pconti->get(PCN_TMCF);
long codcf = s;
@ -596,11 +711,11 @@ TLocalisamfile * get_descr_cf (TLocalisamfile * pconti,
clifo->read();
if (clifo->good())
return clifo;
return clifo;
return NULL;
}
}
**********************************************/