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

Gigamodifica saldi contabili + correzioni maschere e altro

Browse Source 
Elenco files modificati in ~villa/src/saldi.mod


git-svn-id: svn://10.65.10.50/trunk@2852 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
villa 1996-05-20 09:26:39 +00:00
parent 4c24bfce1b
commit af0bd15535
27 changed files with 5333 additions and 2278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
cg/cg0100.cpp
View File

@ -162,18 +162,47 @@ bool CG0100_application::protected_record(TRectype &rec)
_saldi->put(PCN_GRUPPO, gruppo); _saldi->put(PCN_GRUPPO, gruppo);
_saldi->put(PCN_CONTO, conto); _saldi->put(PCN_CONTO, conto);
_saldi->put(PCN_SOTTOCONTO, sottoc); _saldi->put(PCN_SOTTOCONTO, sottoc);
_saldi->read(_isgteq); _saldi->read();
bool ok = FALSE; bool ok = FALSE;
if (_saldi->good()) if (_saldi->good())
ok = _saldi->get_real(SLD_SALDO) != ZERO || ok = _saldi->get_real(SLD_SALDO) != ZERO ||
_saldi->get_real(SLD_PDARE) != ZERO || _saldi->get_real(SLD_PDARE) != ZERO ||
_saldi->get_real(SLD_PAVERE) != ZERO || _saldi->get_real(SLD_PAVERE) != ZERO ||
<<<<<<< cg0100.cpp
_saldi->get_real(SLD_SALDOFIN) != ZERO ||
=======
>>>>>>> 1.22
_saldi->get_real(SLD_PDAREPRO) != ZERO || _saldi->get_real(SLD_PDAREPRO) != ZERO ||
_saldi->get_real(SLD_PAVEREPRO) != ZERO; _saldi->get_real(SLD_PAVEREPRO) != ZERO;
return ok && gruppo ==_saldi->get_int(PCN_GRUPPO) && ok &= (gruppo ==_saldi->get_int(PCN_GRUPPO) &&
conto ==_saldi->get_int(PCN_CONTO) && conto ==_saldi->get_int(PCN_CONTO) &&
sottoc ==_saldi->get_long(PCN_SOTTOCONTO); sottoc ==_saldi->get_long(PCN_SOTTOCONTO));
if (!ok)
{
// look for scaricato
_saldi->zero();
_saldi->put(PCN_GRUPPO, gruppo);
_saldi->put(PCN_CONTO, conto);
_saldi->put(PCN_SOTTOCONTO, sottoc);
_saldi->put(SLD_FLSCA, "X");
_saldi->read(_isgteq);
if (_saldi->good())
{
ok = _saldi->get_real(SLD_SALDO) != ZERO ||
_saldi->get_real(SLD_PDARE) != ZERO ||
_saldi->get_real(SLD_PAVERE) != ZERO ||
_saldi->get_real(SLD_SALDOFIN) != ZERO ||
_saldi->get_real(SLD_PDAREPRO) != ZERO ||
_saldi->get_real(SLD_PAVEREPRO) != ZERO;
ok &= (gruppo ==_saldi->get_int(PCN_GRUPPO) &&
conto ==_saldi->get_int(PCN_CONTO) &&
sottoc ==_saldi->get_long(PCN_SOTTOCONTO));
}
}
if (ok) return TRUE;
} }
get_relation()->save_status(); get_relation()->save_status();
pconti.zero() ; pconti.zero() ;
@ -216,7 +245,6 @@ HIDDEN bool tmcf_handler(TMask_field& f, KEY key)
void CG0100_application::init_insert_mode(TMask& m) void CG0100_application::init_insert_mode(TMask& m)
{ {
const int gruppo = atoi(m.get(FLD_CM1_GRUPPO)); const int gruppo = atoi(m.get(FLD_CM1_GRUPPO));
const int conto = atoi(m.get(FLD_CM1_CONTO)); const int conto = atoi(m.get(FLD_CM1_CONTO));

5
cg/cg1500.cpp
View File

@ -107,6 +107,7 @@ class CG1500_application : public TPrintapp
public: public:
TDate _inizioEs, _fineEs; TDate _inizioEs, _fineEs;
bool menu (MENU_TAG m) { return TPrintapp::menu(m) ; } bool menu (MENU_TAG m) { return TPrintapp::menu(m) ; }
virtual bool user_create() ; virtual bool user_create() ;
@ -162,7 +163,7 @@ public:
CG1500_application() {} CG1500_application() {}
}; };
HIDDEN inline CG1500_application & app() { return (CG1500_application&) main_app(); } HIDDEN inline CG1500_application& app() { return (CG1500_application&)main_app(); }
TDate InizioEsercizio(int anno) TDate InizioEsercizio(int anno)
{ {
@ -1503,7 +1504,7 @@ if (movimentato || _stampav != 1)
mov_conto_avere += _mov_periodo_avere; mov_conto_avere += _mov_periodo_avere;
prg_conto_dare += _prg_prec_dare; prg_conto_dare += _prg_prec_dare;
prg_conto_avere += _prg_prec_avere; prg_conto_avere += _prg_prec_avere;
saldo_conto += saldo_finale; // somma algebrica!!! saldo_conto += saldo_finale; // somma pitagorica
//scrivo il record relat. al sottoconto se non e' richiesto saldi di mastro //scrivo il record relat. al sottoconto se non e' richiesto saldi di mastro
if (_verifica != 2) if (_verifica != 2)

12
cg/cg2100.cpp
View File

@ -1,4 +1,4 @@
#include <config.h> #include <config.h>
#include <mailbox.h> #include <mailbox.h>
#include <urldefid.h> #include <urldefid.h>
#include <execp.h> #include <execp.h>
@ -635,7 +635,9 @@ int TPrimanota_application::read(TMask& m)
_saldi.reset(); // Azzera saldi _saldi.reset(); // Azzera saldi
_saldi.set_movprovv(_rel->lfile().get_char("PROVVIS") > ' '); _saldi.set_movprovv(_rel->lfile().get_char("PROVVIS") > ' ');
_saldi.set_movap(causale().apertura()); tiposal tsal = causale().apertura() ? apertura :
(causale().chiusura() ? chiusura : normale);
_saldi.set_tipo_saldo(tsal);
_saldi.set_anno_es(m.get_int(F_ANNOES)); _saldi.set_anno_es(m.get_int(F_ANNOES));
_saldi.set_num_ulmov(numreg); _saldi.set_num_ulmov(numreg);
_saldi.set_data_ulmov((TDate)m.get(F_DATAREG)); _saldi.set_data_ulmov((TDate)m.get(F_DATAREG));
@ -732,7 +734,9 @@ void TPrimanota_application::mask2rel(const TMask& m)
const int annoes = m.get_int(F_ANNOES); const int annoes = m.get_int(F_ANNOES);
_saldi.set_movprovv(m.get(F_PROVVISORIO)[0] > ' '); _saldi.set_movprovv(m.get(F_PROVVISORIO)[0] > ' ');
_saldi.set_movap(causale().apertura()); tiposal tsal = causale().apertura() ? apertura :
(causale().chiusura() ? chiusura : normale);
_saldi.set_tipo_saldo(tsal);
_saldi.set_anno_es(annoes); _saldi.set_anno_es(annoes);
_saldi.set_num_ulmov(numreg); _saldi.set_num_ulmov(numreg);
_saldi.set_data_ulmov((TDate)m.get(F_DATAREG)); _saldi.set_data_ulmov((TDate)m.get(F_DATAREG));
@ -1183,7 +1187,7 @@ void TPrimanota_application::genera_incasso(const char* causimm)
_saldi.reset(); // Inizializza saldi _saldi.reset(); // Inizializza saldi
_saldi.set_movprovv(FALSE); _saldi.set_movprovv(FALSE);
_saldi.set_movap(FALSE); _saldi.set_tipo_saldo(normale);
_saldi.set_anno_es(m.get_int(F_ANNOES)); _saldi.set_anno_es(m.get_int(F_ANNOES));
_saldi.set_num_ulmov(_lastreg); _saldi.set_num_ulmov(_lastreg);
_saldi.set_data_ulmov((TDate)m.get(F_DATAREG)); _saldi.set_data_ulmov((TDate)m.get(F_DATAREG));

3
cg/cg2103.cpp
View File

@ -397,6 +397,9 @@ bool TCausale::num_doc() const
bool TCausale::apertura() const bool TCausale::apertura() const
{ return _rec.get_char(CAU_MOVAP) == 'A'; } { return _rec.get_char(CAU_MOVAP) == 'A'; }
bool TCausale::chiusura() const
{ return _rec.get_char(CAU_MOVAP) == 'C'; }
bool TCausale::sezionale() const bool TCausale::sezionale() const
{ return _rec.get_bool(CAU_MOVSEZ); } { return _rec.get_bool(CAU_MOVSEZ); }

1
cg/cg2103.h
View File

@ -123,6 +123,7 @@ public:
bool data_doc() const; bool data_doc() const;
bool num_doc() const; bool num_doc() const;
bool apertura() const; bool apertura() const;
bool chiusura() const;
bool sezionale() const; bool sezionale() const;
bool valuta() const; bool valuta() const;
bool intra() const; bool intra() const;

9
cg/cg2200.cpp
View File

@ -97,15 +97,18 @@ void TProvvisori_app::inizia_saldi(const TRectype& r)
_saldi.reset(); _saldi.reset();
bool apertura = FALSE; tiposal tsal = normale;
const TString& c = r.get(MOV_CODCAUS); const TString& c = r.get(MOV_CODCAUS);
if (c.not_empty()) if (c.not_empty())
{ {
_cau->put(CAU_CODCAUS, c); _cau->put(CAU_CODCAUS, c);
if (_cau->read() == NOERR) if (_cau->read() == NOERR)
apertura = _cau->get_bool(CAU_MOVAP); {
if (_cau->get_char(CAU_MOVAP) == 'A') tsal = apertura;
else if (_cau->get_char(CAU_MOVAP) == 'C') tsal = chiusura;
} }
_saldi.set_movap(apertura); }
_saldi.set_tipo_saldo(tsal);
_saldi.set_anno_es(r.get_int(MOV_ANNOES)); _saldi.set_anno_es(r.get_int(MOV_ANNOES));
_saldi.set_num_ulmov(r.get_long(MOV_NUMREG)); _saldi.set_num_ulmov(r.get_long(MOV_NUMREG));

39
cg/cg3200.cpp
View File

@ -2900,6 +2900,11 @@ void TMastrini_application::calcola_progressivi_al()
void TMastrini_application::calcola_progressivi() void TMastrini_application::calcola_progressivi()
{ {
/* fv 20/3/96: aggiustato per nuova struttura saldi - modificata ricerca
* record scaricati e assegnazione dare/avere relativo - Controllare che
* non occorra considerare il saldo di chiusura (SALDOFIN) aggiunto al
* record */
TLocalisamfile saldi(LF_SALDI, FALSE); TLocalisamfile saldi(LF_SALDI, FALSE);
real pdaresca,paveresca,pdarescap,paverescap; real pdaresca,paveresca,pdarescap,paverescap;
real progdare_attuale,progavere_attuale,progdare_prec,progavere_prec; real progdare_attuale,progavere_attuale,progdare_prec,progavere_prec;
@ -2942,23 +2947,49 @@ void TMastrini_application::calcola_progressivi()
if (annoes_saldi == _anno_corrente) if (annoes_saldi == _anno_corrente)
{ {
pdaresca = saldi.get_real(SLD_PDARESCA); pdaresca = ZERO;
paveresca = saldi.get_real(SLD_PAVERESCA); paveresca = ZERO;
progdare_attuale = saldi.get_real(SLD_PDARE); progdare_attuale = saldi.get_real(SLD_PDARE);
progavere_attuale = saldi.get_real(SLD_PAVERE); progavere_attuale = saldi.get_real(SLD_PAVERE);
saldo = saldi.get_real(SLD_SALDO); saldo = saldi.get_real(SLD_SALDO);
salini = saldi.get(SLD_FLAGSALINI)[0]; salini = saldi.get(SLD_FLAGSALINI)[0];
_ultima_data_reg = saldi.get_date(SLD_DATAULMOV); _ultima_data_reg = saldi.get_date(SLD_DATAULMOV);
// cerca eventuale record scaricati
saldi.next();
if (!saldi.eof() && saldi.get_bool(SLD_FLSCA) &&
annoes_saldi == saldi.curr().get_int(SLD_ANNOES) &&
saldi.get_int(SLD_GRUPPO) == _gruppo &&
saldi.get_int(SLD_CONTO) == _conto &&
saldi.get_long(SLD_SOTTOCONTO) == _sottoc)
{
pdaresca = saldi.get_real(SLD_PDARE);
paveresca = saldi.get_real(SLD_PAVERE);
}
saldi.prev();
} }
//Calcola i progressivi dell'esercizio precedente //Calcola i progressivi dell'esercizio precedente
if (annoes_saldi == _anno_precedente) if (annoes_saldi == _anno_precedente)
{ {
pdarescap = saldi.get_real(SLD_PDARESCA); pdarescap = ZERO;
pdarep = saldi.get_real(SLD_PDARE); pdarep = saldi.get_real(SLD_PDARE);
paverescap = saldi.get_real(SLD_PAVERESCA); paverescap = ZERO;
paverep = saldi.get_real(SLD_PAVERE); paverep = saldi.get_real(SLD_PAVERE);
// cerca eventuale record scaricati
saldi.next();
if (!saldi.eof() && saldi.get_bool(SLD_FLSCA) &&
annoes_saldi == saldi.curr().get_int(SLD_ANNOES) &&
saldi.get_int(SLD_GRUPPO) == _gruppo &&
saldi.get_int(SLD_CONTO) == _conto &&
saldi.get_long(SLD_SOTTOCONTO) == _sottoc)
{
pdarescap = saldi.get_real(SLD_PDARE);
paverescap = saldi.get_real(SLD_PAVERE);
}
saldi.prev();
} }
// Se il saldo dell'esercizio attuale e' diverso da 0 allora significa che // Se il saldo dell'esercizio attuale e' diverso da 0 allora significa che

15
cg/cg4100.cpp
View File

@ -356,7 +356,8 @@ bool CG4100_App::sort_sal()
sal.set_anno_es(year); sal.set_anno_es(year);
sal.clear_saldi(year); sal.clear_saldi(year);
long numreg = 0L; long numreg = 0L;
bool apertura = FALSE, provvis = FALSE; tiposal tsal = normale;
bool provvis = FALSE;
TDate datareg; TDate datareg;
while (!rmov.eof()) while (!rmov.eof())
@ -368,6 +369,8 @@ bool CG4100_App::sort_sal()
gruppo = rmov.get_int(RMV_GRUPPO); gruppo = rmov.get_int(RMV_GRUPPO);
conto = rmov.get_int(RMV_CONTO); conto = rmov.get_int(RMV_CONTO);
sottoconto = rmov.get_long(RMV_SOTTOCONTO); sottoconto = rmov.get_long(RMV_SOTTOCONTO);
bool scaricato = FALSE;
if (numreg != oldnumreg) if (numreg != oldnumreg)
{ {
if (oldnumreg !=0) if (oldnumreg !=0)
@ -381,6 +384,8 @@ bool CG4100_App::sort_sal()
mov.read(); mov.read();
CHECK(mov.good(),"Archivi movimenti e righe inconsistenti"); CHECK(mov.good(),"Archivi movimenti e righe inconsistenti");
scaricato = mov.get_bool(MOV_SCARCON);
causali.zero(); causali.zero();
const char* codcaus = mov.get(MOV_CODCAUS); const char* codcaus = mov.get(MOV_CODCAUS);
// cerca causale // cerca causale
@ -389,15 +394,15 @@ bool CG4100_App::sort_sal()
causali.put(CAU_CODCAUS, codcaus); causali.put(CAU_CODCAUS, codcaus);
causali.read(); causali.read();
CHECK(causali.good(),"Archivi causali e movimenti inconsistenti"); CHECK(causali.good(),"Archivi causali e movimenti inconsistenti");
apertura = causali.get(CAU_MOVAP) == "A"; if (causali.get(CAU_MOVAP) == "A") tsal = apertura;
else if (causali.get(CAU_MOVAP) == "C") tsal = chiusura;
} }
else apertura = FALSE;
provvis = mov.get(MOV_PROVVIS).not_empty(); provvis = mov.get(MOV_PROVVIS).not_empty();
datareg = mov.get_date(MOV_DATAREG); datareg = mov.get_date(MOV_DATAREG);
sal.reset(); sal.reset();
sal.set_anno_es(_year); sal.set_anno_es(_year);
sal.set_movap(apertura); sal.set_tipo_saldo(tsal);
sal.set_movprovv(provvis); sal.set_movprovv(provvis);
sal.set_data_ulmov(datareg); sal.set_data_ulmov(datareg);
sal.set_num_ulmov(oldnumreg); sal.set_num_ulmov(oldnumreg);
@ -405,7 +410,7 @@ bool CG4100_App::sort_sal()
const char sezione = rmov.get(RMV_SEZIONE)[0]; const char sezione = rmov.get(RMV_SEZIONE)[0];
real importo(rmov.get(RMV_IMPORTO)); real importo(rmov.get(RMV_IMPORTO));
sal.aggiorna(gruppo, conto, sottoconto, importo, sezione); sal.aggiorna(gruppo, conto, sottoconto, importo, sezione, TRUE, scaricato);
} }
rmov.next(); rmov.next();
prnd.addstatus(1); prnd.addstatus(1);

1
cg/cg4100b.uml
View File

@ -27,6 +27,7 @@ BEGIN
DISPLAY "Data fine esercizio " D1 DISPLAY "Data fine esercizio " D1
OUTPUT FLD_CG41_YEAR CODTAB OUTPUT FLD_CG41_YEAR CODTAB
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
FLAGS "Z"
HELP "Codice esercizio per il quale si desidera il ricalcolo dei saldi" HELP "Codice esercizio per il quale si desidera il ricalcolo dei saldi"
WARNING "Il codice esercizio e' obbligatorio" WARNING "Il codice esercizio e' obbligatorio"
END END

4
cg/cg4600.cpp
View File

@ -614,7 +614,7 @@ bool CG4600_application::set()
_sld->set_anno_es(_annoesch); _sld->set_anno_es(_annoesch);
_sld->set_movprovv(FALSE); _sld->set_movprovv(FALSE);
_sld->set_movap(FALSE); _sld->set_tipo_saldo(normale);
// _pn->destroy_rows(_numreg); //Azzero l'oggetto pn. // _pn->destroy_rows(_numreg); //Azzero l'oggetto pn.
costi (); costi ();
@ -654,7 +654,7 @@ bool CG4600_application::set()
_totale_saldo = ZERO; _totale_saldo = ZERO;
_sld->set_anno_es(_annoesap); _sld->set_anno_es(_annoesap);
_sld->set_movap(TRUE); _sld->set_tipo_saldo(apertura);
_sld->set_movimentato(TRUE); _sld->set_movimentato(TRUE);
// _pn->destroy_rows(_numreg); //Azzero l'oggetto pn. // _pn->destroy_rows(_numreg); //Azzero l'oggetto pn.
*_cur = 0l; *_cur = 0l;

16
cg/cg5100a.uml
View File

@ -20,6 +20,11 @@ ENDPAGE
PAGE "Impostazione parametri ditta" -1 -1 77 8 PAGE "Impostazione parametri ditta" -1 -1 77 8
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 1 "Archivi in comune"
END
NUMBER FLD_ANLIIV 4 NUMBER FLD_ANLIIV 4
BEGIN BEGIN
PROMPT 2 0 "@bANNO LIQUIDAZIONE IVA " PROMPT 2 0 "@bANNO LIQUIDAZIONE IVA "
@ -44,11 +49,6 @@ BEGIN
FIELD PcTcCm FIELD PcTcCm
END END
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 1 "Archivi in comune"
END
GROUPBOX DLG_NULL 76 8 GROUPBOX DLG_NULL 76 8
BEGIN BEGIN
@ -180,7 +180,7 @@ END
ENDPAGE ENDPAGE
PAGE "Impostazione parametri ditta" -1 -1 77 8 PAGE "Pag. 2" -1 -1 77 8
GROUPBOX DLG_NULL 78 12 GROUPBOX DLG_NULL 78 12
BEGIN BEGIN
@ -687,7 +687,7 @@ END
ENDPAGE ENDPAGE
PAGE "Impostazione parametri ditta" -1 -1 77 8 PAGE "Pag. 3" -1 -1 77 8
GROUPBOX DLG_NULL 78 10 GROUPBOX DLG_NULL 78 10
BEGIN BEGIN
@ -695,7 +695,7 @@ BEGIN
END END
RADIOBUTTON LST_RRFRAM 16 RADIOBUTTON LST_RRFRAM 20
BEGIN BEGIN
PROMPT 3 2 "" PROMPT 3 2 ""
HELP "Frequenza del calcolo dei ratei e risconti" HELP "Frequenza del calcolo dei ratei e risconti"

1
cg/cg5200.h
View File

@ -9,3 +9,4 @@
#define F_DESCR_CLIENTE 109 #define F_DESCR_CLIENTE 109
#define F_DESCR_FORN 110 #define F_DESCR_FORN 110
#define F_SHEET_SALDI 111 #define F_SHEET_SALDI 111
#define F_SCARICATO 112

55
cg/cg5200a.uml
View File

@ -25,6 +25,11 @@ BEGIN
FLAGS "Z" FLAGS "Z"
END END
BOOLEAN F_SCARICATO
BEGIN
PROMPT 40 1 "Solo saldi dei movimenti scaricati"
END
GROUPBOX DLG_NULL 73 4 GROUPBOX DLG_NULL 73 4
BEGIN BEGIN
PROMPT 3 2 "" PROMPT 3 2 ""
@ -214,8 +219,10 @@ BEGIN
ITEM " Avere@15" ITEM " Avere@15"
ITEM " Saldo@15" ITEM " Saldo@15"
ITEM "" ITEM ""
ITEM "Progr.Mov.Elim.: Dare@15" // ITEM "Progr.Mov.Elim.: Dare@15"
ITEM " Avere@15" // ITEM " Avere@15"
ITEM "Saldo di chiusura@15"
ITEM ""
ITEM "Saldo complessivo" ITEM "Saldo complessivo"
ITEM "" ITEM ""
ITEM "Ult.Op.: Data" ITEM "Ult.Op.: Data"
@ -224,6 +231,8 @@ BEGIN
ITEM " Avere@15" ITEM " Avere@15"
ITEM " Saldo@15" ITEM " Saldo@15"
ITEM "" ITEM ""
ITEM "Progr.Mov.Elim.: Dare@15"
ITEM " Avere@15"
END END
ENDPAGE ENDPAGE
@ -285,10 +294,11 @@ BEGIN
HELP "Sezione del saldo attuale del conto" HELP "Sezione del saldo attuale del conto"
END END
/* =====================================================================
NUMBER 108 15 NUMBER 108 15
BEGIN BEGIN
PROMPT 1 6 "Progr.Mov.Eliminati: Dare " PROMPT 1 6 "Progr.Mov.Eliminati: Dare "
HELP "Progressivi dare attuali dei moviementi eliminati" HELP "Progressivi dare attuali dei movimenti eliminati"
FLAGS "R" FLAGS "R"
PICTURE "." PICTURE "."
END END
@ -296,10 +306,26 @@ END
NUMBER 109 15 NUMBER 109 15
BEGIN BEGIN
PROMPT 45 6 "Avere " PROMPT 45 6 "Avere "
HELP "Progressivi avere attuali dei moviementi eliminati" HELP "Progressivi avere attuali dei movimenti eliminati"
FLAGS "R" FLAGS "R"
PICTURE "." PICTURE "."
END END
=======================================================================*/
NUMBER 108 15
BEGIN
PROMPT 1 6 " Saldo di chiusura "
HELP "Saldo di chiusura"
FLAGS "R"
PICTURE "."
END
STRING 109 1
BEGIN
PROMPT 44 6 ""
HELP "Sezione del saldo di chiusura"
FLAGS "R"
END
NUMBER 110 15 NUMBER 110 15
BEGIN BEGIN
@ -333,7 +359,7 @@ END
NUMBER 114 15 NUMBER 114 15
BEGIN BEGIN
PROMPT 1 10 "Progr.Mov.Provvisori: Dare " PROMPT 1 10 "Progr.Mov.Provvisori: Dare "
HELP "Progressivi dare attuali dei moviementi provvisori" HELP "Progressivi dare attuali dei movimenti provvisori"
FLAGS "R" FLAGS "R"
PICTURE "." PICTURE "."
END END
@ -341,7 +367,7 @@ END
NUMBER 115 15 NUMBER 115 15
BEGIN BEGIN
PROMPT 45 10 "Avere " PROMPT 45 10 "Avere "
HELP "Progressivi avere attuali dei moviementi provvisori del conto" HELP "Progressivi avere attuali dei movimenti provvisori del conto"
FLAGS "R" FLAGS "R"
PICTURE "." PICTURE "."
END END
@ -361,6 +387,23 @@ BEGIN
FLAGS "R" FLAGS "R"
END END
NUMBER 118 15
BEGIN
PROMPT 1 6 "Progr.Mov.Eliminati: Dare "
HELP "Progressivi dare attuali dei movimenti eliminati"
FLAGS "R"
PICTURE "."
END
NUMBER 119 15
BEGIN
PROMPT 45 6 "Avere "
HELP "Progressivi avere attuali dei movimenti eliminati"
FLAGS "R"
PICTURE "."
END
BUTTON DLG_CANCEL 9 2 BUTTON DLG_CANCEL 9 2
BEGIN BEGIN
PROMPT -11 -1 "" PROMPT -11 -1 ""

6
cg/cg5300.cpp
View File

@ -213,7 +213,7 @@ int TParaliq_app::rewrite(const TMask& m)
TToken_string& tt = sf.row(i); TToken_string& tt = sf.row(i);
const TString16 att = tt.get(0); const TString16 att = tt.get(0);
const TString16 tips(tt.get(1)); const TString16 tips(tt.get(1));
const TString16 codtab(format("%05ld%4d%s1", firm, year, (const char*)att)); const TString16 codtab(format("%05ld%4d%s", firm, year, (const char*)att));
_pla->zero(); _pla->zero();
_pla->put("CODTAB", codtab); _pla->put("CODTAB", codtab);
@ -264,7 +264,7 @@ int TParaliq_app::rewrite(const TMask& m)
lia.put("CODTAB", format("%05ld%d", firm, year)); lia.put("CODTAB", format("%05ld%d", firm, year));
was = lia.read() == NOERR; was = lia.read() == NOERR;
if (!was) lia.zero(); if (!was) lia.zero();
m.autosave(_rel); m.autosave(*_rel);
if (err == NOERR) err = (was ? lia.rewrite() : lia.write()); if (err == NOERR) err = (was ? lia.rewrite() : lia.write());
if (err == NOERR && year == _yearliq) if (err == NOERR && year == _yearliq)
{ {
@ -290,7 +290,7 @@ int TParaliq_app::read(TMask& m)
// legge da LIA (si istanziano i campi credito prec. e Freq. Vers // legge da LIA (si istanziano i campi credito prec. e Freq. Vers
// prende le attivita' una per una da _atts e // prende le attivita' una per una da _atts e
// crea le righe sheet // crea le righe sheet
m.autoload(get_relation()); m.autoload(*get_relation());
const long firm = m.get_long(F_CODDITTA); const long firm = m.get_long(F_CODDITTA);
const int year = m.get_int(F_YEAR); const int year = m.get_int(F_YEAR);

6
cg/cg5300a.uml
View File

@ -94,7 +94,7 @@ SPREADSHEET F_SHEET_PLA 78 6
BEGIN BEGIN
PROMPT 1 10 "Parametri attivita'" PROMPT 1 10 "Parametri attivita'"
ITEM "Attivita'@5F" ITEM "Attivita'@5F"
ITEM "Tipo@1" ITEM "Tipo@9"
ITEM "% Pro-rata@6" ITEM "% Pro-rata@6"
ITEM "Plafond art.8@15" ITEM "Plafond art.8@15"
ITEM "Plafond art.8b@15" ITEM "Plafond art.8b@15"
@ -131,8 +131,8 @@ BEGIN
HELP "Tipo di attivita' della ditta" HELP "Tipo di attivita' della ditta"
FLAGS "U" FLAGS "U"
ITEM " |Altre" ITEM " |Altre"
ITEM "E|Mista evidenziata" ITEM "E|Mista evid."
ITEM "S|Servizio o mista generica" ITEM "S|Serv. o mista gen."
END END
NUMBER F_PRORATA 6 2 NUMBER F_PRORATA 6 2

2
cg/cg5400a.uml
View File

@ -91,7 +91,7 @@ BEGIN
WARNING "Registro assente" WARNING "Registro assente"
END END
LIST F_TIPO LIST F_TIPO 15
BEGIN BEGIN
FLAGS "HG" FLAGS "HG"
ITEM "1|Vendite" MESSAGE HIDE,F_ESER|SHOW,F_YEAR|HIDE,F_DAY ITEM "1|Vendite" MESSAGE HIDE,F_ESER|SHOW,F_YEAR|HIDE,F_DAY

37
cg/cg5500.cpp
View File

@ -141,7 +141,7 @@ void Visliq_app::build_ditte_sheet()
const char vers = d->get_char(2); const char vers = d->get_char(2);
bool selectable = vers == '?'; bool selectable = vers == '?';
const long pos = _ditte->add(d); const long pos = _ditte->add(d);
if (selectable) _ditte->disable(pos); if (selectable) _ditte->disable_row(pos);
} }
} }
@ -281,7 +281,7 @@ bool Visliq_app::set_ditta(TMask_field& f, KEY k)
TToken_string& row = sh->row(i); TToken_string& row = sh->row(i);
if (ditta == row.get(0)) if (ditta == row.get(0))
{ {
if (sh->enabled(i)) if (sh->row_enabled(i))
{ {
f.mask().field(F_CODDITTA).set(row.get(0)); f.mask().field(F_CODDITTA).set(row.get(0));
f.mask().field(F_RAGSOC).set(row.get(1)); f.mask().field(F_RAGSOC).set(row.get(1));
@ -321,7 +321,7 @@ bool Visliq_app::set_ragsoc(TMask_field& f, KEY k)
TString ts(row.get(1)); TString ts(row.get(1));
if (ts.find(ditta) != -1) if (ts.find(ditta) != -1)
{ {
if (sh->enabled(i)) if (sh->row_enabled(i))
{ {
f.mask().field(F_CODDITTA).set(row.get(0)); f.mask().field(F_CODDITTA).set(row.get(0));
f.mask().field(F_RAGSOC).set(row.get(1)); f.mask().field(F_RAGSOC).set(row.get(1));
@ -602,7 +602,8 @@ bool Visliq_app::vis_one(int m)
msk.field(F_RIMBORSO).set(rimborso.string()); msk.field(F_RIMBORSO).set(rimborso.string());
if (rettifica.sign() < 0) if (rettifica.sign() < 0)
{ {
msk.field(F_RETTIFICA).set(((real) abs(rettifica)).string()); real rabs = abs(rettifica);
msk.field(F_RETTIFICA).set(rabs.string());
msk.field(F_DEBCRE).set("C"); msk.field(F_DEBCRE).set("C");
} }
else if (rettifica.sign() > 0) else if (rettifica.sign() > 0)
@ -919,7 +920,8 @@ void Visliq_app::recalc_liq_data(TViswin* vsw, real& rimb, real& rett, real& ver
} }
else if (rett.sign() < 0) else if (rett.sign() < 0)
{ {
vsw->replace(lrettc, ((real) abs(rett)).string("###.###.###.###"), 58); real rabs = abs(rett);
vsw->replace(lrettc, rabs.string("###.###.###.###"), 58);
vsw->replace(lrettd, " ", 75); vsw->replace(lrettd, " ", 75);
} }
else else
@ -930,8 +932,9 @@ void Visliq_app::recalc_liq_data(TViswin* vsw, real& rimb, real& rett, real& ver
if (risul.sign() < 0) if (risul.sign() < 0)
{ {
real rabs = abs(risul);
ln.overwrite("CREDITO ATTUALE", 23); ln.overwrite("CREDITO ATTUALE", 23);
ln.overwrite(((real) abs(risul)).string("###.###.###.###"), 58); ln.overwrite(rabs.string("###.###.###.###"), 58);
} }
else if (risul.sign() > 0) else if (risul.sign() > 0)
{ {
@ -1030,10 +1033,13 @@ void Visliq_app::recalc_next_liq(int start_month, TSheet_field* sl, TSheet_field
int sr0 = (_lim->get_real("R0")).sign(); int sr0 = (_lim->get_real("R0")).sign();
int sr5 = (_lim->get_real("R5")).sign(); int sr5 = (_lim->get_real("R5")).sign();
t.add(((real) abs(_lim->get_real("R0"))).string(),1); real r0abs = abs(_lim->get_real("R0"));
real r5abs = abs(_lim->get_real("R0"));
t.add(r0abs.string(),1);
t.add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"), 2); t.add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"), 2);
t.add((_lim->get_real("R1")).string(),3); t.add((_lim->get_real("R1")).string(),3);
t.add(((real) abs(_lim->get_real("R5"))).string(),4); t.add(r5abs.string(),4);
t.add(sr5 == 0 ? "" : (sr5 > 0 ? "D" : "C"),5); t.add(sr5 == 0 ? "" : (sr5 > 0 ? "D" : "C"),5);
sl->force_update(row); sl->force_update(row);
@ -1131,15 +1137,17 @@ void Visliq_app::read_general(TMask& m)
if (sh.items() < i) tt = new TToken_string(80); if (sh.items() < i) tt = new TToken_string(80);
else tt = &(sh.row(i-1)); else tt = &(sh.row(i-1));
real r0abs = abs(_lim->get_real("R0"));
real r5abs = abs(_lim->get_real("R5"));
tt->add(itoname(i),0); tt->add(itoname(i),0);
tt->add(((real) abs(_lim->get_real("R0"))).string(),1); tt->add(r0abs.string(),1);
int sr0 = (_lim->get_real("R0")).sign(); int sr0 = (_lim->get_real("R0")).sign();
int sr5 = (_lim->get_real("R5")).sign(); int sr5 = (_lim->get_real("R5")).sign();
tt->add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"),2); tt->add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"),2);
tt->add(_lim->get_real("R1").string(),3); tt->add(_lim->get_real("R1").string(),3);
tt->add(((real) abs(_lim->get_real("R5"))).string(),4); tt->add(r5abs.string(),4);
tt->add(sr5 == 0 ? "" : (sr5 > 0 ? "D" : "C"),5); tt->add(sr5 == 0 ? "" : (sr5 > 0 ? "D" : "C"),5);
sh.row(i-1) = (*tt); sh.row(i-1) = (*tt);
@ -1166,6 +1174,8 @@ void Visliq_app::read_general(TMask& m)
if (m >= 12) if (m >= 12)
m = tipod == 7 ? 12 : 13; m = tipod == 7 ? 12 : 13;
// supercauto
if (m <= 0) continue;
versamenti[m-1] += _del->get_real("R0"); versamenti[m-1] += _del->get_real("R0");
date[m-1] = _del->get_date("D0"); date[m-1] = _del->get_date("D0");
@ -1505,10 +1515,13 @@ if (was_lim)
int sr0 = (_lim->get_real("R0")).sign(); int sr0 = (_lim->get_real("R0")).sign();
int sr5 = (_lim->get_real("R5")).sign(); int sr5 = (_lim->get_real("R5")).sign();
tt_ln.add(((real) abs(_lim->get_real("R0"))).string(),1); real r0abs = abs(_lim->get_real("R0"));
real r5abs = abs(_lim->get_real("R5"));
tt_ln.add(r0abs.string(),1);
tt_ln.add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"), 2); tt_ln.add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"), 2);
tt_ln.add((_lim->get_real("R1")).string(),3); tt_ln.add((_lim->get_real("R1")).string(),3);
tt_ln.add(((real) abs(_lim->get_real("R5"))).string(),4); tt_ln.add(r5abs.string(),4);
tt_ln.add(sr5 == 0 ? "" : (sr5 > 0 ? "D" : "C"),5); tt_ln.add(sr5 == 0 ? "" : (sr5 > 0 ? "D" : "C"),5);
// sh.force_update(row); // sh.force_update(row);

3
cg/cg5500t.h
View File

@ -1,12 +1,15 @@
BUTTON DLG_SAVEREC 8 2 BUTTON DLG_SAVEREC 8 2
BEGIN BEGIN
PROMPT -14 -1 "~Registra" PROMPT -14 -1 "~Registra"
PICTURE BMP_SAVEREC
PICTURE BMP_SAVERECDN
MESSAGE EXIT,K_SAVE MESSAGE EXIT,K_SAVE
END END
BUTTON DLG_RECALC 8 2 BUTTON DLG_RECALC 8 2
BEGIN BEGIN
PROMPT -24 -1 "Ri~calcola" PROMPT -24 -1 "Ri~calcola"
PICTURE BMP_RECALC
MESSAGE EXIT,K_INS MESSAGE EXIT,K_INS
END END

2
cg/cg5600.cpp
View File

@ -75,7 +75,7 @@ void TRipristino_liq::build_ditte_sheet()
d->insert(" |", 0); d->insert(" |", 0);
const long pos = _ditte->add(d); const long pos = _ditte->add(d);
if (selectable) _ditte->disable(pos); if (selectable) _ditte->disable_row(pos);
} }
} }

3038
cg/cg6600.cpp
View File

File diff suppressed because it is too large Load Diff

47
cg/cglib.h
View File

@ -39,14 +39,17 @@ public:
}; };
enum tipobil { DataLimite=1, UltimaImmissione }; enum tipobil { DataLimite=1, UltimaImmissione };
enum tiposal { normale, apertura, chiusura };
const int EsePre(const int EseCorr); const int EsePre(const int EseCorr);
class TSaldo class TSaldo
{ {
real _saldo, _saldo_iniziale, _saldoiniziale; TLocalisamfile _saldi;
real _prg_dare, _prg_avere, _prg_daresca, _prg_averesca;
real _saldo, _saldo_iniziale, _saldoiniziale; // oh my GOSH
real _prg_dare, _prg_avere;
int _indbil; int _indbil;
TRectype* _saldo_ep;
int _annoes; int _annoes;
TDate _inizioEs, _fineEs; TDate _inizioEs, _fineEs;
TString16 _codcaus; TString16 _codcaus;
@ -62,14 +65,15 @@ class TSaldo
protected: protected:
void InFinEs(int); void InFinEs(int);
void leggi_mov(long numreg); // Leggi testata bool leggi_mov(long numreg); // Leggi testata
real calcola_saldo_iniziale(int g, int c, long s, int indbil); real calcola_saldo_iniziale(int g, int c, long s, int indbil);
bool prg_saldo(int, TConto&, real&, real&, bool);
public: public:
bool movimentato() const { return _movimentato; } bool movimentato() const { return _movimentato; }
bool significativo() const { return _significativo; } bool significativo() const { return _significativo; }
bool esiste_saldo() const { return _rec_presente_ec || _rec_presente_ep;} bool esiste_saldo() const { return _rec_presente_ec || _rec_presente_ep; }
bool esiste_saldo_ep() const { return _rec_presente_ep; } bool esiste_saldo_ep() const { return _rec_presente_ep; }
int annoes () const { return _annoes; } int annoes () const { return _annoes; }
@ -83,11 +87,13 @@ public:
bool ultima_immissione_verifica(int anno,int g,int c,long s,int indbil,int prov); bool ultima_immissione_verifica(int anno,int g,int c,long s,int indbil,int prov);
bool data_limite_bilancio(int,int,int,long,const TDate&,const TDate&,int,int); bool data_limite_bilancio(int,int,int,long,const TDate&,const TDate&,int,int);
TRectype& ricerca_progr_prec(int, int, int, long); bool ricerca_progr_prec(int, int, int, long);
real saldofin_esprec(int,int,int,long); real saldofin_esprec(int,int,int,long);
bool prg_attuali(int,TConto&,real&,real&); bool prg_attuali(int i,TConto& c, real& p1, real& p2)
bool prg_mov_eliminati(int,TConto&,real&,real&); { return prg_saldo(i, c, p1, p2, FALSE); }
bool prg_mov_eliminati(int i, TConto& c, real& p1, real& p2)
{ return prg_saldo(i, c, p1, p2, TRUE); }
const real& saldo() const { return _saldo;} const real& saldo() const { return _saldo;}
const real& saldoini() const { return _saldo_iniziale;} const real& saldoini() const { return _saldo_iniziale;}
@ -95,10 +101,11 @@ public:
const real& prgdare() const { return _prg_dare;} const real& prgdare() const { return _prg_dare;}
const real& prgavere() const { return _prg_avere;} const real& prgavere() const { return _prg_avere;}
const bool flagprec() { return _prec; } const bool flagprec() { return _prec; }
bool prg_attuali(int,TConto&,int,real&,real&);
bool prg_mov_eliminati(int,TConto&,int,real&,real&); // bool prg_attuali(int i,TConto& c, int d, real& p1, real& p2);
// bool prg_mov_eliminati(int i,TConto& c,int d, real& p1, real& p2);
TSaldo(); TSaldo();
~TSaldo();
}; };
@ -107,18 +114,18 @@ class TTab_conti : public TAssoc_array
{ {
public: public:
void aggiorna_conto(const TBill& tc, int anno_es, const TImporto& importo, void aggiorna_conto(const TBill& tc, int anno_es, const TImporto& importo,
bool movap, bool provv, bool somma, bool movimentato); tiposal movap, bool provv, bool somma, bool movimentato, bool scaricato);
TConto* add(const TBill& c, int anno); TConto* add(const TBill& c, int anno, bool provv = FALSE);
TConto* find(const TBill& c, int anno); TConto* find(const TBill& c, int anno, bool provv = FALSE);
void remove(const TBill& c, int anno); void remove(const TBill& c, int anno, bool provv = FALSE);
}; };
class TSaldo_agg : public TObject class TSaldo_agg : public TObject
{ {
TTab_conti _tab_conti; TTab_conti _tab_conti;
bool _movap; // se e' mov. d'apertura (aggiorno SALDO e FLAGSALINI in saldi) tiposal _movap; // se e' mov. d'apertura (aggiorno SALDO e FLAGSALINI in saldi)
bool _provv; bool _provv;
int _anno_es; // anno esercizio int _anno_es; // anno esercizio
TDate _data_ulmov; // data ultimo movimento TDate _data_ulmov; // data ultimo movimento
@ -130,17 +137,17 @@ class TSaldo_agg : public TObject
public: public:
void clear_saldi(int year); void clear_saldi(int year);
void registra(); void registra();
void aggiorna (const TBill& tc, const TImporto& importo, bool somma=TRUE); void aggiorna (const TBill& tc, const TImporto& importo, bool somma=TRUE, bool scaricato = FALSE);
void aggiorna (int gruppo, int conto, long sottoconto, void aggiorna (int gruppo, int conto, long sottoconto,
const real& importo, char sezione, bool somma=TRUE); const real& importo, char sezione, bool somma=TRUE, bool scaricato = FALSE);
TConto* find(const TBill& c, int anno) { return _tab_conti.find(c, anno); } TConto* find(const TBill& c, int anno) { return _tab_conti.find(c, anno); }
void set_anno_es(int anno) { _anno_es = anno; } void set_anno_es(int anno) { _anno_es = anno; }
int anno_es() const { return _anno_es; } int anno_es() const { return _anno_es; }
void set_movap (bool movap) { _movap = movap; } void set_tipo_saldo (tiposal movap) { _movap = movap; }
bool movap() const { return _movap; } tiposal tipo_saldo() const { return _movap; }
void set_movprovv (bool p) { _provv = p; } void set_movprovv (bool p) { _provv = p; }
bool movprovv() const { return _provv; } bool movprovv() const { return _provv; }

406
cg/cglib01.cpp
View File

@ -1,14 +1,7 @@
// cglib01.cpp // cglib01.cpp
// calcolo dei saldi // calcolo dei saldi
// La compilazione e' gia' lenta da sola: evitare include inutili (Guy)
// #include <applicat.h>
// #include <utility.h>
#include <config.h> #include <config.h>
#include "cglib.h"
#include <rmov.h> #include <rmov.h>
#include <mov.h> #include <mov.h>
#include <saldi.h> #include <saldi.h>
@ -16,15 +9,14 @@
#include <causali.h> #include <causali.h>
#include <clifo.h> #include <clifo.h>
#include "cglib.h"
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Causale // Causale
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
TCaus::TCaus(const char* cod) TCaus::TCaus(const char* cod) : _rec(LF_CAUSALI)
: _rec(LF_CAUSALI)
{ {
//if (*cod) read(cod);
read(cod); read(cod);
} }
@ -57,7 +49,6 @@ bool TCaus::apertura() const
// //
// Cerca l'esercizio precedente di EseCorr // Cerca l'esercizio precedente di EseCorr
// Se EseCorr e' gia' il primo ritorna 0 // Se EseCorr e' gia' il primo ritorna 0
// senno' ritorna il precedente (Stavolta meno astutamente, ma correttamente)
// //
const int EsePre(const int EseCorr) const int EsePre(const int EseCorr)
{ {
@ -80,41 +71,25 @@ TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par)
if (aep_par == 0) if (aep_par == 0)
aep = EsePre(aec); aep = EsePre(aec);
// if (aep)
cf.setkey(2); cf.setkey(2);
/* else
{
cf.setkey(1);
cf.put(SLD_ANNOES,aec);
}
*/
cf.put(SLD_GRUPPO,gr); cf.put(SLD_GRUPPO,gr);
cf.put(SLD_CONTO,co); cf.put(SLD_CONTO,co);
// TRectype rec(cf.curr());
for (cf.read(_isgteq);!cf.eof();cf.next()) for (cf.read(_isgteq);!cf.eof();cf.next())
{ {
// if (cf.curr() > rec) break;
const int ae = cf.get_int(SLD_ANNOES); const int ae = cf.get_int(SLD_ANNOES);
const int g = cf.get_int(SLD_GRUPPO); const int g = cf.get_int(SLD_GRUPPO);
const int c = cf.get_int(SLD_CONTO); const int c = cf.get_int(SLD_CONTO);
const long s = cf.get_long(SLD_SOTTOCONTO); const long s = cf.get_long(SLD_SOTTOCONTO);
if (g != gr || c != co) break; if (g != gr || c != co) break;
// if (aep) {
if (ae != aec && ae != aep) continue; if (ae != aec && ae != aep) continue;
// }
TRectype r(cf.curr()); TRectype r(cf.curr());
key.format("%3d%3d%6ld", g, c, s); key.format("%3d%3d%6ld", g, c, s);
// Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato // Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato
if (aep_par) force = !aep_par;
force = FALSE;
else
force = TRUE;
add((const char*) key, r, force); add((const char*) key, r, force);
} }
} }
@ -122,65 +97,34 @@ TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par)
TRectype* TSaldi_list::saldi() const TRectype* TSaldi_list::saldi() const
{ {
TObject* o = ((TAssoc_array*)this)->get(); TObject* o = ((TAssoc_array*)this)->get();
if (o == NULL)
return (TRectype*)NULL;
else
return (TRectype*)o; return (TRectype*)o;
} }
TSaldo::TSaldo() TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO),
{ _prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0),
_saldo_ep = new TRectype(LF_SALDI); _indbil(0), _prec(FALSE), _movimentato(FALSE), _significativo(FALSE),
_saldo_iniziale = ZERO; _rec_presente_ec(FALSE), _rec_presente_ep(FALSE)
_saldoiniziale = ZERO; {}
_prg_dare = ZERO;
_prg_avere = ZERO;
_saldo = ZERO;
_annoes = 0;
_indbil = 0;
_prec = FALSE;
_movimentato = _significativo = FALSE;
_rec_presente_ec = _rec_presente_ep = FALSE;
}
TSaldo::~TSaldo()
{
delete _saldo_ep;
}
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s) real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
{ {
const int annoesprec = EsePre(annoes); const int annoesprec = EsePre(annoes);
if (annoesprec == 0) // non ci sono esercizi prima del primo
{
_rec_presente_ep = FALSE;
_significativo = FALSE; _significativo = FALSE;
if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo
return ZERO; return ZERO;
}
const TRectype& app = ricerca_progr_prec(annoesprec, g, c, s); const char flag = _saldi.get(SLD_FLAGSALINI)[0];
const real saldo = _saldi.get_real(SLD_SALDO);
const real pdare = _saldi.get_real(SLD_PDARE);
const real pavere = _saldi.get_real(SLD_PAVERE);
const char flag = app.get(SLD_FLAGSALINI)[0];
const real saldo = app.get_real(SLD_SALDO);
const real pdare = app.get_real(SLD_PDARE);
const real pavere = app.get_real(SLD_PAVERE);
//const real pdaresca = app.get_real(SLD_PDARESCA);
//const real paveresca = app.get_real(SLD_PAVERESCA);
/*
_significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO
|| pdaresca != ZERO || paveresca != ZERO);
*/
_significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO); _significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO);
//real tot = pdare-pavere+pdaresca-paveresca;
real tot = pdare-pavere; real tot = pdare-pavere;
if (flag == 'D') if (flag == 'D') tot += saldo;
tot += saldo; else tot -= saldo;
else
tot -= saldo;
return tot; return tot;
} }
@ -188,55 +132,33 @@ real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
//in realta' calcola il saldo finale es.prec //in realta' calcola il saldo finale es.prec
real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil) real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
{ {
real saldoini, pdaresca, paveresca, pdare, pavere; real saldoini;
char flag;
TLocalisamfile saldi(LF_SALDI, FALSE);
_significativo = TRUE; _significativo = TRUE;
saldi.zero(); _saldi.zero();
saldi.put(SLD_GRUPPO,g); _saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c); _saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s); _saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,_annoes); _saldi.put(SLD_ANNOES,_annoes);
if (saldi.read() == NOERR) if (_rec_presente_ec = (_saldi.read() == NOERR))
_rec_presente_ec = TRUE; saldoini = _saldi.get_real(SLD_SALDO);
else
{
saldi.zero();
_rec_presente_ec = FALSE;
}
flag = saldi.get_char(SLD_FLAGSALINI); _significativo = _rec_presente_ec && saldoini != ZERO;
saldoini = saldi.get_real(SLD_SALDO);
_significativo = (saldoini != ZERO);
if (saldoini != ZERO) //non va considerato!!! Vedi appunti if (saldoini != ZERO) //non va considerato!!! Vedi appunti
_saldo_iniziale = ZERO; _saldo_iniziale = ZERO;
if (saldoini == ZERO) if (saldoini == ZERO)
{ {
if ( indbil == 1 || indbil == 2 || indbil == 5 ) if (indbil == 1 || indbil == 2 || indbil == 5)
{ {
_prec = TRUE; _prec = TRUE;
saldoini = saldofin_esprec(_annoes, g, c, s); saldoini = saldofin_esprec(_annoes, g, c, s);
flag = 'D'; // Il segno DEVE essere quello del saldo precedente
} }
_saldo_iniziale = saldoini; _saldo_iniziale = saldoini;
} }
#ifdef DBG
TString sldi(saldoini.string());
#endif
//if (flag == 'D')
//return saldoini;
return _saldo_iniziale; return _saldo_iniziale;
//else
//return (-saldoini);
//return (-_saldo_iniziale);
} }
const char* TSaldo::causale_chiusura_es() const char* TSaldo::causale_chiusura_es()
@ -251,20 +173,22 @@ const char* TSaldo::causale_apertura_es()
return conf.get("CoCaAp"); return conf.get("CoCaAp");
} }
void TSaldo::leggi_mov(long nr) bool TSaldo::leggi_mov(long nr)
{ {
TLocalisamfile mov(LF_MOV, FALSE); TLocalisamfile mov(LF_MOV, FALSE);
bool ok = TRUE;
mov.zero(); mov.zero();
mov.put (MOV_NUMREG,nr); mov.put (MOV_NUMREG,nr);
if (mov.read() == NOERR) if (ok = (mov.read() == NOERR))
{ {
_codcaus = mov.get (MOV_CODCAUS); _codcaus = mov.get (MOV_CODCAUS);
_datareg = mov.get_date(MOV_DATAREG); _datareg = mov.get_date(MOV_DATAREG);
_provv = mov.get (MOV_PROVVIS); _provv = mov.get (MOV_PROVVIS);
_datacomp = mov.get_date(MOV_DATACOMP); _datacomp = mov.get_date(MOV_DATACOMP);
} }
return ok;
} }
//per bilancio scalare (ovvero a sezioni contrapposte) per data limite //per bilancio scalare (ovvero a sezioni contrapposte) per data limite
@ -320,35 +244,26 @@ bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDat
else else
data_mov = _datacomp; data_mov = _datacomp;
} }
if (data_mov < data_inf || data_mov > data_sup) if (data_mov < data_inf || data_mov > data_sup)
continue; continue;
// "Se la causale del movimento e' uguale a quella di chiusura, // "Se la causale del movimento e' uguale a quella di chiusura,
// o di apertura il movimento non va considerato" // o di apertura il movimento non va considerato"
// if (_codcaus.not_empty())
// if (_codcaus == causale_chiusura_es() ||
// _codcaus == causale_apertura_es())
// continue;
// Modifica del 03-03-1995
TCaus cau(_codcaus); TCaus cau(_codcaus);
if (_codcaus.not_empty()) if (_codcaus.not_empty())
if (cau.chiusura()) //|| cau.apertura()) if (cau.chiusura()) continue;
//bilancio normale (non comprende i provvisori) ?
if (stp_prov == 1 && _provv.trim().not_empty())
continue; continue;
/* //bilancio dei soli provvisori ?
if (!stp_prov && _provv.trim().not_empty()) if (stp_prov == 3 && _provv.trim().empty())
continue;
*/
if (stp_prov == 1 && _provv.trim().not_empty()) //bilancio normale (non comprende i provvisori)
continue; continue;
if (stp_prov == 3 && _provv.trim().empty()) //bilancio dei soli provvisori // I mov. di puro riferimento (= con importo = 0) vanno scartati
continue;
// "I mov. di puro riferimento (= con importo = 0) vanno scartati"
if (importo == ZERO) continue; if (importo == ZERO) continue;
gcs_corr.format ("%3d%3d%6ld", gruppo, conto, sottoconto); gcs_corr.format ("%3d%3d%6ld", gruppo, conto, sottoconto);
@ -360,10 +275,6 @@ bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDat
_saldo = calcola_saldo_iniziale(gruppo,conto,sottoconto,indbil); _saldo = calcola_saldo_iniziale(gruppo,conto,sottoconto,indbil);
} }
#ifdef DBG
TString dep1(_saldo.string());
#endif
_movimentato = TRUE; _movimentato = TRUE;
if (sezione == 'D') if (sezione == 'D')
@ -371,9 +282,6 @@ bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDat
else else
_saldo -= importo; _saldo -= importo;
} }
#ifdef DBG
TString dep2(_saldo.string());
#endif
// Anche se non movimentato vado a vedere il saldo // Anche se non movimentato vado a vedere il saldo
if (!_movimentato) if (!_movimentato)
@ -394,47 +302,36 @@ bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil
real pdarepro, paverepro; real pdarepro, paverepro;
bool esito = FALSE; bool esito = FALSE;
TLocalisamfile saldi(LF_SALDI);
_saldo_iniziale = ZERO; _saldo_iniziale = ZERO;
_saldoiniziale = ZERO; _saldoiniziale = ZERO;
_prg_dare = ZERO; _prg_dare = ZERO;
_prg_avere = ZERO; _prg_avere = ZERO;
_prg_daresca = ZERO;
_prg_averesca = ZERO;
_saldo = ZERO; _saldo = ZERO;
saldi.zero(); _saldi.zero();
_saldi.put(SLD_ANNOES,annoes);
_saldi.put(SLD_GRUPPO,g);
_saldi.put(SLD_CONTO,c);
_saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes); if (_saldi.read() == NOERR)
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
if (saldi.read() == NOERR)
{ {
annoe = saldi.get_int(SLD_ANNOES); annoe = _saldi.get_int(SLD_ANNOES);
gruppo = saldi.get_int(SLD_GRUPPO); gruppo = _saldi.get_int(SLD_GRUPPO);
conto = saldi.get_int(SLD_CONTO); conto = _saldi.get_int(SLD_CONTO);
sottoconto = saldi.get_long(SLD_SOTTOCONTO); sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = saldi.get_real(SLD_SALDO); _saldo_iniziale = _saldi.get_real(SLD_SALDO);
_prg_dare = saldi.get_real(SLD_PDARE); _prg_dare = _saldi.get_real(SLD_PDARE);
_prg_avere = saldi.get_real(SLD_PAVERE); _prg_avere = _saldi.get_real(SLD_PAVERE);
pdarepro = saldi.get_real(SLD_PDAREPRO); pdarepro = _saldi.get_real(SLD_PDAREPRO);
paverepro = saldi.get_real(SLD_PAVEREPRO); paverepro = _saldi.get_real(SLD_PAVEREPRO);
sezione = saldi.get_char(SLD_FLAGSALINI); sezione = _saldi.get_char(SLD_FLAGSALINI);
if (stp_prov == 1) //bilancio normale (senza provvisori) if (stp_prov == 1) //bilancio normale (senza provvisori)
if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO) if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO)
return esito; return esito;
if (stp_prov == 2) //bilancio globale (con provvisori) if (stp_prov == ZERO && paverepro == ZERO)
if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO
&& pdarepro == ZERO && paverepro == ZERO)
return esito;
if (stp_prov == 3) //bilancio dei soli mov. provvisori
if (pdarepro == ZERO && paverepro == ZERO)
return esito; return esito;
if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale; if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
@ -476,42 +373,34 @@ bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil
long sottoconto; long sottoconto;
real pdarepro, paverepro; real pdarepro, paverepro;
bool esito = FALSE; bool esito = FALSE;
TLocalisamfile saldi(LF_SALDI, FALSE);
_saldo_iniziale = ZERO; _saldo_iniziale = ZERO;
_prg_dare = ZERO; _prg_dare = ZERO;
_prg_avere = ZERO; _prg_avere = ZERO;
_prg_daresca = ZERO;
_prg_averesca = ZERO;
_saldo = ZERO; _saldo = ZERO;
_rec_presente_ec = FALSE; _rec_presente_ec = FALSE;
_rec_presente_ep = FALSE; _rec_presente_ep = FALSE;
_prec = FALSE; _prec = FALSE;
saldi.zero(); _saldi.zero();
_saldi.put(SLD_ANNOES,annoes);
_saldi.put(SLD_GRUPPO,g);
_saldi.put(SLD_CONTO,c);
_saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes); if (_saldi.read() == NOERR)
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
if (saldi.read() == NOERR)
{ {
annoe = saldi.get_int(SLD_ANNOES); annoe = _saldi.get_int(SLD_ANNOES);
gruppo = saldi.get_int(SLD_GRUPPO); gruppo = _saldi.get_int(SLD_GRUPPO);
conto = saldi.get_int(SLD_CONTO); conto = _saldi.get_int(SLD_CONTO);
sottoconto = saldi.get_long(SLD_SOTTOCONTO); sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = saldi.get_real(SLD_SALDO); _saldo_iniziale = _saldi.get_real(SLD_SALDO);
_prg_dare = saldi.get_real(SLD_PDARE); _prg_dare = _saldi.get_real(SLD_PDARE);
_prg_avere = saldi.get_real(SLD_PAVERE); _prg_avere = _saldi.get_real(SLD_PAVERE);
pdarepro = saldi.get_real(SLD_PDAREPRO); pdarepro = _saldi.get_real(SLD_PDAREPRO);
paverepro = saldi.get_real(SLD_PAVEREPRO); paverepro = _saldi.get_real(SLD_PAVEREPRO);
sezione = saldi.get_char(SLD_FLAGSALINI); sezione = _saldi.get_char(SLD_FLAGSALINI);
/*
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
|| _prg_daresca != ZERO || _prg_averesca != ZERO);
*/
if (stp_prov == 1) //bilancio normale (senza provvisori) if (stp_prov == 1) //bilancio normale (senza provvisori)
esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO); esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO);
@ -535,7 +424,6 @@ bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil
_saldo_iniziale += saldofin_esprec(annoes,g,c,s); _saldo_iniziale += saldofin_esprec(annoes,g,c,s);
} }
//_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
if (stp_prov == 1) if (stp_prov == 1)
_saldo = _saldo_iniziale + _prg_dare - _prg_avere; _saldo = _saldo_iniziale + _prg_dare - _prg_avere;
@ -548,108 +436,60 @@ bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil
return esito; return esito;
} }
TRectype& TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s) bool TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{ {
TLocalisamfile saldi(LF_SALDI); if (annoesprec == 0)
// Tre righe inutili che vengono gia' eseguite da TLocalisamfile (Guy)
const int oldkey = saldi.getkey();
saldi.setkey(1);
saldi.zero();
saldi.put(SLD_ANNOES,annoesprec);
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
if (saldi.read() == NOERR)
_rec_presente_ep = TRUE;
else
{
saldi.zero();
_rec_presente_ep = FALSE; _rec_presente_ep = FALSE;
}
*_saldo_ep = saldi.curr();
// riposiziona... 7 righe inutili (Guy)
saldi.setkey(oldkey);
saldi.zero();
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoesprec+1); // Astuto anche questo (Guy)
saldi.read(_isequal);
return (*_saldo_ep);
}
//calcolo dei progressivi attuali
bool TSaldo::prg_attuali(int annoes,TConto& conto,real& prgdare,real& prgavere)
{
real saldoini = ZERO;
real pdare = ZERO;
real pavere = ZERO;
real pdaresca = ZERO;
real paveresca = ZERO;
char flagsalini;
int g = conto.gruppo();
int c = conto.conto();
long s = conto.sottoconto();
TLocalisamfile saldi(LF_SALDI, FALSE);
saldi.zero();
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes);
if (saldi.read() == NOERR)
{
flagsalini = saldi.get_char(SLD_FLAGSALINI);
saldoini = saldi.get_real(SLD_SALDO);
pdare = saldi.get_real(SLD_PDARE);
pavere = saldi.get_real(SLD_PAVERE);
pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA);
if (flagsalini == 'D')
{
prgdare = saldoini + pdare + pdaresca;
prgavere = pavere + paveresca;
}
else else
{ {
prgdare = pdare + pdaresca; const int oldkey = _saldi.getkey();
prgavere = saldoini + pavere + paveresca; _saldi.zero();
_saldi.put(SLD_ANNOES,annoesprec);
_saldi.put(SLD_GRUPPO,g);
_saldi.put(SLD_CONTO,c);
_saldi.put(SLD_SOTTOCONTO,s);
_rec_presente_ep = _saldi.read() == NOERR;
_saldi.setkey(oldkey);
} }
} return _rec_presente_ep;
return TRUE;
} }
bool TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prgavere) //calcolo dei progressivi attuali (normali o eliminati)
bool TSaldo::prg_saldo(int annoes, TConto& conto, real& prgdare, real& prgavere, bool scar)
{ {
real saldoini = ZERO; _saldi.zero();
real pdaresca = ZERO; _saldi.put(SLD_GRUPPO,conto.gruppo());
real paveresca = ZERO; _saldi.put(SLD_CONTO,conto.conto());
char flagsalini; _saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
int g = conto.gruppo(); _saldi.put(SLD_ANNOES,annoes);
int c = conto.conto();
long s = conto.sottoconto();
TLocalisamfile saldi(LF_SALDI, FALSE);
saldi.zero(); bool ok = _saldi.read() == NOERR;
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes);
if (saldi.read() == NOERR) if (ok)
{
char flagsalini = _saldi.get_char(SLD_FLAGSALINI);
real saldoini = _saldi.get_real(SLD_SALDO);
real pdare = _saldi.get_real(SLD_PDARE);
real pavere = _saldi.get_real(SLD_PAVERE);
real pdaresca, paveresca;
// look for scaricated
_saldi.zero();
_saldi.put(SLD_GRUPPO,conto.gruppo());
_saldi.put(SLD_CONTO,conto.conto());
_saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
_saldi.put(SLD_ANNOES,annoes);
_saldi.put(SLD_FLSCA, "X");
if (_saldi.read() == NOERR)
{
pdaresca = _saldi.get_real(SLD_PDARE);
paveresca = _saldi.get_real(SLD_PAVERE);
}
// fill reals with proper kanker
if (scar)
{ {
flagsalini = saldi.get(SLD_FLAGSALINI)[0];
saldoini = saldi.get_real(SLD_SALDO);
pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA);
if (flagsalini == 'D') if (flagsalini == 'D')
{ {
prgdare = saldoini + pdaresca; prgdare = saldoini + pdaresca;
@ -661,10 +501,24 @@ bool TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prga
prgavere = saldoini + paveresca; prgavere = saldoini + paveresca;
} }
} }
return TRUE; else
{
if (flagsalini == 'D')
{
prgdare = saldoini + pdare + pdaresca;
prgavere = pavere + paveresca;
}
else
{
prgdare = pdare + pdaresca;
prgavere = saldoini + pavere + paveresca;
}
}
}
return ok;
} }

111
cg/cglib02.cpp
View File

@ -6,56 +6,80 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#include <stdlib.h> #include <stdlib.h>
#include <prefix.h> #include <prefix.h>
#include <utility.h> #include <utility.h>
#include <saldi.h>
#include "cglib.h" #include "cglib.h"
#include <saldi.h> class TContoExt : public TConto
{
bool _scaricato;
TConto* TTab_conti::add(const TBill& c, int anno) public:
bool scaricato() { return _scaricato; }
TContoExt(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL, bool sc = FALSE)
: TConto(g, c, s, t, d), _scaricato(sc) {}
TContoExt(TToken_string& tgcsd, int from, int mode = 0, bool sc = FALSE)
: TConto(tgcsd, from, mode), _scaricato(sc) {}
virtual ~TContoExt() {}
};
TConto* TTab_conti::add(const TBill& c, int anno, bool scar)
{ {
TString80 key; TString80 key;
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto()); key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
TConto* tc = new TConto(c.gruppo(), c.conto(), c.sottoconto(), c.tipo()); if (scar) key << "X";
TContoExt* tc = new TContoExt(c.gruppo(), c.conto(), c.sottoconto(),
c.tipo(), NULL, scar);
TAssoc_array::add(key, tc); TAssoc_array::add(key, tc);
return tc; return tc;
} }
TConto* TTab_conti::find(const TBill& c, int anno) TConto* TTab_conti::find(const TBill& c, int anno, bool scar)
{ {
TString80 key; TString80 key;
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto()); key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
TConto* tc = (TConto*)objptr(key); if (scar) key << "X";
TContoExt* tc = (TContoExt*)objptr(key);
return tc; return tc;
} }
void TTab_conti::remove(const TBill& c, int anno) void TTab_conti::remove(const TBill& c, int anno, bool scar)
{ {
TString80 key; TString80 key;
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto()); key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
if (scar) key << "X";
TAssoc_array::remove(key); TAssoc_array::remove(key);
} }
void TTab_conti::aggiorna_conto(const TBill& tcon, void TTab_conti::aggiorna_conto(const TBill& tcon,
int anno_es, const TImporto& importo, bool movap, int anno_es, const TImporto& importo, tiposal movap,
bool provv, bool somma, bool movimentato) bool provv, bool somma, bool movimentato, bool scaricato)
{ {
TConto* tc = find(tcon, anno_es); TContoExt* tc = (TContoExt*)find(tcon, anno_es, scaricato);
if (tc == NULL) if (tc == NULL)
tc = add(tcon, anno_es); tc = (TContoExt*)add(tcon, anno_es, scaricato);
const real i(somma ? importo.valore() : -importo.valore()); const real i(somma ? importo.valore() : -importo.valore());
if (movap) if (movap == apertura)
{ {
if (importo.sezione() == 'D') if (importo.sezione() == 'D')
tc->saldo() += i; tc->saldo() += i;
else else
tc->saldo() -= i; tc->saldo() -= i;
} }
else if (movap == chiusura)
{
if (importo.sezione() == 'D')
tc->saldofin() += i;
else else
tc->saldofin() -= i;
}
else
{
if (provv) if (provv)
{ {
if (importo.sezione() == 'D') if (importo.sezione() == 'D')
@ -70,35 +94,31 @@ void TTab_conti::aggiorna_conto(const TBill& tcon,
else else
tc->avere() += i; tc->avere() += i;
} }
}
// rimuovo dalla tabella il conto se dare e avere vanno a zero // rimuovo dalla tabella il conto se dare e avere vanno a zero
if (!movimentato) if (!movimentato)
if (tc->dare().is_zero() && tc->avere().is_zero() && if (tc->dare().is_zero() && tc->avere().is_zero() &&
tc->darepro().is_zero() && tc->averepro().is_zero() && tc->saldofin().is_zero() && tc->darepro().is_zero() &&
tc->saldo().is_zero()) tc->averepro().is_zero() && tc->saldo().is_zero())
remove(*tc, anno_es); remove(*tc, anno_es, scaricato);
} }
TSaldo_agg::TSaldo_agg() TSaldo_agg::TSaldo_agg() : _anno_es(0), _data_ulmov(""), _num_ulmov(0l),
_movap(normale), _provv(FALSE), _movimentato(FALSE)
{}
void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma, bool scaricato)
{ {
_anno_es = 0; _tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato);
_data_ulmov = "";
_num_ulmov = 0l;
_movap = FALSE;
_provv = FALSE;
_movimentato = FALSE;
// reset(); // INUTILE pulizia dell'array dei conti
} }
void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma) void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione,
{ bool somma, bool scaricato)
_tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato);
}
void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione, bool somma)
{ {
const TImporto imp(sezione, importo); const TImporto imp(sezione, importo);
_tab_conti.aggiorna_conto(TBill(gruppo, conto, sottoconto), _anno_es, imp, _movap, _provv, somma, _movimentato); _tab_conti.aggiorna_conto(TBill(gruppo, conto, sottoconto), _anno_es, imp, _movap,
_provv, somma, _movimentato, scaricato);
} }
void TSaldo_agg::reset() void TSaldo_agg::reset()
@ -148,8 +168,9 @@ void TSaldo_agg::clear_saldi(int year)
// Scorro la tabella dei conti interna _tab_conti. // Scorro la tabella dei conti interna _tab_conti.
// Per ogni conto cerco il record su saldi, se non c'e' lo creo. // Per ogni conto cerco il record su saldi, se non c'e' lo creo.
// Se c'e' gia' lo aggiorno nel seguente modo: // Se c'e' gia' lo aggiorno nel seguente modo:
// // GLOP
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
void TSaldo_agg::registra() void TSaldo_agg::registra()
{ {
real si, r; real si, r;
@ -163,14 +184,16 @@ void TSaldo_agg::registra()
for (int i = 0; i < conti; i++) for (int i = 0; i < conti; i++)
{ {
THash_object* hobj = _tab_conti.get_hashobj(); THash_object* hobj = _tab_conti.get_hashobj();
TConto& tcon = (TConto &)hobj->obj(); TContoExt& tcon = (TContoExt&)hobj->obj();
CHECK(tcon.ok(), "Tentavi di saldare un conto incompleto, eh?"); CHECK(tcon.ok(), "Tentavi di saldare un conto incompleto, eh? Mapporcodio! Stronzone!");
saldi.zero(); saldi.zero();
saldi.put(SLD_ANNOES, atoi(hobj->key().left(4)) ); saldi.put(SLD_ANNOES, atoi(hobj->key().left(4)) );
saldi.put(SLD_GRUPPO, tcon.gruppo()); saldi.put(SLD_GRUPPO, tcon.gruppo());
saldi.put(SLD_CONTO, tcon.conto()); saldi.put(SLD_CONTO, tcon.conto());
saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
if (tcon.scaricato())
saldi.put(SLD_FLSCA, "X");
bool update = TRUE; bool update = TRUE;
@ -181,6 +204,9 @@ void TSaldo_agg::registra()
saldi.put(SLD_GRUPPO, tcon.gruppo()); saldi.put(SLD_GRUPPO, tcon.gruppo());
saldi.put(SLD_CONTO, tcon.conto()); saldi.put(SLD_CONTO, tcon.conto());
saldi.put(SLD_SOTTOCONTO, tcon.sottoconto()); saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
if (tcon.scaricato())
saldi.put(SLD_FLSCA, "X");
si = tcon.saldo(); si = tcon.saldo();
if (si < ZERO) if (si < ZERO)
{ flag_salini = 'A'; si = -si; } { flag_salini = 'A'; si = -si; }
@ -189,10 +215,15 @@ void TSaldo_agg::registra()
saldi.put(SLD_FLAGSALINI, flag_salini); saldi.put(SLD_FLAGSALINI, flag_salini);
saldi.put(SLD_SALDO, si); saldi.put(SLD_SALDO, si);
saldi.put(SLD_PDAREPRO, tcon.darepro());
saldi.put(SLD_PAVEREPRO, tcon.averepro());
saldi.put(SLD_PDARE, tcon.dare()); saldi.put(SLD_PDARE, tcon.dare());
real sf = tcon.saldofin();
char flag_salfin = sf < ZERO ? 'A' : 'D';
if (flag_salfin == 'A') sf = -sf;
saldi.put(SLD_FLAGSALFIN, flag_salfin);
saldi.put(SLD_SALDOFIN, sf);
saldi.put(SLD_PAVERE, tcon.avere()); saldi.put(SLD_PAVERE, tcon.avere());
if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov); if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_ulmov);
if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov); if (_data_ulmov.ok()) saldi.put(SLD_DATAULMOV, _data_ulmov);
@ -226,12 +257,6 @@ void TSaldo_agg::registra()
saldi.put(SLD_FLAGSALINI, flag_salini); saldi.put(SLD_FLAGSALINI, flag_salini);
saldi.put(SLD_SALDO, si); saldi.put(SLD_SALDO, si);
} }
r = saldi.get_real(SLD_PDAREPRO);
r += tcon.darepro();
saldi.put(SLD_PDAREPRO, r);
r = saldi.get_real(SLD_PAVEREPRO);
r += tcon.averepro();
saldi.put(SLD_PAVEREPRO, r);
r = saldi.get_real(SLD_PDARE); r = saldi.get_real(SLD_PDARE);
r += tcon.dare(); r += tcon.dare();
saldi.put(SLD_PDARE, r); saldi.put(SLD_PDARE, r);
@ -241,11 +266,9 @@ void TSaldo_agg::registra()
const int err = saldi.rewrite(); const int err = saldi.rewrite();
if (err != NOERR) if (err != NOERR)
{
yesnofatal_box("Errore %d nell'aggiornamento del saldo %d %d %ld", yesnofatal_box("Errore %d nell'aggiornamento del saldo %d %d %ld",
err, tcon.gruppo(), tcon.conto(), tcon.sottoconto()); err, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
} }
}
TImporto sf(flag_salini, si); TImporto sf(flag_salini, si);
const TImporto dare('D', saldi.get_real(SLD_PDARE)); const TImporto dare('D', saldi.get_real(SLD_PDARE));

17
cg/cglib04.cpp
View File

@ -4,6 +4,7 @@
#include <progind.h> #include <progind.h>
#include <stdlib.h> #include <stdlib.h>
#include <extcdecl.h> #include <extcdecl.h>
#include "cglib.h"
#include "cglib04.h" #include "cglib04.h"
const int size = 256; //Lunghezza del record del TRASFER const int size = 256; //Lunghezza del record del TRASFER
@ -3461,17 +3462,9 @@ const char* riconverti (TString& data_PC,bool anno_di_quattro)
int date2esc(const TDate& d, int* prevesc) int date2esc(const TDate& d, int* prevesc)
{ {
if (prevesc) *prevesc = 0; TEsercizi_contabili esc;
TTable esc("ESC"); int e = esc.date2esc(d);
for (int err = esc.first(); err == NOERR; err = esc.next()) if (prevesc) *prevesc = esc.pred(e);
{ return e;
const TDate ia(esc.get("D0")); // Data inizio esercizio
const TDate fa(esc.get("D1")); // Data fine esercizio
const anno = esc.get_int("CODTAB");
if (d >= ia && d <= fa)
return anno;
if (prevesc) *prevesc = anno;
}
return 0;
} }

7
cg/conto.h
View File

@ -85,14 +85,14 @@ enum TIndbil { ib_null, ib_attivita, ib_passivita, ib_costi, ib_ricavi, ib_conti
class TConto : public TBill class TConto : public TBill
{ {
real _dare, _avere, _darepro, _averepro, _saldo; real _dare, _avere, _darepro, _averepro, _saldofin, _saldo;
TImporto _saldo_finale; TImporto _saldo_finale;
public: public:
TConto(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL) TConto(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL)
: TBill(g, c, s, t, d) {} : TBill(g, c, s, t, d) {}
TConto (TToken_string& tgcsd, int from, int mode = 0) TConto (TToken_string& tgcsd, int from, int mode = 0)
: TBill(tgcsd, from, mode) {}; : TBill(tgcsd, from, mode) {}
real& dare() { return _dare; } real& dare() { return _dare; }
const real& dare() const { return _dare; } const real& dare() const { return _dare; }
@ -109,6 +109,9 @@ public:
real& saldo() { return _saldo; } real& saldo() { return _saldo; }
const real& saldo() const { return _saldo; } const real& saldo() const { return _saldo; }
real& saldofin() { return _saldofin; }
const real& saldofin() const { return _saldofin; }
TImporto& saldo_finale() { return _saldo_finale; } TImporto& saldo_finale() { return _saldo_finale; }
const TImporto& saldo_finale() const { return _saldo_finale; } const TImporto& saldo_finale() const { return _saldo_finale; }
}; };