root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg4600.cpp
guy b629eb591e Patch level : 2.0 450 
Files correlati     : cg4.exe
Ricompilazione Demo : [ ]
Commento            :

CM700617
In fase di apertura conti sul file dei saldi, per i record relativi
all'esercizio che ho aperto, non viene aggiornato il campo NUMULTMOV.
Controllare perché riporta un valore nel campo FLAGSALFIN dello stesso record

CM700621
In fase di chiusura sul file dei saldi non vengono aggiornati i campi
NUMULTMOV e nel campo DATAULMOV viene riportata per errore la data di apertura.


git-svn-id: svn://10.65.10.50/trunk@10995 c028cbd2-c16b-5b4b-a496-9718f37d4682
2003-04-09 08:35:52 +00:00

2029 lines
61 KiB
C++
Executable File
Raw Blame History

// Chiusura/Apertura Conti
#include <applicat.h>
#include <config.h>
#include <mask.h>
#include <progind.h>
#include "cg4.h"
#include "cg4600.h"
#include "cg2101.h"
#include "cglib02.h"
#include <pconti.h>
#include <mov.h>
#include <saldi.h>
#include <rmov.h>
#define MAX 98
class TApertura_chiusura : public TSkeleton_application
{
TRelation* _rel;
TMovimentoPN* _pn;
TCursor* _cur;
TSaldo_agg* _sld;
TSaldo* _sale;
TProgind* _prog;
TConto _tcbilch,_tcproper,_tcbilap,_tcutilp,_tcperdp,_tcutile,_tcperde, _conto_corrente;
TEsercizi_contabili* _esc;
real _saldo, _totale_saldo, _capitale_netto;
int _annoesch, _annoesap;
long _numreg;
TDate _dataregap, _dataregch, _datacompch, _datacompap;
TString _codcausap, _codcausch;
protected:
static bool mask_datac (TMask_field&, KEY);
static bool mask_dataap (TMask_field&, KEY);
static bool mask_distinti (TMask_field&, KEY);
static bool attivo_passivo(TMask_field&, KEY);
static bool costi_ricavi (TMask_field&, KEY);
static bool abilita_anni(TMask& m, KEY k);
bool anni_contigui (int annoch, int annoap);
const bool cerca_esercizio(int anno, TMask_field& f);
long ultima_registrazione();
void compila_testata(int anno,const TDate& datareg,const TString& codcaus,const TDate& datacomp);
void registra_pn();
public:
virtual bool create();
virtual bool destroy();
virtual void main_loop();
void costi ();
void ricavi();
void chiudi_attivita();
void chiudi_passivita();
void chiudi_conti_ordine();
void apri_attivita();
void apri_passivita();
void apri_conti_ordine();
void rmov_proper (int, long, TDate&, TRectype&, TConto&, real&, bool);
void chiusura_conto_economico();
void chiusura_conto_patrimoniale();
void apertura_capitale_netto();
bool set();
TApertura_chiusura() {}
};
TApertura_chiusura& app() { return (TApertura_chiusura&) main_app(); }
bool TApertura_chiusura::abilita_anni(TMask& m, KEY k)
{
if (k == K_SHIFT+K_F12)
{
m.enable(F_ANNOCH);
m.enable(F_ANNO);
}
return TRUE;
}
bool TApertura_chiusura::anni_contigui (int annoch, int annoap)
{
const TEsercizio & chi = _esc->esercizio(annoch);
const TEsercizio & ap = _esc->esercizio(annoap);
const TDate inizio(ap.inizio() - 1L);
const TDate fine(chi.fine());
if (inizio != fine)
return warning_box(TR("I due esercizi indicati non risultano contigui"));
return TRUE;
}
const bool TApertura_chiusura::cerca_esercizio(int anno, TMask_field& f)
{
if (!_esc->exist(anno))
return f.warning_box(TR("Esercizio non presente in tabella esercizi"));
return TRUE;
}
bool TApertura_chiusura::mask_datac(TMask_field& f, KEY k)
{
bool ok = TRUE;
if ( k == K_TAB && f.focusdirty() )
{
TDate data = f.get();
int anno = app()._esc->date2esc(data);
f.mask().set(F_ANNOCH, anno); // Esercizio di chiusura
if (anno == 0)
return f.error_box("Esercizio non presente in tabella esercizi");
}
if ( (k == K_ENTER) && f.to_check(k) )
{
const TDate data = f.get();
const int annoch = f.mask().get_int(F_ANNOCH);
const int annoap = f.mask().get_int(F_ANNO);
int anno = 0;
if (app().cerca_esercizio(annoap,f) && app().cerca_esercizio(annoch,f) &&
app().anni_contigui(annoch,annoap))
{
const TEsercizio & ap = app()._esc->esercizio(annoap);
const TDate inizio = ap.inizio();
const TDate fine = ap.fine();
const TDate scarico = ap.scarico();
const TEsercizio & chi = app()._esc->esercizio(annoch);
const TDate iniziop = chi.inizio();
const TDate finep = chi.fine();
if (data < finep)
{
f.warning_box (TR("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente"));
return FALSE;
}
if (data > fine)
{
f.warning_box (TR("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso"));
return FALSE;
}
if ( scarico.ok() && (data <= scarico) )
{
f.warning_box (TR("La data di chiusura non puo' essere inferiore o uguale alla data di scarico"));
return FALSE;
}
if ( (data >= inizio) && (data <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso
anno = fine.year();
else if ( (data >= iniziop) && (data <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente
anno = finep.year();
}
else
return FALSE;
TRelation reg("REG");
TRectype & tabreg = reg.curr();
TString16 annos;
annos.format("%04d", anno);
tabreg.put("CODTAB", annos);
TCursor cur(&reg, "", 1, &tabreg, &tabreg);
const TRecnotype items = cur.items();
cur.freeze();
for (cur = 0L; cur.pos() < items; ++cur)
{
if (tabreg.get_int("I0") == 5)
{
const TDate datast(tabreg.get_date("D3"));
if (data < datast)
return f.warning_box(TR("La data di apertura non puo' essere inferiore alla data ultima stampa bollato"));
}
}
}
return TRUE;
}
bool TApertura_chiusura::mask_dataap (TMask_field& f, KEY k)
{
bool ok = TRUE;
if ( k == K_TAB && f.focusdirty() )
{
TDate data = f.mask().get_date(F_DATAAP);
int anno = app()._esc->date2esc(data);
f.mask().set(F_ANNO, anno); // Esercizio di apertura
if (anno != 0)
{
const int pred = app()._esc->pred(anno);
if (pred > 0)
{
f.mask().set(F_ANNOCH, pred);
f.mask().set(F_DATAC, app()._esc->esercizio(pred).fine());
}
}
else
return f.error_box(TR("Esercizio non presente in tabella esercizi"));
}
if ( (k == K_ENTER) && f.to_check(k) )
{
const int annoch = f.mask().get_int(F_ANNOCH);
const int annoap = f.mask().get_int(F_ANNO);
const TDate data = f.get();
int anno = 0;
if (app().cerca_esercizio(annoap,f) && app().cerca_esercizio(annoch,f) &&
app().anni_contigui(annoch,annoap))
{
const TEsercizio & ap = app()._esc->esercizio(annoap);
const TDate inizio = ap.inizio();
const TDate fine = ap.fine();
const TDate scarico = ap.scarico();
const TEsercizio & chi = app()._esc->esercizio(annoch);
const TDate iniziop = chi.inizio();
const TDate finep = chi.fine();
if (data < inizio)
{
f.warning_box (TR("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso"));
return FALSE;
}
if (data > fine)
{
f.warning_box (TR("La data di apertura non puo' essere superiore alla data di fine esercizio in corso"));
return FALSE;
}
if ( scarico.ok() && (data <= scarico) )
{
f.warning_box (TR("La data di apertura non puo' essere inferiore o uguale alla data di scarico"));
return FALSE;
}
if ( (data >= inizio) && (data <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso
anno = fine.year();
else if( (data >= iniziop) && (data <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente
anno = finep.year();
}
else
return FALSE;
TRelation reg("REG");
TRectype & tabreg = reg.curr();
TString16 annos;
annos.format("%04d", anno);
tabreg.put("CODTAB", annos);
TCursor cur(&reg, "", 1, &tabreg, &tabreg);
const TRecnotype items = cur.items();
cur.freeze();
for (cur = 0L; cur.pos() < items; ++cur)
{
if (tabreg.get_int("I0") == 5)
{
const TDate datast(tabreg.get_date("D3"));
if (data < datast)
return f.warning_box(TR("La data di apertura non puo' essere inferiore alla data ultima stampa bollato"));
}
}
}
if (k == K_ENTER)
{
int anno = f.mask().get_int(F_ANNO);
if (anno == 0)
return f.warning_box(TR("L'eventuale esercizio di apertura non e' presente sulla tabella esercizi"));
}
return TRUE;
}
bool TApertura_chiusura::mask_distinti (TMask_field& f, KEY k)
{
if (k == K_ENTER)
{
const TMask& m = f.mask();
short idg = 108;
short idc = 109;
short ids = 110;
for (int i = 0; i < 7; i++)
{
const int g = m.get_int(idg);
const int c = m.get_int(idc);
const long s = m.get_long(ids);
short idg1 = idg;
short idc1 = idc;
short ids1 = ids;
for (int j = i+1; j < 7; j++)
{
idg1 += 3;
idc1 += 3;
ids1 += 3;
int gruppo = m.get_int(idg1);
int conto = m.get_int(idc1);
long sottoc = m.get_long(ids1);
if ((g == gruppo)&&(c == conto)&&(s == sottoc))
return f.error_box(TR("Il sottoconto della riga %d e' ripetuto alla riga %d."), i+1, j+1);
}
idg += 3;
idc += 3;
ids += 3;
}
}
return TRUE;
}
bool TApertura_chiusura::attivo_passivo (TMask_field& f, KEY k)
{
if (k == K_ENTER)
{
int g,c;
int id = f.dlg();
if (id == F_UTILPC)
g = f.mask().get_int(F_UTILPG);
else
if (id == F_PERDPC)
g = f.mask().get_int(F_PERDPG);
c = atoi(f.get());
TString16 key;
key.format("%d|%d", g, c);
const TRectype & pcon = cache().get(LF_PCON, key);
if (!pcon.empty())
{
int indbil = pcon.get_int(PCN_INDBIL);
if (indbil != 1 && indbil != 2 && indbil != 5)
return f.warning_box(TR("Indicatore di bilancio del conto %d %d errato: deve essere 1,2 o 5"), g, c);
}
}
return TRUE;
}
bool TApertura_chiusura::costi_ricavi (TMask_field& f, KEY k)
{
if (k == K_ENTER)
{
int g,c;
int id = f.dlg();
if (id == F_UTILEC)
g = f.mask().get_int(F_UTILEG);
else
if (id == F_PERDEC)
g = f.mask().get_int(F_PERDEG);
c = atoi(f.get());
TString16 key;
key.format("%d|%d", g, c);
const TRectype & pcon = cache().get(LF_PCON, key);
if (!pcon.empty())
{
int indbil = pcon.get_int(PCN_INDBIL);
if (indbil != 3 && indbil != 4)
return f.warning_box(TR("Indicatore di bilancio del conto %d %d errato: deve essere 3 o 4"), g, c);
}
}
return TRUE;
}
bool TApertura_chiusura::create()
{
open_files(LF_TABCOM, LF_TAB, LF_SALDI, LF_PCON, LF_MOV, LF_RMOV, LF_RMOVIVA,
LF_PARTITE, LF_SCADENZE, LF_PAGSCA, 0);
_rel = new TRelation (LF_PCON);
_cur = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1);
_pn = new TMovimentoPN();
_sld = new TSaldo_agg();
_sale = new TSaldo();
_esc = new TEsercizi_contabili;
_capitale_netto = ZERO;
return TSkeleton_application::create();
}
bool TApertura_chiusura::destroy()
{
delete _sale;
delete _esc;
delete _pn;
delete _rel;
delete _cur;
delete _sld;
return TApplication::destroy();
}
long TApertura_chiusura::ultima_registrazione()
{
TLocalisamfile mov(LF_MOV);
// Leggo il numero di registrazione dell'ultimo record di mov, e lo
// incremento di uno per ottenere un numero di registrazione sicuramente non esistente.
mov.last();
_numreg = mov.get_long(MOV_NUMREG) + 1;
return _numreg;
}
bool TApertura_chiusura::set()
{
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"));
int anno_ap = _esc->last();
TDate inizio = _esc->esercizio(anno_ap).inizio();
// determina quello precedente
const int anno_ch = _esc->pred(anno_ap);
const TDate fine = _esc->esercizio(anno_ch).fine(); //data fine es. precedente
if (anno_ap == anno_ch)
{
anno_ap = 0;
inizio = botime;
}
m.set(F_ANNO, anno_ap);
m.set(F_ANNOCH, anno_ch);
m.set(F_DATAC, fine);
m.set(F_DATAAP, inizio);
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);
m.set_handler (F_UTILPC, attivo_passivo);
m.set_handler (F_PERDPC, attivo_passivo);
m.set_handler (F_UTILEC, costi_ricavi);
m.set_handler (F_PERDEC, costi_ricavi);
m.set_handler (abilita_anni);
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);
if (_esc->exist(_annoesch))
_datacompch = _esc->esercizio(_annoesch).fine();
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);
long cicli = (_cur->items() * 8) + 4;
_prog = new TProgind(cicli,TR("Chiusura/Apertura conti in corso... Prego attendere"),FALSE);
_numreg = 0;
(*_cur) = 0L;
_sld->set_anno_es(_annoesch);
_sld->set_movprovv(FALSE);
_sld->set_tipo_saldo(chiusura);
_sld->set_movimentato(TRUE);
costi ();
*_cur = 0l;
ricavi();
chiusura_conto_economico();
_totale_saldo = ZERO;
*_cur = 0l;
chiudi_attivita();
*_cur = 0l;
chiudi_passivita();
*_cur = 0l;
chiudi_conti_ordine();
chiusura_conto_patrimoniale();
_totale_saldo = ZERO;
_sld->set_anno_es(_annoesap);
_sld->set_tipo_saldo(apertura);
_sld->set_movimentato(TRUE);
*_cur = 0l;
apri_attivita();
*_cur = 0l;
apri_passivita();
*_cur = 0l;
apri_conti_ordine();
apertura_capitale_netto();
delete _prog;
message_box(TR("Apertura/chiusura conti completata"));
} //K_ENTER
return FALSE;
}
void TApertura_chiusura::compila_testata(int annoes,const TDate& datareg,const TString& codcaus,const TDate& datacomp)
{
_numreg = ultima_registrazione();
_pn->curr().zero();
_pn->curr().put(MOV_ANNOES, annoes); //Viene generato un movimento
_pn->curr().put(MOV_DATAREG, datareg); //a rottura di conto
_pn->curr().put(MOV_CODCAUS, codcaus);
_pn->curr().put(MOV_NUMREG, _numreg);
_pn->curr().put(MOV_DATACOMP, datacomp);
}
void TApertura_chiusura::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,TImporto(sez_rmov,totale)); //Aggiorno anche i saldi con
// l'oggetto TSaldo_agg
}
else
{
rmov.put(RMV_SEZIONE, sezione);
_sld->aggiorna(tc,TImporto(sezione,totale)); //Aggiorno anche i saldi con
//l'oggetto TSaldo_agg
}
rmov.put(RMV_IMPORTO, totale);
}
void TApertura_chiusura::registra_pn()
{
_pn->write();
_pn->destroy_rows(_numreg); //Azzero l'oggetto pn.
_sld->set_num_ulmov(_numreg);
_sld->set_data_ulmov(_pn->curr().get_date(MOV_DATAREG));
_sld->registra();
_sld->reset();
}
void TApertura_chiusura::costi()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
_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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 3)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec(saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(); ; saldi.next())
{
_saldo = ZERO;
if (saldi.eof() || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 1 Chiusura Costi
compila_mov = FALSE;
}
s = saldi.get_long(SLD_SOTTOCONTO);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
_saldo = sale.saldo();
if (_saldo.is_zero())
continue;
numrig++;
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).
if (tot_saldo != ZERO)
rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 1 Chiusura Costi
compila_mov = FALSE;
tot_saldo = ZERO;
}
if (_saldo >= ZERO)
sezione = 'D';
else
{
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 99
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
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);
rmov.put(RMV_TIPOC, tmcf);
_tcproper.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 3)
} // for pcon
}
void TApertura_chiusura::ricavi()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 4)
{
compila_mov = TRUE;
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec(saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(); ; saldi.next())
{
_saldo = ZERO;
if (saldi.eof() || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 2 Chiusura Ricavi
compila_mov = FALSE;
}
//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, 1);
_saldo = sale.saldo();
if (_saldo.is_zero()) continue;
numrig++;
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++;
if (tot_saldo != ZERO)
rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcproper,tot_saldo,FALSE);
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 2 Chiusura Ricavi
compila_mov = FALSE;
tot_saldo = ZERO;
}
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 99
_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 (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
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);
rmov.put(RMV_TIPOC, tmcf);
_tcproper.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 4)
} // for pcon
}
void TApertura_chiusura::chiusura_conto_economico()
{
_capitale_netto = _totale_saldo; //Mi serve per fare la riapertura del capitale netto
if (_totale_saldo.is_zero())
return;
if (_totale_saldo > ZERO)
{
int j;
//Compilo la testata per perdite di es. c.economico a Profitti e Perdite
//Chiusura conto economico
j = 0;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 3 Chiusura Conto Economico
TRectype& rmov1 = _pn->cg(j);
long numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcproper,_totale_saldo,TRUE);
_tcperde.put(rmov1, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperde,_totale_saldo,FALSE);
_tcproper.put(rmov2, TRUE); // Contropartita
registra_pn();
//Compilo la testata per perdite di es. c.patrimon. a Perdita di es. c. econom.
//Chiusura capitale netto
j = 0;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 4 Chiusura Capitale netto
TRectype& rmov3 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcperde,_totale_saldo,TRUE);
_tcperdp.put(rmov3, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov4 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcperdp,_totale_saldo,FALSE);
_tcperde.put(rmov4, TRUE); // Contropartita
registra_pn();
}
else
{
int j;
//Compilo la testata per Profitti e perdite a Utile di es. c.economico
//Chiusura conto economico
j = 0;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 3 Chiusura Conto Economico
TRectype& rmov1 = _pn->cg(j);
long numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutile,_totale_saldo,FALSE);
_tcproper.put(rmov1, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcproper,_totale_saldo,TRUE);
_tcutile.put(rmov2, TRUE); // Contropartita
registra_pn();
//Compilo la testata per Utile di es. c.economico a Utile di es. c.patrimoniale
//Chiusura capitale netto
j = 0;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 4 Chiusura Capitale netto
TRectype& rmov3 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov3,_tcutilp,_totale_saldo,FALSE);
_tcutile.put(rmov3, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov4 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov4,_tcutile,_totale_saldo,TRUE);
_tcutilp.put(rmov4, TRUE); // Contropartita
registra_pn();
}
}
void TApertura_chiusura::chiudi_attivita()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 1)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec(saldi.curr());
j = 0;
numrig = 0;
for (int err = saldi.read(_isgteq); ; saldi.next())
{
if (saldi.eof() || err != NOERR || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita'
compila_mov = FALSE;
}
s = saldi.get_long(SLD_SOTTOCONTO);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
_saldo = sale.saldo();
const int dbkey = saldi.getkey();
saldi.setkey(1);
if (_saldo == ZERO) continue; // *** TBC qui fa ciclo infinito
numrig++;
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++;
if (tot_saldo != ZERO)
rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita'
compila_mov = FALSE;
tot_saldo = ZERO;
}
if (_saldo >= ZERO)
sezione = 'D';
else
{
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 99
_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 (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
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);
rmov.put(RMV_TIPOC, tmcf);
_tcbilch.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 1)
} // for pcon
}
void TApertura_chiusura::chiudi_passivita()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 2)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec (saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(); ; saldi.next())
{
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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 6 Chiusura Passivita'
compila_mov = FALSE;
}
//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, 1);
_saldo = sale.saldo();
if (_saldo.is_zero()) continue;
numrig++;
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++;
if (tot_saldo != ZERO)
rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 6 Chiusura Passivita'
compila_mov = FALSE;
tot_saldo = ZERO;
}
if (_saldo >= ZERO)
sezione = 'D';
else
{
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 99
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
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);
rmov.put(RMV_TIPOC, tmcf);
_tcbilch.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 2)
} // for pcon
}
void TApertura_chiusura::chiudi_conti_ordine()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 5)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec(saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(_isgteq); ; saldi.next())
{
if (saldi.eof() || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch);
compila_mov = FALSE;
}
s = saldi.get_long(SLD_SOTTOCONTO);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
_saldo = sale.saldo();
const int dbkey = saldi.getkey();
saldi.setkey(1);
if (_saldo == ZERO) continue;
numrig++;
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).
if (tot_saldo != ZERO)
rmov_proper (_annoesch,numrig,_dataregch,_pn->cg(j),_tcbilch,tot_saldo,FALSE); //Chiusura
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 5 Chiusura Attivita'
compila_mov = FALSE;
tot_saldo = ZERO;
}
if (_saldo >= ZERO)
sezione = 'D';
else
{
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 99
_totale_saldo += _saldo;
} // righe di movimento, genero un' altra
else // riga con importo di sezione opposta alla somma, mandando a zero
{ // il saldo di quel movimento.
sez_rmov = 'D';
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
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);
rmov.put(RMV_TIPOC, tmcf);
_tcbilch.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sez_rmov,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 1)
} // for pcon
}
void TApertura_chiusura::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
j = 0;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 7 Chiusura Conto Patrimoniale
TRectype& rmov1 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcutilp,_totale_saldo,FALSE);
_tcbilch.put(rmov1, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcbilch,_totale_saldo,TRUE);
_tcutilp.put(rmov2, TRUE); // Contropartita
registra_pn();
}
else
if (_totale_saldo < ZERO)
{
//Compilo la testata per Utile di es. c.patrimon. a Bilancio di chiusura
//Chiusura conto patrimoniale
j = 0;
compila_testata(_annoesch,_dataregch,_codcausch,_datacompch); //Reg. 7 Chiusura Conto Patrimoniale
TRectype& rmov1 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesch,numrig,_dataregch,rmov1,_tcbilch,_totale_saldo,TRUE);
_tcperdp.put(rmov1, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesch,numrig,_dataregch,rmov2,_tcperdp,_totale_saldo,FALSE);
_tcbilch.put(rmov2, TRUE); // Contropartita
registra_pn();
}
}
void TApertura_chiusura::apri_attivita()
{
bool compila_mov = TRUE;
long s;
char sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 1)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec (saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(); ; saldi.next())
{
if (saldi.eof() || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
compila_mov = FALSE;
}
//numrig++;
s = saldi.get_long(SLD_SOTTOCONTO);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
_saldo = sale.saldo();
if (_saldo == ZERO) continue;
numrig++;
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).
if (tot_saldo != ZERO)
rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Chiusura
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
compila_mov = FALSE;
tot_saldo = ZERO;
}
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
tot_saldo += _saldo; // quando ho raggiunto un massimo di 99
_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.
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
rmov.zero();
rmov.put(RMV_ANNOES, _annoesap); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregap); //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, sezione); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
rmov.put(RMV_TIPOC, tmcf);
_tcbilap.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sezione,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 1)
} // for pcon
}
void TApertura_chiusura::apri_passivita()
{
bool compila_mov = TRUE;
long s;
char sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 2)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec(saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(); ; saldi.next())
{
if (saldi.eof() || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 9 Apertura Passivita'
compila_mov = FALSE;
}
//numrig++;
s = saldi.get_long(SLD_SOTTOCONTO);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
_saldo = sale.saldo();
if (_saldo.is_zero()) continue;
numrig++;
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).
if (tot_saldo != ZERO)
rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 9 Apertura Passivita'
compila_mov = FALSE;
tot_saldo = ZERO;
}
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
tot_saldo += _saldo; // finito di leggere i sottoconti, oppure
_totale_saldo += _saldo; // quando ho raggiunto un massimo di 99
} // 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.
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
rmov.zero();
rmov.put(RMV_ANNOES, _annoesap); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregap); //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, sezione); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
rmov.put(RMV_TIPOC, tmcf);
_tcbilap.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sezione,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 2)
} // for pcon
}
void TApertura_chiusura::apri_conti_ordine()
{
bool compila_mov = TRUE;
long s;
char sezione = ' ';
real tot_saldo;
long numrig = 0;
TSaldo& sale = *_sale;
int j = 0;
TLocalisamfile saldi(LF_SALDI);
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);
TString tmcf = _cur->curr().get (PCN_TMCF);
_prog->addstatus(1);
if (indbil == 5)
{
compila_mov = TRUE;
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES, _annoesch);
saldi.put(SLD_GRUPPO, g);
saldi.put(SLD_CONTO, c);
saldi.put(SLD_FLSCA, FALSE);
const TRectype rec(saldi.curr());
j = 0;
numrig = 0;
for (saldi.read(); ; saldi.next())
{
if (saldi.eof() || (saldi.curr() != rec))
{
// 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++;
if (tot_saldo != ZERO)
rmov_proper(_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Apertura
tot_saldo = ZERO;
}
break;
}
if (compila_mov)
{
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
compila_mov = FALSE;
}
//numrig++;
s = saldi.get_long(SLD_SOTTOCONTO);
sale.ultima_immissione_bilancio(_annoesch,g,c,s,indbil, 1);
_saldo = sale.saldo();
if (_saldo == ZERO) continue;
numrig++;
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).
if (tot_saldo != ZERO)
rmov_proper (_annoesap,numrig,_dataregap,_pn->cg(j),_tcbilap,tot_saldo,TRUE); //Chiusura
registra_pn();
j = 0;
numrig = 1;
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 8 Apertura Attivita'
compila_mov = FALSE;
tot_saldo = ZERO;
}
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
tot_saldo += _saldo; // quando ho raggiunto un massimo di 99
_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.
tot_saldo -= _saldo;
_totale_saldo -= _saldo;
}
if (!saldi.eof())
{
TRectype& rmov = _pn->cg(j);
rmov.zero();
rmov.put(RMV_ANNOES, _annoesap); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _dataregap); //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, sezione); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, _saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
rmov.put(RMV_TIPOC, tmcf);
_tcbilap.put(rmov, TRUE); // Contropartita
TBill tc(g,c,s);
_sld->aggiorna(tc,TImporto(sezione,_saldo)); //l'oggetto TSaldo_agg
j++;
}
if (saldi.eof()) break;
} //for saldi
if (j >= 1)
{
registra_pn();
j = 0;
}
} // if (indbil == 1)
} // for pcon
}
void TApertura_chiusura::apertura_capitale_netto()
{
int numrig;
if (_capitale_netto > ZERO)
{
//Compilo la testata per Perdita es. c/to patrimoniale a Bilancio di apertura
//Apertura capitale netto
int j = 0;
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 10 Apertura Capitale netto
TRectype& rmov1 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcbilap,_capitale_netto,TRUE);
_tcperdp.put(rmov1, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcperdp,_capitale_netto,FALSE);
_tcbilap.put(rmov2, TRUE); // Contropartita
registra_pn();
}
else
if (_capitale_netto < ZERO)
{
//Compilo la testata per Bilancio di apertura a Utile es. c/to patrimoniale
//Apertura capitale netto
int j = 0;
compila_testata(_annoesap,_dataregap,_codcausap,_dataregap); //Reg. 10 Apertura Capitale netto
TRectype& rmov1 = _pn->cg(j);
numrig = 1;
rmov_proper(_annoesap,numrig,_dataregap,rmov1,_tcbilap,_capitale_netto,TRUE);
_tcutilp.put(rmov1, TRUE); // Contropartita
numrig++;
j++;
TRectype& rmov2 = _pn->cg(j);
rmov_proper(_annoesap,numrig,_dataregap,rmov2,_tcutilp,_capitale_netto,FALSE);
_tcbilap.put(rmov2, TRUE); // Contropartita
registra_pn();
}
}
void TApertura_chiusura::main_loop()
{
set();
}
int cg4600 (int argc, char* argv[])
{
TApertura_chiusura main_app;
main_app.run(argc, argv, TR("Apertura/Chiusura Conti"));
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink