root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg4600.cpp
guy 8d4438bda8 Giustiziata MainApp 
Corretti errori(ni) causali e prima nota


git-svn-id: svn://10.65.10.50/trunk@824 c028cbd2-c16b-5b4b-a496-9718f37d4682
1995-01-04 15:38:10 +00:00

1329 lines
39 KiB
C++
Executable File
Raw Blame History

// Chiusura/Apertura Conti
#include <mask.h>
#include <printapp.h>
#include <relation.h>
#include <tabutil.h>
#include <utility.h>
#include <config.h>
#include <urldefid.h>
#include "cglib.h"
#include "cg4.h"
#include "cg4600.h"
#include "cg2101.h"
#include <pconti.h>
#include <mov.h>
#include <saldi.h>
#include <rmov.h>
bool mask_datac (TMask_field&, KEY);
bool mask_dataap (TMask_field&, KEY);
bool mask_distinti (TMask_field&, KEY);
#define MAX 200
class CG4600_application : public TApplication
{
friend bool mask_datac (TMask_field&, KEY);
friend bool mask_dataap (TMask_field&, KEY);
friend bool mask_distinti (TMask_field&, KEY);
TTable* _esc, * _reg;
TRelation* _rel;
TMovimentoPN* _pn;
TLocalisamfile* _saldi;
TRectype* _rec;
TLocalisamfile* _mov;
TCursor* _cur;
TSaldo_agg* _sld;
Saldo* _sale;
TConto _tcbilch,_tcproper,_tcbilap,_tcutilp,_tcperdp,_tcutile,_tcperde, _conto_corrente;
real _saldo, _totale_saldo;
int _annoesch, _annoesap;
long _numreg;
TDate _dataregap, _dataregch;
TString _codcausap, _codcausch;
public:
virtual bool create();
virtual bool destroy();
virtual bool menu(MENU_TAG m);
void costi ();
void ricavi();
void attivita();
void passivita();
void rmov_proper (int, long, TDate&, TRectype&, TConto&, real&, bool);
void ultima_registrazione();
void compila_testata(int,TDate&,TString&);
void chiusura_conto_economico();
void chiusura_conto_patrimoniale();
bool set();
// bool epilogo_conti();
CG4600_application() {}
};
bool mask_datac (TMask_field& f, KEY k)
{
TTable TabEs ("ESC");
TTable TabReg("REG");
TString annos (4);
int anno = 0;;
bool ok = TRUE;
if ( (k == K_ENTER) && f.to_check(k) )
{
TabEs.last();
TDate inizio = TabEs.get_date("D0");
TDate fine = TabEs.get_date("D1");
TDate scarico = TabEs.get_date("D2");
TabEs.prev();
TDate iniziop = TabEs.get_date("D0");
TDate finep = TabEs.get_date("D1");
if (f.get() < finep)
{
f.warning_box ("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente");
return FALSE;
}
if (f.get() > fine)
{
f.warning_box ("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso");
return FALSE;
}
if ( scarico.ok() && (f.get() <= scarico) )
{
f.warning_box ("La data di chiusura non puo' essere inferiore o uguale alla data di scarico");
return FALSE;
}
if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso
anno = fine.year();
else if ( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente
anno = finep.year();
TabReg.zero();
annos = format ("%04d", anno);
TabReg.put ("CODTAB", annos);
TRectype r (TabReg.curr());
TabReg.read(_isgteq);
for (; !TabReg.eof(); TabReg.next())
{
if (TabReg.curr() != r) break;
int tiporeg = TabReg.get_int("I0");
if (tiporeg == 5)
{
TDate datast = TabReg.get_date("D3");
if (f.get() < datast.string())
{
ok = FALSE;
break;
}
}
}
if (!ok)
{
f.warning_box("La data di chiusura non puo' essere inferiore alla data ultima stampa bollato");
return FALSE;
}
}
return TRUE;
}
bool mask_dataap (TMask_field& f, KEY k)
{
TTable TabEs ("ESC");
TTable TabReg("REG");
int anno = 0;
TString annos (4);
bool ok = TRUE;
if ( (k == K_ENTER) && f.to_check(k) )
{
TabEs.last();
TDate inizio = TabEs.get_date("D0");
TDate fine = TabEs.get_date("D1");
TDate scarico = TabEs.get_date("D2");
TabEs.prev();
TDate iniziop = TabEs.get_date("D0");
TDate finep = TabEs.get_date("D1");
if (f.get() < inizio)
{
f.warning_box ("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso");
return FALSE;
}
if (f.get() > fine)
{
f.warning_box ("La data di apertura non puo' essere superiore alla data di fine esercizio in corso");
return FALSE;
}
if ( scarico.ok() && (f.get() <= scarico) )
{
f.warning_box ("La data di apertura non puo' essere inferiore o uguale alla data di scarico");
return FALSE;
}
if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso
anno = fine.year();
else if( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente
anno = finep.year();
TabReg.zero();
annos = format ("%04d", anno);
TabReg.put ("CODTAB", annos);
TRectype r (TabReg.curr());
TabReg.read(_isgteq);
for (; !TabReg.eof(); TabReg.next())
{
if (TabReg.curr() != r) break;
int tiporeg = TabReg.get_int("I0");
if (tiporeg == 5)
{
TDate datast = TabReg.get_date("D3");
if (f.get() < datast)
{
ok = FALSE;
break;
}
}
}
if (!ok)
{
f.warning_box("La data di apertura non puo' essere inferiore alla data ultima stampa bollato");
return FALSE;
}
}
return TRUE;
}
bool mask_distinti (TMask_field& f, KEY k)
{
int idg,idc,ids,idg1,idc1,ids1;
if (k == K_ENTER)
{
idg = 108;
idc = 109;
ids = 110;
for (int i = 0; i < 7; i++)
{
int g = f.mask().get_int(idg);
int c = f.mask().get_int(idc);
long s = f.mask().get_long(ids);
idg1 = idg;
idc1 = idc;
ids1 = ids;
for (int j = i+1; j < 7; j++)
{
idg1 = idg1 + 3;
idc1 = idc1 + 3;
ids1 = ids1 + 3;
int gruppo = f.mask().get_int(idg1);
int conto = f.mask().get_int(idc1);
long sottoc = f.mask().get_long(ids1);
if ((g == gruppo)&&(c == conto)&&(s == sottoc))
{
f.warning_box("Nessun sottoconto puo' essere ripetuto!");
return FALSE;
}
}
idg = idg + 3;
idc = idc + 3;
ids = ids + 3;
}
}
return TRUE;
}
bool CG4600_application::create()
{
TApplication::create();
_rel = new TRelation (LF_PCON);
_cur = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1);
_pn = new TMovimentoPN();
_saldi = new TLocalisamfile (LF_SALDI);
_rec = new TRectype(LF_SALDI);
_mov = new TLocalisamfile (LF_MOV);
_esc = new TTable ("ESC");
_reg = new TTable ("REG");
_sld = new TSaldo_agg();
_sale = new Saldo();
dispatch_e_menu (BAR_ITEM(1));
return TRUE;
}
bool CG4600_application::destroy()
{
delete _saldi;
delete _sale;
delete _mov;
delete _esc;
delete _reg;
delete _pn;
delete _rel;
delete _cur;
delete _sld;
delete _rec;
return TApplication::destroy();
}
void CG4600_application::ultima_registrazione()
{
long numregmov;
_mov->setkey(1); //Leggo il numero di registrazione
_mov->last(); //dell'ultimo record di mov, e lo
numregmov = _mov->get_long(MOV_NUMREG); //incremento di uno per ottenere
_numreg = numregmov + 1; //un numero di registrazione
//sicuramente non esistente.
}
bool CG4600_application::set()
{
TTable TabEs ("ESC");
TMask m ("cg4600a");
KEY tasto;
int gbilch, cbilch , gproper, cproper, gbilap, cbilap, gutilp;
int cutilp, gperdp, cperdp, gutile, cutile, gperde, cperde;
long sbilch, sproper, sbilap, sutilp, sperdp, sutile, sperde;
TConfig conf(CONFIG_DITTA);
m.set(F_CHIUSURA, conf.get("CoCaCh"));
m.set(F_APERTURA, conf.get("CoCaAp"));
TabEs.last();
int annoap = TabEs.get_int ("CODTAB");
TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso
TabEs.prev();
int annoch = TabEs.get_int ("CODTAB");
TDate fine = TabEs.get_date("D1"); //data fine es. precedente
m.set(F_ANNO, annoap);
m.set(F_ANNOCH, annoch);
m.set(F_DATAC, fine.string());
m.set(F_DATAAP,inizio.string());
m.set(F_BILCHG, conf.get("CsBiChG"));
m.set(F_BILCHC, conf.get("CsBiChC"));
m.set(F_BILCHS, conf.get("CsBiChS"));
m.set(F_PROPERG, conf.get("CsPrPeG"));
m.set(F_PROPERC, conf.get("CsPrPeC"));
m.set(F_PROPERS, conf.get("CsPrPeS"));
m.set(F_BILAPG, conf.get("CsBiApG"));
m.set(F_BILAPC, conf.get("CsBiApC"));
m.set(F_BILAPS, conf.get("CsBiApS"));
m.set(F_UTILPG, conf.get("CsUeCpG"));
m.set(F_UTILPC, conf.get("CsUeCpC"));
m.set(F_UTILPS, conf.get("CsUeCpS"));
m.set(F_PERDPG, conf.get("CsPeCpG"));
m.set(F_PERDPC, conf.get("CsPeCpC"));
m.set(F_PERDPS, conf.get("CsPeCpS"));
m.set(F_UTILEG, conf.get("CsUeCeG"));
m.set(F_UTILEC, conf.get("CsUeCeC"));
m.set(F_UTILES, conf.get("CsUeCeS"));
m.set(F_PERDEG, conf.get("CsPeCeG"));
m.set(F_PERDEC, conf.get("CsPeCeC"));
m.set(F_PERDES, conf.get("CsPeCeS"));
m.set_handler (F_DATAC, mask_datac);
m.set_handler (F_DATAAP, mask_dataap);
m.set_handler (F_PERDES, mask_distinti);
tasto = m.run();
if (tasto == K_ENTER)
{
_annoesch = m.get_int(F_ANNOCH);
_annoesap = m.get_int(F_ANNO);
_dataregch = m.get (F_DATAC);
_codcausch = m.get (F_CHIUSURA);
_dataregap = m.get (F_DATAAP);
_codcausap = m.get (F_APERTURA);
gbilch = m.get_int (F_BILCHG);
cbilch = m.get_int (F_BILCHC);
sbilch = m.get_long(F_BILCHS);
gproper = m.get_int (F_PROPERG);
cproper = m.get_int (F_PROPERC);
sproper = m.get_long(F_PROPERS);
gbilap = m.get_int (F_BILAPG);
cbilap = m.get_int (F_BILAPC);
sbilap = m.get_long(F_BILAPS);
gutilp = m.get_int (F_UTILPG);
cutilp = m.get_int (F_UTILPC);
sutilp = m.get_long(F_UTILPS);
gperdp = m.get_int (F_PERDPG);
cperdp = m.get_int (F_PERDPC);
sperdp = m.get_long(F_PERDPS);
gutile = m.get_int (F_UTILEG);
cutile = m.get_int (F_UTILEC);
sutile = m.get_long(F_UTILES);
gperde = m.get_int (F_PERDEG);
cperde = m.get_int (F_PERDEC);
sperde = m.get_long(F_PERDES);
_tcbilch.set (gbilch,cbilch,sbilch);
_tcproper.set(gproper,cproper,sproper);
_tcbilap.set (gbilap,cbilap,sbilap);
_tcutilp.set (gutilp,cutilp,sutilp);
_tcperdp.set (gperdp,cperdp,sperdp);
_tcutile.set (gutile,cutile,sutile);
_tcperde.set (gperde,cperde,sperde);
ultima_registrazione();
// anno_ese_precedente();
(*_cur) = 0L;
_sld->set_anno_es(_annoesch);
_sld->set_movprovv(FALSE);
_sld->set_movap(FALSE);
costi ();
_sld->reset(); //Azzera la tabella dei conti dell'oggetto TSaldo_agg
_pn->destroy_rows(); //Azzero l'oggetto pn.
ultima_registrazione();
*_cur = 0l;
ricavi();
_sld->reset();
chiusura_conto_economico();
_totale_saldo = ZERO;
_sld->reset();
_pn->destroy_rows(); //Azzero l'oggetto pn.
ultima_registrazione();
*_cur = 0l;
attivita();
_sld->reset();
_pn->destroy_rows(); //Azzero l'oggetto pn.
ultima_registrazione();
*_cur = 0l;
passivita();
_sld->reset();
chiusura_conto_patrimoniale();
return TRUE;
} //K_ENTER
return FALSE;
}
void CG4600_application::compila_testata(int annoes,TDate& datareg, TString& codcaus)
{
_pn->lfile().zero();
_pn->lfile().put(MOV_ANNOES, annoes); //Viene generato un mov
_pn->lfile().put(MOV_DATAREG, datareg); //quando si incontra il
_pn->lfile().put(MOV_CODCAUS, codcaus); //primo conto con indbil
_pn->lfile().put(MOV_NUMREG, _numreg);
}
void CG4600_application::rmov_proper(int anno,long numrig,TDate& datareg,TRectype& rmov, TConto& tc,real& tot_saldo, bool sezione_opposta)
{
char sez_rmov = ' ';
char sezione = ' ';
real totale = tot_saldo;
rmov.zero();
rmov.put(RMV_ANNOES, anno);
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
rmov.put(RMV_DATAREG, datareg);
rmov.put(RMV_GRUPPO, tc.gruppo());
rmov.put(RMV_CONTO, tc.conto());
rmov.put(RMV_SOTTOCONTO, tc.sottoconto());
if (totale > ZERO)
{
sez_rmov = 'A';
sezione = 'D';
}
else
if (totale < ZERO)
{
sez_rmov = 'D';
sezione = 'A';
totale = -totale;
}
if (sezione_opposta)
{
rmov.put(RMV_SEZIONE, sez_rmov);
_sld->aggiorna(tc,totale,sez_rmov);//Aggiorno anche i saldi con l'oggetto
//TSaldo_agg
}
else
{
rmov.put(RMV_SEZIONE, sezione);
_sld->aggiorna(tc,totale,sezione);//Aggiorno anche i saldi con l'oggetto
//TSaldo_agg
}
rmov.put(RMV_IMPORTO, totale);
}
void CG4600_application::costi()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
Saldo& sale = *_sale;
_totale_saldo = ZERO;
tot_saldo = ZERO;
TRecnotype items_pcon = _cur->items();
for (int i = 0; i < items_pcon; i++, ++(*_cur))
{
int indbil = _cur->curr().get_int(PCN_INDBIL);
int g = _cur->curr().get_int(PCN_GRUPPO);
int c = _cur->curr().get_int(PCN_CONTO);
if (indbil == 3)
{
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 1
compila_mov = FALSE;
}
_saldi->setkey(1);
_saldi->zero();
_saldi->put(SLD_ANNOES, _annoesch);
_saldi->put(SLD_GRUPPO, g);
_saldi->put(SLD_CONTO, c);
(*_rec) = _saldi->curr();
int j = 0;
for (_saldi->read(); ; _saldi->next())
{
TRectype& rmov = _pn->cg(j);
_saldo = ZERO;
if (_saldi->curr() > (*_rec) || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso conto, indicandola
// con una sezione opposta al risultato (della somma).
if (j >= 1)
{
numrig++;
rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
tot_saldo = ZERO;
}
break;
}
numrig++;
s = _saldi->get_long(SLD_SOTTOCONTO);
//sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
_saldo = sale.saldo();
if (_saldo.is_zero()) continue;
if (_saldo > ZERO)
sezione = 'D';
else
if (_saldo < ZERO)
{
sezione = 'A';
_saldo = -_saldo;
}
if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli
{ // importi trovati sui saldi. Quando ho
sez_rmov = 'A'; // finito di leggere i sottoconti, oppure
tot_saldo += _saldo; // quando ho raggiunto un massimo di 200
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta
if (sezione == 'A') // alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (j == MAX || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso sottoconto, indicandola
// con una sezione opposta al risultato (della somma).
// numrig++;
rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
tot_saldo = ZERO;
}
if (!_saldi->eof())
{
rmov.zero();
rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo
rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste
rmov.put(RMV_CONTO, c); //righe servono per mandare a 0
rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la
rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
TConto tc(g,c,s);
_sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg
j++;
}
if (_saldi->eof()) break;
} //for saldi
if (j >= 1)
{
_pn->write();
_sld->registra();
j = 0;
_pn->destroy_rows(); //Azzero l'oggetto pn.
}
} // if (indbil == 3)
} // for pcon
}
void CG4600_application::ricavi()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
Saldo& sale = *_sale;
tot_saldo = ZERO;
TRecnotype items_pcon = _cur->items();
for (int i = 0; i < items_pcon; i++, ++(*_cur))
{
int indbil = _cur->curr().get_int(PCN_INDBIL);
int g = _cur->curr().get_int(PCN_GRUPPO);
int c = _cur->curr().get_int(PCN_CONTO);
if (indbil == 4)
{
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 2
compila_mov = FALSE;
}
_saldi->setkey(1);
_saldi->zero();
_saldi->put(SLD_ANNOES, _annoesch);
_saldi->put(SLD_GRUPPO, g);
_saldi->put(SLD_CONTO, c);
(*_rec) = _saldi->curr();
int j = 0;
for (_saldi->read(); ; _saldi->next())
{
TRectype& rmov = _pn->cg(j);
_saldo = ZERO;
if (_saldi->curr() > (*_rec) || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso conto, indicandola
// con una sezione opposta al risultato (della somma).
if (j >= 1)
{
numrig++;
rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
tot_saldo = ZERO;
}
break;
}
numrig++;
s = _saldi->get_long(SLD_SOTTOCONTO);
//sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
_saldo = sale.saldo();
if (_saldo.is_zero()) continue;
if (_saldo > ZERO)
sezione = 'D';
else
if (_saldo < ZERO)
{
sezione = 'A';
_saldo = -_saldo;
}
if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli
{ // importi trovati sui saldi. Quando ho
sez_rmov = 'A'; // finito di leggere i sottoconti, oppure
tot_saldo += _saldo; // quando ho raggiunto un massimo di 200
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta
if (sezione == 'A') // alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (j == MAX || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso sottoconto, indicandola
// con una sezione opposta al risultato (della somma).
// numrig++;
rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcproper,tot_saldo,FALSE);
tot_saldo = ZERO;
}
if (!_saldi->eof())
{
rmov.zero();
rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo
rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste
rmov.put(RMV_CONTO, c); //righe servono per mandare a 0
rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la
rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
TConto tc(g,c,s);
_sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg
j++;
}
if (_saldi->eof()) break;
} //for saldi
if (j >= 1)
{
_pn->write();
_sld->registra();
j = 0;
_pn->destroy_rows(); //Azzero l'oggetto pn.
}
} // if (indbil == 4)
} // for pcon
}
void CG4600_application::chiusura_conto_economico()
{
if (_totale_saldo > ZERO)
{
int j;
//Compilo la testata per perdite di es. c.economico a Profitti e Perdite
//Chiusura conto economico
j = 0;
ultima_registrazione();
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 3
TRectype& rmov1 = _pn->cg(j);
long numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcproper,_totale_saldo,TRUE);
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperde,_totale_saldo,FALSE);
_pn->write();
_sld->registra();
_sld->reset();
//Compilo la testata per perdite di es. c.patrimon. a Perdita di es. c. econom.
//Chiusura capitale netto
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 4
TRectype& rmov3 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcperde,_totale_saldo,TRUE);
numrig++;
j++;
TRectype& rmov4 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcperdp,_totale_saldo,FALSE);
_pn->write();
_sld->registra();
_sld->reset();
//Compilo la testata per Perdita es. c/to patrimoniale a Bilancio di apertura
//Apertura capitale netto
_sld->set_anno_es(_annoesap);
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesap,_dataregap,_codcausap); //Reg. 10
TRectype& rmov5 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesap,numrig,_dataregap,rmov5,_tcbilap,_totale_saldo,TRUE);
numrig++;
j++;
TRectype& rmov6 = _pn->cg(j);
rmov_proper(_annoesap,numrig,_dataregap,rmov6,_tcperdp,_totale_saldo,FALSE);
_pn->write();
_sld->registra();
_sld->set_anno_es(_annoesch);
}
else
if (_totale_saldo < ZERO)
{
int j;
//Compilo la testata per Profitti e perdite a Utile di es. c.economico
//Chiusura conto economico
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 3
TRectype& rmov1 = _pn->cg(j);
long numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutile,_totale_saldo,FALSE);
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcproper,_totale_saldo,TRUE);
_pn ->write();
_sld->registra();
_sld->reset();
//Compilo la testata per Utile di es. c.economico a Utile di es. c.patrimoniale
//Chiusura capitale netto
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 4
TRectype& rmov3 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcutilp,_totale_saldo,FALSE);
numrig++;
j++;
TRectype& rmov4 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcutile,_totale_saldo,TRUE);
_pn ->write();
_sld->registra();
_sld->reset();
//Compilo la testata per Bilancio di apertura a Utile es. c/to patrimoniale
//Apertura capitale netto
_sld->set_anno_es(_annoesap);
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesap,_dataregap,_codcausap); //Reg. 10
TRectype& rmov5 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesap,numrig,_dataregap,rmov5,_tcbilap,_totale_saldo,TRUE);
numrig++;
j++;
TRectype& rmov6 = _pn->cg(j);
rmov_proper(_annoesap,numrig,_dataregap,rmov6,_tcutilp,_totale_saldo,FALSE);
_pn->write();
_sld->registra();
_sld->set_anno_es(_annoesch);
}
}
void CG4600_application::chiusura_conto_patrimoniale()
{
int j;
long numrig;
if (_totale_saldo > ZERO)
{
//Compilo la testata per Bilancio di chiusura a Perdita di es. c. patrimoniale
//Chiusura conto patrimoniale
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 7
TRectype& rmov1 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutilp,_totale_saldo,FALSE);
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcbilch,_totale_saldo,TRUE);
_pn->write();
_sld->registra();
}
else
if (_totale_saldo < ZERO)
{
//Compilo la testata per Utile di es. c.patrimon. a Bilancio di chiusura
//Chiusura conto patrimoniale
_pn->destroy_rows(); //Azzero l'oggetto pn.
j = 0;
ultima_registrazione();
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 7
TRectype& rmov1 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcbilch,_totale_saldo,TRUE);
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperdp,_totale_saldo,FALSE);
_pn ->write();
_sld->registra();
}
}
void CG4600_application::attivita()
{
bool compila_mov_ch = TRUE;
bool compila_mov_ap = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
Saldo& sale = *_sale;
tot_saldo = ZERO;
TRecnotype items_pcon = _cur->items();
for (int i = 0; i < items_pcon; i++, ++(*_cur))
{
_sld->set_anno_es(_annoesch);
int indbil = _cur->curr().get_int(PCN_INDBIL);
int g = _cur->curr().get_int(PCN_GRUPPO);
int c = _cur->curr().get_int(PCN_CONTO);
if (indbil == 1)
{
if (compila_mov_ch)
{
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 5 Chiusura
compila_mov_ch = FALSE;
}
_saldi->setkey(1);
_saldi->zero();
_saldi->put(SLD_ANNOES, _annoesch);
_saldi->put(SLD_GRUPPO, g);
_saldi->put(SLD_CONTO, c);
TRectype rec (_saldi->curr());
int j = 0;
for (_saldi->read(); ; _saldi->next())
{
TRectype& rmov = _pn->cg(j);
if (_saldi->curr() > rec || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso conto, indicandola
// con una sezione opposta al risultato (della somma).
if (j >= 1)
{
numrig++;
rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
break;
}
numrig++;
s = _saldi->get_long(SLD_SOTTOCONTO);
//sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
_saldo = sale.saldo();
if (_saldo == ZERO) continue;
if (_saldo > ZERO)
sezione = 'D';
else
if (_saldo < ZERO)
{
sezione = 'A';
_saldo = -_saldo;
}
if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli
{ // importi trovati sui saldi. Quando ho
sez_rmov = 'A'; // finito di leggere i sottoconti, oppure
tot_saldo += _saldo; // quando ho raggiunto un massimo di 200
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta
if (sezione == 'A') // alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (j == MAX || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso sottoconto, indicandola
// con una sezione opposta al risultato (della somma).
// numrig++;
rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
if (!_saldi->eof())
{
rmov.zero();
rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo
rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste
rmov.put(RMV_CONTO, c); //righe servono per mandare a 0
rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la
rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
TConto tc(g,c,s);
_sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg
j++;
}
if (_saldi->eof()) break;
} //for saldi
if (j >= 1)
{
_pn->write();
_sld->registra();
_sld->reset();
j = 0;
long items_pn = _pn->cg_items();
_sld->set_anno_es(_annoesap);
if (compila_mov_ap)
{
ultima_registrazione();
compila_testata(_annoesap,_dataregap,_codcausap); //Reg. 8 Apertura
compila_mov_ap = FALSE;
}
for (int i = 0; i < items_pn; i++)
{
char sez_rmov;
TRectype& rmov = _pn->cg(j);
char sezione = rmov.get (RMV_SEZIONE)[0];
int gruppo = rmov.get_int (RMV_GRUPPO);
int conto = rmov.get_int (RMV_CONTO);
long sottoc = rmov.get_long(RMV_SOTTOCONTO);
real importo = rmov.get_real(RMV_IMPORTO);
if (sezione == 'D')
sez_rmov = 'A';
else
if (sezione == 'A')
sez_rmov = 'D';
rmov.put(RMV_ANNOES, _annoesap);
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_DATAREG, _dataregap);
if (i == (items_pn - 1)) //Quando incontro il conto
{
rmov.put(RMV_GRUPPO, _tcbilap.gruppo());
rmov.put(RMV_CONTO, _tcbilap.conto());
rmov.put(RMV_SOTTOCONTO, _tcbilap.sottoconto()); //bilancio di chiusura lo
rmov.put(RMV_SEZIONE, sez_rmov); //sostituisco con quello di
_sld->aggiorna(_tcbilap,importo,sez_rmov); //apertura, non girando l'importo
} //perche' non l'avevo girato
else //precedentemente, mentre per gli altri
{ //conti l'importo deve essere girato,
rmov.put(RMV_SEZIONE, sez_rmov); //perche' erano gia' stati girati
TConto tc(gruppo,conto,sottoc); //precedentemente per fare la chiusura
_sld->aggiorna(tc,importo,sez_rmov);
}
j++;
}
_pn->write();
_sld->registra();
j = 0;
_pn->destroy_rows(); //Azzero l'oggetto pn.
}
} // if (indbil == 1)
} // for pcon
}
void CG4600_application::passivita()
{
bool compila_mov_ch = TRUE;
bool compila_mov_ap = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
Saldo& sale = *_sale;
tot_saldo = ZERO;
TRecnotype items_pcon = _cur->items();
for (int i = 0; i < items_pcon; i++, ++(*_cur))
{
_sld->set_anno_es(_annoesch);
int indbil = _cur->curr().get_int(PCN_INDBIL);
int g = _cur->curr().get_int(PCN_GRUPPO);
int c = _cur->curr().get_int(PCN_CONTO);
if (indbil == 2)
{
if (compila_mov_ch)
{
compila_testata(_annoesch,_dataregch,_codcausch); //Reg. 6 Chiusura
compila_mov_ch = FALSE;
}
_saldi->setkey(1);
_saldi->zero();
_saldi->put(SLD_ANNOES, _annoesch);
_saldi->put(SLD_GRUPPO, g);
_saldi->put(SLD_CONTO, c);
TRectype rec (_saldi->curr());
int j = 0;
for (_saldi->read(); ; _saldi->next())
{
TRectype& rmov = _pn->cg(j);
if (_saldi->curr() > rec || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso conto, indicandola
// con una sezione opposta al risultato (della somma).
if (j >= 1)
{
numrig++;
rmov_proper(_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
break;
}
numrig++;
s = _saldi->get_long(SLD_SOTTOCONTO);
//sale.calcola_ultima_immissione(_annoesch,0,g,c,s,indbil);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil);
_saldo = sale.saldo();
if (_saldo.is_zero()) continue;
if (_saldo > ZERO)
sezione = 'D';
else
if (_saldo < ZERO)
{
sezione = 'A';
_saldo = -_saldo;
}
if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli
{ // importi trovati sui saldi. Quando ho
sez_rmov = 'A'; // finito di leggere i sottoconti, oppure
tot_saldo += _saldo; // quando ho raggiunto un massimo di 200
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta
if (sezione == 'A') // alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (j == MAX || _saldi->eof())
{
// Aggiungo un ulteriore riga di movimento contenente la somma
// di tutti i saldi aventi lo stesso sottoconto, indicandola
// con una sezione opposta al risultato (della somma).
// numrig++;
rmov_proper (_annoesch,numrig,_dataregch,rmov,_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
if (!_saldi->eof())
{
rmov.zero();
rmov.put(RMV_ANNOES, _annoesch); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregch); //per ogni sottoconto che leggo
rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste
rmov.put(RMV_CONTO, c); //righe servono per mandare a 0
rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la
rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
TConto tc(g,c,s);
_sld->aggiorna(tc,_saldo,sez_rmov); //l'oggetto TSaldo_agg
j++;
}
if (_saldi->eof()) break;
} //for saldi
if (j >= 1)
{
_pn->write();
_sld->registra();
_sld->reset();
j = 0;
long items_pn = _pn->cg_items();
_sld->set_anno_es(_annoesap);
if (compila_mov_ap)
{
ultima_registrazione();
compila_testata(_annoesap,_dataregap,_codcausap); //Reg. 9 Apertura
compila_mov_ap = FALSE;
}
for (int i = 0; i < items_pn; i++)
{
char sez_rmov;
TRectype& rmov = _pn->cg(j);
char sezione = rmov.get (RMV_SEZIONE)[0];
int gruppo = rmov.get_int (RMV_GRUPPO);
int conto = rmov.get_int (RMV_CONTO);
long sottoc = rmov.get_long(RMV_SOTTOCONTO);
real importo = rmov.get_real(RMV_IMPORTO);
if (sezione == 'D')
sez_rmov = 'A';
else
if (sezione == 'A')
sez_rmov = 'D';
rmov.put(RMV_ANNOES, _annoesap);
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_DATAREG, _dataregap);
if (i == (items_pn - 1)) //Quando incontro il conto
{
rmov.put(RMV_GRUPPO, _tcbilap.gruppo());
rmov.put(RMV_CONTO, _tcbilap.conto());
rmov.put(RMV_SOTTOCONTO, _tcbilap.sottoconto()); //bilancio di chiusura lo
rmov.put(RMV_SEZIONE, sez_rmov); //sostituisco con quello di
_sld->aggiorna(_tcbilap,importo,sez_rmov); //apertura, non girando l'importo
} //perche' non l'avevo girato
else //precedentemente, mentre per gli altri
{ //conti l'importo deve essere girato,
rmov.put(RMV_SEZIONE, sez_rmov); //perche' erano gia' stati girati
TConto tc(gruppo,conto,sottoc); //precedentemente per fare la chiusura
_sld->aggiorna(tc,importo,sez_rmov);
}
j++;
}
_pn->write();
_sld->registra();
j = 0;
_pn->destroy_rows();
}
} // if (indbil == 2)
} // for pcon
}
bool CG4600_application::menu(MENU_TAG m)
{
if (m == BAR_ITEM(1))
return set();
return FALSE;
}
int /*main */ cg4600 (int argc, char* argv[])
{
CG4600_application main_app;
main_app.run(argc, argv, "Apertura/Chiusura Conti");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink