root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg4600.cpp
alex 16f87d79e6 Aggiornato il programma di ricalcolo sadli/rinumerazione movimenti 
(cg4100.cpp).


git-svn-id: svn://10.65.10.50/trunk@48 c028cbd2-c16b-5b4b-a496-9718f37d4682
1994-08-22 11:18:48 +00:00

716 lines
19 KiB
C++
Executable File
Raw Blame History

// Chiusura/Apertura Conti
#include <config.h>
#include <mask.h>
#include <printapp.h>
#include <relation.h>
#include <tabutil.h>
#include <urldefid.h>
#include <utility.h>
#include "cg4.h"
#include "cg4600.h"
#include "cg2101.h"
#include "cglib.h"
#include <pconti.h>
#include <mov.h>
#include <saldi.h>
#include <rmov.h>
bool mask_datac (TMask_field&, KEY);
bool mask_dataap (TMask_field&, KEY);
bool mask_distinti (TMask_field&, KEY);
#define MAX 200
class CG4600_application : public TApplication
{
friend bool mask_datac (TMask_field&, KEY);
friend bool mask_dataap (TMask_field&, KEY);
friend bool mask_distinti (TMask_field&, KEY);
TTable* _esc, * _reg;
TRelation* _rel;
TMovimentoPN* _pn;
TLocalisamfile* _saldi;
TLocalisamfile* _mov;
TCursor* _cur;
TSaldo_agg* _sld;
Saldo _sale;
int _annoes_msk;
long _sproper, _numreg;
TDate _datareg;
TString _codcaus, _annoeseprec;
int _gproper, _cproper;
public:
virtual bool create();
virtual bool destroy();
virtual bool menu(MENU_TAG m);
void costi ();
void ricavi();
void record_rmov_proper (long, TRectype&, real&);
void ultima_registrazione();
void anno_ese_precedente();
bool set();
// bool epilogo_conti();
CG4600_application() {}
};
HIDDEN CG4600_application* app() { return (CG4600_application *) MainApp(); }
bool mask_datac (TMask_field& f, KEY k)
{
TTable TabEs ("ESC");
TTable TabReg("REG");
TString annos (4);
int anno = 0;;
bool ok = TRUE;
if ( (k == K_ENTER) && f.to_check(k) )
{
TabEs.last();
TDate inizio = TabEs.get_date("D0");
TDate fine = TabEs.get_date("D1");
TDate scarico = TabEs.get_date("D2");
TabEs.prev();
TDate iniziop = TabEs.get_date("D0");
TDate finep = TabEs.get_date("D1");
if (f.get() < finep)
{
f.warning_box ("La data di chiusura non puo' essere inferiore alla data di fine esercizio precedente");
return FALSE;
}
if (f.get() > fine)
{
f.warning_box ("La data di chiusura non puo' essere superiore alla data di fine esercizio in corso");
return FALSE;
}
if ( scarico.ok() && (f.get() <= scarico) )
{
f.warning_box ("La data di chiusura non puo' essere inferiore o uguale alla data di scarico");
return FALSE;
}
if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di chiusura e' cioe' relativa all'esercizio in corso
anno = fine.year();
else if ( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di chiusura e' cioe' relativa all'esercizio precedente
anno = finep.year();
TabReg.zero();
annos = format ("%04d", anno);
TabReg.put ("CODTAB", annos);
TRectype r (TabReg.curr());
TabReg.read(_isgteq);
for (; !TabReg.eof(); TabReg.next())
{
if (TabReg.curr() != r) break;
int tiporeg = TabReg.get_int("I0");
if (tiporeg == 5)
{
TDate datast = TabReg.get_date("D3");
if (f.get() < datast.string())
{
ok = FALSE;
break;
}
}
}
if (!ok)
{
f.warning_box("La data di chiusura non puo' essere inferiore alla data ultima stampa bollato");
return FALSE;
}
}
return TRUE;
}
bool mask_dataap (TMask_field& f, KEY k)
{
bool ok = TRUE;
if ( (k == K_ENTER) && f.to_check(k) )
{
TTable TabEs ("ESC");
TTable TabReg("REG");
int anno = 0;
TabEs.last();
TDate inizio = TabEs.get_date("D0");
TDate fine = TabEs.get_date("D1");
TDate scarico = TabEs.get_date("D2");
TabEs.prev();
TDate iniziop = TabEs.get_date("D0");
TDate finep = TabEs.get_date("D1");
if (f.get() < inizio)
return f.error_box ("La data di apertura non puo' essere inferiore alla data di inizio esercizio in corso");
if (f.get() > fine)
return f.error_box ("La data di apertura non puo' essere superiore alla data di fine esercizio in corso");
if ( scarico.ok() && (f.get() <= scarico) )
return f.error_box ("La data di apertura non puo' essere inferiore o uguale alla data di scarico");
if ( (f.get() >= inizio) && (f.get() <= fine) ) //la data di apertura e' cioe' relativa all'esercizio in corso
anno = fine.year();
else if( (f.get() >= iniziop) && (f.get() <= finep) ) //la data di apertura e' cioe' relativa all'esercizio precedente
anno = finep.year();
TabReg.zero();
TString16 annos(format ("%04d", anno));
TabReg.put ("CODTAB", annos);
TRectype r (TabReg.curr());
TabReg.read(_isgteq);
for (; !TabReg.eof(); TabReg.next())
{
if (TabReg.curr() != r) break;
int tiporeg = TabReg.get_int("I0");
if (tiporeg == 5)
{
TDate datast = TabReg.get_date("D3");
if (f.get() < datast)
{
ok = FALSE;
break;
}
}
}
if (!ok)
return f.error_box("La data di apertura non puo' essere inferiore alla data ultima stampa bollato");
}
return TRUE;
}
bool mask_distinti (TMask_field& f, KEY k)
{
int idg,idc,ids,idg1,idc1,ids1;
if (k == K_ENTER)
{
idg = 108;
idc = 109;
ids = 110;
for (int i = 0; i < 7; i++)
{
int g = f.mask().get_int(idg);
int c = f.mask().get_int(idc);
long s = f.mask().get_long(ids);
idg1 = idg;
idc1 = idc;
ids1 = ids;
for (int j = i+1; j < 7; j++)
{
idg1 = idg1 + 3;
idc1 = idc1 + 3;
ids1 = ids1 + 3;
int gruppo = f.mask().get_int(idg1);
int conto = f.mask().get_int(idc1);
long sottoc = f.mask().get_long(ids1);
if ((g == gruppo)&&(c == conto)&&(s == sottoc))
{
f.warning_box("Nessun sottoconto puo' essere ripetuto!");
return FALSE;
}
}
idg = idg + 3;
idc = idc + 3;
ids = ids + 3;
}
}
return TRUE;
}
/******
TConto conto (chg, chc, chs);
if ( app()->gia_inserito(conto) )
{
f.warning_box("Nessun sottoconto puo' essere ripetuto!");
return FALSE;
}
}
}
return TRUE;
}
*******/
bool CG4600_application::create()
{
TApplication::create();
_rel = new TRelation (LF_PCON);
_cur = new TCursor(_rel,"((GRUPPO!=\"\")&&(CONTO!=\"\")&&(SOTTOCONTO==\"\"))",1);
_pn = new TMovimentoPN();
_saldi = new TLocalisamfile (LF_SALDI);
_mov = new TLocalisamfile (LF_MOV);
_esc = new TTable ("ESC");
_reg = new TTable ("REG");
_sld = new TSaldo_agg();
dispatch_e_menu (BAR_ITEM(1));
return TRUE;
}
bool CG4600_application::destroy()
{
delete _saldi;
delete _mov;
delete _esc;
delete _reg;
delete _pn;
delete _rel;
delete _cur;
delete _sld;
return TApplication::destroy();
}
void CG4600_application::anno_ese_precedente()
{
TTable tabesc ("ESC");
TString16 chiave; chiave << _annoes_msk;
tabesc.zero();
tabesc.put("CODTAB", chiave);
const int err = tabesc.read();
if (err == NOERR)
{
tabesc.prev();
_annoeseprec = tabesc.get("CODTAB");
}
else
_annoeseprec = 0;
}
void CG4600_application::ultima_registrazione()
{
long numregmov;
_mov->setkey(1); //Leggo il numero di registrazione
_mov->last(); //dell'ultimo record di mov, e lo
numregmov = _mov->get_long(MOV_NUMREG); //incremento di uno per ottenere
_numreg = numregmov + 1; //un numero di registrazione
//sicuramente non esistente.
}
bool CG4600_application::set()
{
TTable TabEs ("ESC");
// TLocalisamfile saldi (LF_SALDI);
TMask m ("cg4600a");
KEY tasto;
TConfig conf(CONFIG_DITTA);
m.set(F_CHIUSURA, conf.get("CoCaCh"));
m.set(F_APERTURA, conf.get("CoCaAp"));
TabEs.last();
int anno = TabEs.get_int ("CODTAB");
TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso
TabEs.prev();
TDate fine = TabEs.get_date("D1"); //data fine es. precedente
m.set(F_ANNO, anno);
m.set(F_DATAC, fine.string());
m.set(F_DATAAP,inizio.string());
m.set(F_BILCHG, conf.get("CsBiChG"));
m.set(F_BILCHC, conf.get("CsBiChC"));
m.set(F_BILCHS, conf.get("CsBiChS"));
m.set(F_PROPERG, conf.get("CsPrPeG"));
m.set(F_PROPERC, conf.get("CsPrPeC"));
m.set(F_PROPERS, conf.get("CsPrPeS"));
m.set(F_BILAPG, conf.get("CsBiApG"));
m.set(F_BILAPC, conf.get("CsBiApC"));
m.set(F_BILAPS, conf.get("CsBiApS"));
m.set(F_UTILPG, conf.get("CsUeCpG"));
m.set(F_UTILPC, conf.get("CsUeCpC"));
m.set(F_UTILPS, conf.get("CsUeCpS"));
m.set(F_PERDPG, conf.get("CsPeCpG"));
m.set(F_PERDPC, conf.get("CsPeCpC"));
m.set(F_PERDPS, conf.get("CsPeCpS"));
m.set(F_UTILEG, conf.get("CsUeCeG"));
m.set(F_UTILEC, conf.get("CsUeCeC"));
m.set(F_UTILES, conf.get("CsUeCeS"));
m.set(F_PERDEG, conf.get("CsPeCeG"));
m.set(F_PERDEC, conf.get("CsPeCeC"));
m.set(F_PERDES, conf.get("CsPeCeS"));
m.set_handler (F_DATAC, mask_datac);
m.set_handler (F_DATAAP, mask_dataap);
m.set_handler (F_PERDES, mask_distinti);
tasto = m.run();
if (tasto == K_ENTER)
{
_annoes_msk = m.get_int (F_ANNO);
_datareg = m.get (F_DATAC);
_codcaus = m.get (F_CHIUSURA);
_gproper = m.get_int (F_PROPERG);
_cproper = m.get_int (F_PROPERC);
_sproper = m.get_long(F_PROPERS);
ultima_registrazione();
anno_ese_precedente();
*_cur = 0l;
costi ();
// _pn->destroy_rows(); //Azzero l'oggetto pn.
// ultima_registrazione();
// *_cur = 0l;
// ricavi();
return TRUE;
} //K_ENTER
return FALSE;
}
void CG4600_application::record_rmov_proper(long numrig,TRectype& rmov,real& tot_saldo)
{
char sez_rmov = ' ';
rmov.zero();
rmov.put(RMV_ANNOES, _annoes_msk);
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
rmov.put(RMV_DATAREG, _datareg);
rmov.put(RMV_GRUPPO, _gproper);
rmov.put(RMV_CONTO, _cproper);
rmov.put(RMV_SOTTOCONTO, _sproper);
if (tot_saldo.sign() > 0)
sez_rmov = 'A';
else
if (tot_saldo.sign() < 0)
{
sez_rmov = 'D';
tot_saldo = -tot_saldo;
}
rmov.put(RMV_SEZIONE, sez_rmov);
rmov.put(RMV_IMPORTO, tot_saldo);
}
void CG4600_application::costi()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ', sezione = ' ';
real tot_saldo;
long numrig = 0;
TRecnotype items_pcon = _cur->items();
for (int i = 0; i < items_pcon; i++, ++(*_cur))
{
int indbil = _cur->curr().get_int(PCN_INDBIL);
int g = _cur->curr().get_int(PCN_GRUPPO);
int c = _cur->curr().get_int(PCN_CONTO);
if (indbil == 3)
{
if (compila_mov)
{
_pn->lfile()->zero();
_pn->lfile()->put(MOV_ANNOES, _annoes_msk); //Viene generato un mov
_pn->lfile()->put(MOV_DATAREG, _datareg); //quando si incontra il
_pn->lfile()->put(MOV_CODCAUS, _codcaus); //primo conto con indbil
_pn->lfile()->put(MOV_NUMREG, _numreg);
compila_mov = FALSE; //=3 (costi).
}
_saldi->setkey(1);
_saldi->zero();
_saldi->put(SLD_ANNOES, _annoes_msk);
_saldi->put(SLD_GRUPPO, g);
_saldi->put(SLD_CONTO, c);
TRectype rec (_saldi->curr());
int j = 0;
numrig = 0;
for (_saldi->read(); ; _saldi->next())
{
TRectype& rmov = _pn->cg(j);
numrig++;
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)
{
record_rmov_proper(numrig, rmov, tot_saldo);
tot_saldo = 0.00;
// j = 0;
// _pn->destroy_rows(); //Azzero l'oggetto pn.
}
break;
}
s = _saldi->get_long(SLD_SOTTOCONTO);
int annoeseprec = atoi(_annoeseprec);
_sale.calcola_ultima_immissione(_annoes_msk,annoeseprec ,g,c,s,indbil);
real saldo = _sale.saldo();
if (saldo == 0) continue;
if (saldo.sign() > 0)
sezione = 'D';
else
if (saldo.sign() < 0)
{
sezione = 'A';
saldo = -saldo;
}
if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli
{ // importi trovati sui saldi. Quando ho
sez_rmov = 'A'; // finito di leggere i sottoconti, oppure
tot_saldo += saldo; // quando ho raggiunto un massimo di 200
} // 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;
}
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).
record_rmov_proper (numrig, rmov, tot_saldo);
// _pn->write();
tot_saldo = 0.00;
// j = 0;
// _pn->destroy_rows(); //Azzero l'oggetto pn.
}
if (!_saldi->eof())
{
rmov.zero();
rmov.put(RMV_ANNOES, _annoes_msk); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _datareg); //per ogni sottoconto che leggo
rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste
rmov.put(RMV_CONTO, c); //righe servono per mandare a 0
rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la
rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
TConto tc(g,c,s);
_sld->set_anno_es(_annoes_msk); //Aggiorno anche i saldi con
_sld->aggiorna(tc,saldo,sezione); //l'oggetto TSaldo_agg
j++;
}
if (_saldi->eof()) break;
} //for saldi
if (j >= 1)
{
_pn->write();
_sld->registra();
j = 0;
}
} // if (indbil == 3)
} // for pcon
/************************
_pn->destroy_rows(); //Azzero l'oggetto pn.
ultima_registrazione();
_pn->lfile()->zero();
_pn->lfile()->put(MOV_ANNOES, _annoes_msk); //Compilo la testata per
_pn->lfile()->put(MOV_DATAREG, _datareg); //perdite di es. c.economico
_pn->lfile()->put(MOV_CODCAUS, _codcaus); //a Profitti e Perdite
_pn->lfile()->put(MOV_NUMREG, _numreg);
TRectype& rmov = _pn->cg(j);
long numrig = 1;
record_rmov_proper(numrig,rmov);
******/
}
void CG4600_application::ricavi()
{
bool compila_mov = TRUE;
long s;
char sez_rmov = ' ';
real tot_saldo;
long numrig = 0;
TRecnotype items_pcon = _cur->items();
for (int i = 0; i < items_pcon; i++, ++(*_cur))
{
int indbil = _cur->curr().get_int(PCN_INDBIL);
int g = _cur->curr().get_int(PCN_GRUPPO);
int c = _cur->curr().get_int(PCN_CONTO);
if (indbil == 4)
{
if (compila_mov)
{
_pn->lfile()->zero();
_pn->lfile()->put(MOV_ANNOES, _annoes_msk); //Viene generato un mov
_pn->lfile()->put(MOV_DATAREG, _datareg); //quando si incontra il
_pn->lfile()->put(MOV_CODCAUS, _codcaus); //primo conto con indbil
_pn->lfile()->put(MOV_NUMREG, _numreg);
compila_mov = FALSE; //=4 (ricavi).
}
_saldi->setkey(1);
_saldi->zero();
_saldi->put(SLD_ANNOES, _annoes_msk);
_saldi->put(SLD_GRUPPO, g);
_saldi->put(SLD_CONTO, c);
TRectype rec (_saldi->curr());
int j = 0;
numrig = 0;
for (_saldi->read(); ; _saldi->next())
{
TRectype& rmov = _pn->cg(j);
numrig++;
if (_saldi->curr() > rec || _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 (j >= 1)
{
record_rmov_proper (numrig, rmov, tot_saldo);
if (tot_saldo.sign() > 0)
sez_rmov = 'A';
else
if (tot_saldo.sign() < 0)
{
sez_rmov = 'D';
tot_saldo = tot_saldo * (-1.00);
}
rmov.put(RMV_SEZIONE, sez_rmov);
rmov.put(RMV_IMPORTO, tot_saldo);
tot_saldo = 0.00;
// j = 0;
// _pn->destroy_rows(); //Azzero l'oggetto pn.
}
break;
}
s = _saldi->get_long(SLD_SOTTOCONTO);
real saldo = _saldi->get_real(SLD_SALDO);
char sezione = _saldi->get(SLD_FLAGSALINI)[0];
if (sezione == 'D') // ---> Tengo una variabile in cui salvo gli
{ // importi trovati sui saldi. Quando ho
sez_rmov = 'A'; // finito di leggere i sottoconti, oppure
tot_saldo += saldo; // quando ho raggiunto un massimo di 200
} // 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;
}
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).
record_rmov_proper (numrig, rmov, tot_saldo);
if (tot_saldo.sign() > 0)
sez_rmov = 'A';
else
if (tot_saldo.sign() < 0)
{
sez_rmov = 'D';
tot_saldo = tot_saldo * (-1.00);
}
rmov.put(RMV_SEZIONE, sez_rmov);
rmov.put(RMV_IMPORTO, tot_saldo);
_pn->write();
tot_saldo = 0.00;
// j = 0;
// _pn->destroy_rows(); //Azzero l'oggetto pn.
}
if (!_saldi->eof())
{
rmov.zero();
rmov.put(RMV_ANNOES, _annoes_msk); //Compilo una riga di movimento
rmov.put(RMV_DATAREG, _datareg); //per ogni sottoconto che leggo
rmov.put(RMV_GRUPPO, g); //sui saldi. Siccome queste
rmov.put(RMV_CONTO, c); //righe servono per mandare a 0
rmov.put(RMV_SOTTOCONTO, s); //il saldo dei movimenti, la
rmov.put(RMV_SEZIONE, sez_rmov); //sezione sara' opposta a
rmov.put(RMV_IMPORTO, saldo); //quella letta sui saldi.
rmov.put(RMV_NUMREG, _numreg);
rmov.put(RMV_NUMRIG, numrig);
TConto tc(g,c,s);
_sld->set_anno_es(_annoes_msk); //Aggiorno anche i saldi con
_sld->aggiorna(tc,saldo,sezione); //l'oggetto TSaldo_agg
j++;
}
if (_saldi->eof()) break;
} //for saldi
if (j >= 1)
{
_pn->write();
_sld->registra();
j = 0;
}
} // if (indbil == 4)
} // for pcon
}
bool CG4600_application::menu(MENU_TAG m)
{
if (m == BAR_ITEM(1))
return set();
return FALSE;
}
int cg4600 (int argc, char* argv[])
{
CG4600_application main_app;
main_app.run(argc, argv, "Chiusura/Apertura Conti");
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink