root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg4600.cpp
guy 6cea04205e Patch level : 2.0 552 
Files correlati     : cg0100a.msk cg2.exe cg3.exe cg4.exe
Ricompilazione Demo : [ ]
Commento            :

EP20110
Cliccando sul menu "Chiusura apertura conti" errore CG4

EP20111
Correggere controllo su numerazione conti da utilizzare, in quanto risulta
che il controllo sia fatto sul 2° e 3° livello ed il primo livello della
riga successiva.

EP20112
(vedi errore EP00002 versione 1.7): Sia che io inserisa una nota credito
abbinando o meno la sua riga ad una scadenza o generando una riga 9999,
al momento del Registra mi da la seguente segnalazione
"Il totale documento in valuta XXX è YYYY D i pagamenti
e le spese ammontano a ZZZZ A per cui il residuo è YYYY."

EP20112
Inserendo un movimento nota credito (dove in causale ho tipo movimento=nota credito),
in testata il campo "descrizione" della condizione di pagamento non deve essere attivo


git-svn-id: svn://10.65.10.50/trunk@11383 c028cbd2-c16b-5b4b-a496-9718f37d4682
2003-08-08 11:08:38 +00:00

2027 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 = F_BILCHG;
short idc = F_BILCHC;
short ids = F_BILCHS;
for (int i = 0; i < 6; 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;
const int gruppo = m.get_int(idg1);
const int conto = m.get_int(idc1);
const long sottoc = m.get_long(ids1);
if ((g == gruppo)&&(c == conto)&&(s == sottoc))
return f.warning_box(FR("Il conto %d.%d.%ld non puo' essere ripetuto!"), gruppo, conto, sottoc);
}
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, "cg");
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 = anno_ch > 0 ? _esc->esercizio(anno_ch).fine() : botime;
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