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_CONTO, conto);
_saldi->put(PCN_SOTTOCONTO, sottoc);
_saldi->read(_isgteq);
_saldi->read();
bool ok = FALSE;
if (_saldi->good())
ok = _saldi->get_real(SLD_SALDO) != ZERO ||
_saldi->get_real(SLD_PDARE) != 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_PAVEREPRO) != ZERO;
return ok && gruppo ==_saldi->get_int(PCN_GRUPPO) &&
ok &= (gruppo ==_saldi->get_int(PCN_GRUPPO) &&
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();
pconti.zero() ;
@ -216,7 +245,6 @@ HIDDEN bool tmcf_handler(TMask_field& f, KEY key)
void CG0100_application::init_insert_mode(TMask& m)
{
const int gruppo = atoi(m.get(FLD_CM1_GRUPPO));
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:
TDate _inizioEs, _fineEs;
bool menu (MENU_TAG m) { return TPrintapp::menu(m) ; }
virtual bool user_create() ;
@ -162,7 +163,7 @@ public:
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)
{
@ -1503,7 +1504,7 @@ if (movimentato || _stampav != 1)
mov_conto_avere += _mov_periodo_avere;
prg_conto_dare += _prg_prec_dare;
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
if (_verifica != 2)

12
cg/cg2100.cpp
View File

@ -1,4 +1,4 @@
#include <config.h>
#include <config.h>
#include <mailbox.h>
#include <urldefid.h>
#include <execp.h>
@ -635,7 +635,9 @@ int TPrimanota_application::read(TMask& m)
_saldi.reset(); // Azzera saldi
_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_num_ulmov(numreg);
_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);
_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_num_ulmov(numreg);
_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.set_movprovv(FALSE);
_saldi.set_movap(FALSE);
_saldi.set_tipo_saldo(normale);
_saldi.set_anno_es(m.get_int(F_ANNOES));
_saldi.set_num_ulmov(_lastreg);
_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
{ return _rec.get_char(CAU_MOVAP) == 'A'; }
bool TCausale::chiusura() const
{ return _rec.get_char(CAU_MOVAP) == 'C'; }
bool TCausale::sezionale() const
{ return _rec.get_bool(CAU_MOVSEZ); }

1
cg/cg2103.h
View File

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

9
cg/cg2200.cpp
View File

@ -97,15 +97,18 @@ void TProvvisori_app::inizia_saldi(const TRectype& r)
_saldi.reset();
bool apertura = FALSE;
tiposal tsal = normale;
const TString& c = r.get(MOV_CODCAUS);
if (c.not_empty())
{
_cau->put(CAU_CODCAUS, c);
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_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()
{
/* 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);
real pdaresca,paveresca,pdarescap,paverescap;
real progdare_attuale,progavere_attuale,progdare_prec,progavere_prec;
@ -2942,23 +2947,49 @@ void TMastrini_application::calcola_progressivi()
if (annoes_saldi == _anno_corrente)
{
pdaresca = saldi.get_real(SLD_PDARESCA);
paveresca = saldi.get_real(SLD_PAVERESCA);
pdaresca = ZERO;
paveresca = ZERO;
progdare_attuale = saldi.get_real(SLD_PDARE);
progavere_attuale = saldi.get_real(SLD_PAVERE);
saldo = saldi.get_real(SLD_SALDO);
salini = saldi.get(SLD_FLAGSALINI)[0];
_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
if (annoes_saldi == _anno_precedente)
{
pdarescap = saldi.get_real(SLD_PDARESCA);
pdarescap = ZERO;
pdarep = saldi.get_real(SLD_PDARE);
paverescap = saldi.get_real(SLD_PAVERESCA);
paverescap = ZERO;
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

15
cg/cg4100.cpp
View File

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

1
cg/cg4100b.uml
View File

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

4
cg/cg4600.cpp
View File

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

16
cg/cg5100a.uml
View File

@ -20,6 +20,11 @@ ENDPAGE
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
BEGIN
PROMPT 2 0 "@bANNO LIQUIDAZIONE IVA "
@ -44,11 +49,6 @@ BEGIN
FIELD PcTcCm
END
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 1 "Archivi in comune"
END
GROUPBOX DLG_NULL 76 8
BEGIN
@ -180,7 +180,7 @@ END
ENDPAGE
PAGE "Impostazione parametri ditta" -1 -1 77 8
PAGE "Pag. 2" -1 -1 77 8
GROUPBOX DLG_NULL 78 12
BEGIN
@ -687,7 +687,7 @@ END
ENDPAGE
PAGE "Impostazione parametri ditta" -1 -1 77 8
PAGE "Pag. 3" -1 -1 77 8
GROUPBOX DLG_NULL 78 10
BEGIN
@ -695,7 +695,7 @@ BEGIN
END
RADIOBUTTON LST_RRFRAM 16
RADIOBUTTON LST_RRFRAM 20
BEGIN
PROMPT 3 2 ""
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_FORN 110
#define F_SHEET_SALDI 111
#define F_SCARICATO 112

55
cg/cg5200a.uml
View File

@ -25,6 +25,11 @@ BEGIN
FLAGS "Z"
END
BOOLEAN F_SCARICATO
BEGIN
PROMPT 40 1 "Solo saldi dei movimenti scaricati"
END
GROUPBOX DLG_NULL 73 4
BEGIN
PROMPT 3 2 ""
@ -214,8 +219,10 @@ BEGIN
ITEM " Avere@15"
ITEM " Saldo@15"
ITEM ""
ITEM "Progr.Mov.Elim.: Dare@15"
ITEM " Avere@15"
// ITEM "Progr.Mov.Elim.: Dare@15"
// ITEM " Avere@15"
ITEM "Saldo di chiusura@15"
ITEM ""
ITEM "Saldo complessivo"
ITEM ""
ITEM "Ult.Op.: Data"
@ -224,6 +231,8 @@ BEGIN
ITEM " Avere@15"
ITEM " Saldo@15"
ITEM ""
ITEM "Progr.Mov.Elim.: Dare@15"
ITEM " Avere@15"
END
ENDPAGE
@ -285,10 +294,11 @@ BEGIN
HELP "Sezione del saldo attuale del conto"
END
/* =====================================================================
NUMBER 108 15
BEGIN
PROMPT 1 6 "Progr.Mov.Eliminati: Dare "
HELP "Progressivi dare attuali dei moviementi eliminati"
HELP "Progressivi dare attuali dei movimenti eliminati"
FLAGS "R"
PICTURE "."
END
@ -296,10 +306,26 @@ END
NUMBER 109 15
BEGIN
PROMPT 45 6 "Avere "
HELP "Progressivi avere attuali dei moviementi eliminati"
HELP "Progressivi avere attuali dei movimenti eliminati"
FLAGS "R"
PICTURE "."
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
BEGIN
@ -333,7 +359,7 @@ END
NUMBER 114 15
BEGIN
PROMPT 1 10 "Progr.Mov.Provvisori: Dare "
HELP "Progressivi dare attuali dei moviementi provvisori"
HELP "Progressivi dare attuali dei movimenti provvisori"
FLAGS "R"
PICTURE "."
END
@ -341,7 +367,7 @@ END
NUMBER 115 15
BEGIN
PROMPT 45 10 "Avere "
HELP "Progressivi avere attuali dei moviementi provvisori del conto"
HELP "Progressivi avere attuali dei movimenti provvisori del conto"
FLAGS "R"
PICTURE "."
END
@ -361,6 +387,23 @@ BEGIN
FLAGS "R"
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
BEGIN
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);
const TString16 att = tt.get(0);
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->put("CODTAB", codtab);
@ -264,7 +264,7 @@ int TParaliq_app::rewrite(const TMask& m)
lia.put("CODTAB", format("%05ld%d", firm, year));
was = lia.read() == NOERR;
if (!was) lia.zero();
m.autosave(_rel);
m.autosave(*_rel);
if (err == NOERR) err = (was ? lia.rewrite() : lia.write());
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
// prende le attivita' una per una da _atts e
// crea le righe sheet
m.autoload(get_relation());
m.autoload(*get_relation());
const long firm = m.get_long(F_CODDITTA);
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
PROMPT 1 10 "Parametri attivita'"
ITEM "Attivita'@5F"
ITEM "Tipo@1"
ITEM "Tipo@9"
ITEM "% Pro-rata@6"
ITEM "Plafond art.8@15"
ITEM "Plafond art.8b@15"
@ -131,8 +131,8 @@ BEGIN
HELP "Tipo di attivita' della ditta"
FLAGS "U"
ITEM " |Altre"
ITEM "E|Mista evidenziata"
ITEM "S|Servizio o mista generica"
ITEM "E|Mista evid."
ITEM "S|Serv. o mista gen."
END
NUMBER F_PRORATA 6 2

2
cg/cg5400a.uml
View File

@ -91,7 +91,7 @@ BEGIN
WARNING "Registro assente"
END
LIST F_TIPO
LIST F_TIPO 15
BEGIN
FLAGS "HG"
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);
bool selectable = vers == '?';
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);
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_RAGSOC).set(row.get(1));
@ -321,7 +321,7 @@ bool Visliq_app::set_ragsoc(TMask_field& f, KEY k)
TString ts(row.get(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_RAGSOC).set(row.get(1));
@ -602,7 +602,8 @@ bool Visliq_app::vis_one(int m)
msk.field(F_RIMBORSO).set(rimborso.string());
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");
}
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)
{
vsw->replace(lrettc, ((real) abs(rett)).string("###.###.###.###"), 58);
real rabs = abs(rett);
vsw->replace(lrettc, rabs.string("###.###.###.###"), 58);
vsw->replace(lrettd, " ", 75);
}
else
@ -930,8 +932,9 @@ void Visliq_app::recalc_liq_data(TViswin* vsw, real& rimb, real& rett, real& ver
if (risul.sign() < 0)
{
real rabs = abs(risul);
ln.overwrite("CREDITO ATTUALE", 23);
ln.overwrite(((real) abs(risul)).string("###.###.###.###"), 58);
ln.overwrite(rabs.string("###.###.###.###"), 58);
}
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 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((_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);
sl->force_update(row);
@ -1131,15 +1137,17 @@ void Visliq_app::read_general(TMask& m)
if (sh.items() < i) tt = new TToken_string(80);
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(((real) abs(_lim->get_real("R0"))).string(),1);
tt->add(r0abs.string(),1);
int sr0 = (_lim->get_real("R0")).sign();
int sr5 = (_lim->get_real("R5")).sign();
tt->add(sr0 == 0 ? "" : (sr0 > 0 ? "D" : "C"),2);
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);
sh.row(i-1) = (*tt);
@ -1166,6 +1174,8 @@ void Visliq_app::read_general(TMask& m)
if (m >= 12)
m = tipod == 7 ? 12 : 13;
// supercauto
if (m <= 0) continue;
versamenti[m-1] += _del->get_real("R0");
date[m-1] = _del->get_date("D0");
@ -1505,10 +1515,13 @@ if (was_lim)
int sr0 = (_lim->get_real("R0")).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((_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);
// sh.force_update(row);

3
cg/cg5500t.h
View File

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

2
cg/cg5600.cpp
View File

@ -75,7 +75,7 @@ void TRipristino_liq::build_ditte_sheet()
d->insert(" |", 0);
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 tiposal { normale, apertura, chiusura };
const int EsePre(const int EseCorr);
class TSaldo
{
real _saldo, _saldo_iniziale, _saldoiniziale;
real _prg_dare, _prg_avere, _prg_daresca, _prg_averesca;
TLocalisamfile _saldi;
real _saldo, _saldo_iniziale, _saldoiniziale; // oh my GOSH
real _prg_dare, _prg_avere;
int _indbil;
TRectype* _saldo_ep;
int _annoes;
TDate _inizioEs, _fineEs;
TString16 _codcaus;
@ -62,14 +65,15 @@ class TSaldo
protected:
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);
bool prg_saldo(int, TConto&, real&, real&, bool);
public:
bool movimentato() const { return _movimentato; }
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; }
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 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);
bool prg_attuali(int,TConto&,real&,real&);
bool prg_mov_eliminati(int,TConto&,real&,real&);
bool prg_attuali(int i,TConto& c, real& p1, real& p2)
{ 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& saldoini() const { return _saldo_iniziale;}
@ -95,10 +101,11 @@ public:
const real& prgdare() const { return _prg_dare;}
const real& prgavere() const { return _prg_avere;}
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();
};
@ -107,18 +114,18 @@ class TTab_conti : public TAssoc_array
{
public:
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* find(const TBill& c, int anno);
void remove(const TBill& c, int anno);
TConto* add(const TBill& c, int anno, bool provv = FALSE);
TConto* find(const TBill& c, int anno, bool provv = FALSE);
void remove(const TBill& c, int anno, bool provv = FALSE);
};
class TSaldo_agg : public TObject
{
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;
int _anno_es; // anno esercizio
TDate _data_ulmov; // data ultimo movimento
@ -130,17 +137,17 @@ class TSaldo_agg : public TObject
public:
void clear_saldi(int year);
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,
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); }
void set_anno_es(int anno) { _anno_es = anno; }
int anno_es() const { return _anno_es; }
void set_movap (bool movap) { _movap = movap; }
bool movap() const { return _movap; }
void set_tipo_saldo (tiposal movap) { _movap = movap; }
tiposal tipo_saldo() const { return _movap; }
void set_movprovv (bool p) { _provv = p; }
bool movprovv() const { return _provv; }

406
cg/cglib01.cpp
View File

@ -1,14 +1,7 @@
// cglib01.cpp
// calcolo dei saldi
// La compilazione e' gia' lenta da sola: evitare include inutili (Guy)
// #include <applicat.h>
// #include <utility.h>
#include <config.h>
#include "cglib.h"
#include <rmov.h>
#include <mov.h>
#include <saldi.h>
@ -16,15 +9,14 @@
#include <causali.h>
#include <clifo.h>
#include "cglib.h"
///////////////////////////////////////////////////////////
// Causale
///////////////////////////////////////////////////////////
TCaus::TCaus(const char* cod)
: _rec(LF_CAUSALI)
TCaus::TCaus(const char* cod) : _rec(LF_CAUSALI)
{
//if (*cod) read(cod);
read(cod);
}
@ -57,7 +49,6 @@ bool TCaus::apertura() const
//
// Cerca l'esercizio precedente di EseCorr
// Se EseCorr e' gia' il primo ritorna 0
// senno' ritorna il precedente (Stavolta meno astutamente, ma correttamente)
//
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)
aep = EsePre(aec);
// if (aep)
cf.setkey(2);
/* else
{
cf.setkey(1);
cf.put(SLD_ANNOES,aec);
}
*/
cf.put(SLD_GRUPPO,gr);
cf.put(SLD_CONTO,co);
// TRectype rec(cf.curr());
for (cf.read(_isgteq);!cf.eof();cf.next())
{
// if (cf.curr() > rec) break;
const int ae = cf.get_int(SLD_ANNOES);
const int g = cf.get_int(SLD_GRUPPO);
const int c = cf.get_int(SLD_CONTO);
const long s = cf.get_long(SLD_SOTTOCONTO);
if (g != gr || c != co) break;
// if (aep) {
if (ae != aec && ae != aep) continue;
// }
TRectype r(cf.curr());
key.format("%3d%3d%6ld", g, c, s);
// Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato
if (aep_par)
force = FALSE;
else
force = TRUE;
force = !aep_par;
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
{
TObject* o = ((TAssoc_array*)this)->get();
if (o == NULL)
return (TRectype*)NULL;
else
return (TRectype*)o;
}
TSaldo::TSaldo()
{
_saldo_ep = new TRectype(LF_SALDI);
_saldo_iniziale = ZERO;
_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;
}
TSaldo::TSaldo() : _saldi(LF_SALDI), _saldoiniziale(ZERO), _saldo_iniziale(ZERO),
_prg_dare(ZERO), _prg_avere(ZERO), _saldo(ZERO), _annoes(0),
_indbil(0), _prec(FALSE), _movimentato(FALSE), _significativo(FALSE),
_rec_presente_ec(FALSE), _rec_presente_ep(FALSE)
{}
real TSaldo::saldofin_esprec(int annoes, int g, int c, long s)
{
const int annoesprec = EsePre(annoes);
if (annoesprec == 0) // non ci sono esercizi prima del primo
{
_rec_presente_ep = FALSE;
_significativo = FALSE;
if (!ricerca_progr_prec(annoesprec, g, c, s)) // non ci sono esercizi prima del primo
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);
//real tot = pdare-pavere+pdaresca-paveresca;
real tot = pdare-pavere;
if (flag == 'D')
tot += saldo;
else
tot -= saldo;
if (flag == 'D') tot += saldo;
else tot -= saldo;
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
real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
{
real saldoini, pdaresca, paveresca, pdare, pavere;
char flag;
TLocalisamfile saldi(LF_SALDI, FALSE);
real saldoini;
_significativo = TRUE;
saldi.zero();
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,_annoes);
_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)
_rec_presente_ec = TRUE;
else
{
saldi.zero();
_rec_presente_ec = FALSE;
}
if (_rec_presente_ec = (_saldi.read() == NOERR))
saldoini = _saldi.get_real(SLD_SALDO);
flag = saldi.get_char(SLD_FLAGSALINI);
saldoini = saldi.get_real(SLD_SALDO);
_significativo = (saldoini != ZERO);
_significativo = _rec_presente_ec && saldoini != ZERO;
if (saldoini != ZERO) //non va considerato!!! Vedi appunti
_saldo_iniziale = ZERO;
if (saldoini == ZERO)
{
if ( indbil == 1 || indbil == 2 || indbil == 5 )
if (indbil == 1 || indbil == 2 || indbil == 5)
{
_prec = TRUE;
saldoini = saldofin_esprec(_annoes, g, c, s);
flag = 'D'; // Il segno DEVE essere quello del saldo precedente
}
_saldo_iniziale = saldoini;
}
#ifdef DBG
TString sldi(saldoini.string());
#endif
//if (flag == 'D')
//return saldoini;
return _saldo_iniziale;
//else
//return (-saldoini);
//return (-_saldo_iniziale);
}
const char* TSaldo::causale_chiusura_es()
@ -251,20 +173,22 @@ const char* TSaldo::causale_apertura_es()
return conf.get("CoCaAp");
}
void TSaldo::leggi_mov(long nr)
bool TSaldo::leggi_mov(long nr)
{
TLocalisamfile mov(LF_MOV, FALSE);
bool ok = TRUE;
mov.zero();
mov.put (MOV_NUMREG,nr);
if (mov.read() == NOERR)
if (ok = (mov.read() == NOERR))
{
_codcaus = mov.get (MOV_CODCAUS);
_datareg = mov.get_date(MOV_DATAREG);
_provv = mov.get (MOV_PROVVIS);
_datacomp = mov.get_date(MOV_DATACOMP);
}
return ok;
}
//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
data_mov = _datacomp;
}
if (data_mov < data_inf || data_mov > data_sup)
continue;
// "Se la causale del movimento e' uguale a quella di chiusura,
// 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);
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;
/*
if (!stp_prov && _provv.trim().not_empty())
continue;
*/
if (stp_prov == 1 && _provv.trim().not_empty()) //bilancio normale (non comprende i provvisori)
//bilancio dei soli provvisori ?
if (stp_prov == 3 && _provv.trim().empty())
continue;
if (stp_prov == 3 && _provv.trim().empty()) //bilancio dei soli provvisori
continue;
// "I mov. di puro riferimento (= con importo = 0) vanno scartati"
// I mov. di puro riferimento (= con importo = 0) vanno scartati
if (importo == ZERO) continue;
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);
}
#ifdef DBG
TString dep1(_saldo.string());
#endif
_movimentato = TRUE;
if (sezione == 'D')
@ -371,9 +282,6 @@ bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDat
else
_saldo -= importo;
}
#ifdef DBG
TString dep2(_saldo.string());
#endif
// Anche se non movimentato vado a vedere il saldo
if (!_movimentato)
@ -394,47 +302,36 @@ bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil
real pdarepro, paverepro;
bool esito = FALSE;
TLocalisamfile saldi(LF_SALDI);
_saldo_iniziale = ZERO;
_saldoiniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_prg_daresca = ZERO;
_prg_averesca = 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);
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
if (saldi.read() == NOERR)
if (_saldi.read() == NOERR)
{
annoe = saldi.get_int(SLD_ANNOES);
gruppo = saldi.get_int(SLD_GRUPPO);
conto = saldi.get_int(SLD_CONTO);
sottoconto = saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = saldi.get_real(SLD_SALDO);
_prg_dare = saldi.get_real(SLD_PDARE);
_prg_avere = saldi.get_real(SLD_PAVERE);
pdarepro = saldi.get_real(SLD_PDAREPRO);
paverepro = saldi.get_real(SLD_PAVEREPRO);
sezione = saldi.get_char(SLD_FLAGSALINI);
annoe = _saldi.get_int(SLD_ANNOES);
gruppo = _saldi.get_int(SLD_GRUPPO);
conto = _saldi.get_int(SLD_CONTO);
sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = _saldi.get_real(SLD_SALDO);
_prg_dare = _saldi.get_real(SLD_PDARE);
_prg_avere = _saldi.get_real(SLD_PAVERE);
pdarepro = _saldi.get_real(SLD_PDAREPRO);
paverepro = _saldi.get_real(SLD_PAVEREPRO);
sezione = _saldi.get_char(SLD_FLAGSALINI);
if (stp_prov == 1) //bilancio normale (senza provvisori)
if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO)
return esito;
if (stp_prov == 2) //bilancio globale (con provvisori)
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)
if (stp_prov == ZERO && paverepro == ZERO)
return esito;
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;
real pdarepro, paverepro;
bool esito = FALSE;
TLocalisamfile saldi(LF_SALDI, FALSE);
_saldo_iniziale = ZERO;
_prg_dare = ZERO;
_prg_avere = ZERO;
_prg_daresca = ZERO;
_prg_averesca = ZERO;
_saldo = ZERO;
_rec_presente_ec = FALSE;
_rec_presente_ep = 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);
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
if (saldi.read() == NOERR)
if (_saldi.read() == NOERR)
{
annoe = saldi.get_int(SLD_ANNOES);
gruppo = saldi.get_int(SLD_GRUPPO);
conto = saldi.get_int(SLD_CONTO);
sottoconto = saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = saldi.get_real(SLD_SALDO);
_prg_dare = saldi.get_real(SLD_PDARE);
_prg_avere = saldi.get_real(SLD_PAVERE);
pdarepro = saldi.get_real(SLD_PDAREPRO);
paverepro = saldi.get_real(SLD_PAVEREPRO);
sezione = saldi.get_char(SLD_FLAGSALINI);
annoe = _saldi.get_int(SLD_ANNOES);
gruppo = _saldi.get_int(SLD_GRUPPO);
conto = _saldi.get_int(SLD_CONTO);
sottoconto = _saldi.get_long(SLD_SOTTOCONTO);
_saldo_iniziale = _saldi.get_real(SLD_SALDO);
_prg_dare = _saldi.get_real(SLD_PDARE);
_prg_avere = _saldi.get_real(SLD_PAVERE);
pdarepro = _saldi.get_real(SLD_PDAREPRO);
paverepro = _saldi.get_real(SLD_PAVEREPRO);
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)
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 = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;
if (stp_prov == 1)
_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;
}
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);
// 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();
if (annoesprec == 0)
_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
{
prgdare = pdare + pdaresca;
prgavere = saldoini + pavere + paveresca;
const int oldkey = _saldi.getkey();
_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 TRUE;
return _rec_presente_ep;
}
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;
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,conto.gruppo());
_saldi.put(SLD_CONTO,conto.conto());
_saldi.put(SLD_SOTTOCONTO,conto.sottoconto());
_saldi.put(SLD_ANNOES,annoes);
saldi.zero();
saldi.put(SLD_GRUPPO,g);
saldi.put(SLD_CONTO,c);
saldi.put(SLD_SOTTOCONTO,s);
saldi.put(SLD_ANNOES,annoes);
bool ok = _saldi.read() == NOERR;
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')
{
prgdare = saldoini + pdaresca;
@ -661,10 +501,24 @@ bool TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prga
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 <prefix.h>
#include <utility.h>
#include <saldi.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;
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);
return tc;
}
TConto* TTab_conti::find(const TBill& c, int anno)
TConto* TTab_conti::find(const TBill& c, int anno, bool scar)
{
TString80 key;
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;
}
void TTab_conti::remove(const TBill& c, int anno)
void TTab_conti::remove(const TBill& c, int anno, bool scar)
{
TString80 key;
key.format("%4d%3d%3d%6ld", anno, c.gruppo(), c.conto(), c.sottoconto());
if (scar) key << "X";
TAssoc_array::remove(key);
}
void TTab_conti::aggiorna_conto(const TBill& tcon,
int anno_es, const TImporto& importo, bool movap,
bool provv, bool somma, bool movimentato)
int anno_es, const TImporto& importo, tiposal movap,
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)
tc = add(tcon, anno_es);
tc = (TContoExt*)add(tcon, anno_es, scaricato);
const real i(somma ? importo.valore() : -importo.valore());
if (movap)
if (movap == apertura)
{
if (importo.sezione() == 'D')
tc->saldo() += i;
else
tc->saldo() -= i;
}
else if (movap == chiusura)
{
if (importo.sezione() == 'D')
tc->saldofin() += i;
else
tc->saldofin() -= i;
}
else
{
if (provv)
{
if (importo.sezione() == 'D')
@ -70,35 +94,31 @@ void TTab_conti::aggiorna_conto(const TBill& tcon,
else
tc->avere() += i;
}
}
// rimuovo dalla tabella il conto se dare e avere vanno a zero
if (!movimentato)
if (tc->dare().is_zero() && tc->avere().is_zero() &&
tc->darepro().is_zero() && tc->averepro().is_zero() &&
tc->saldo().is_zero())
remove(*tc, anno_es);
tc->saldofin().is_zero() && tc->darepro().is_zero() &&
tc->averepro().is_zero() && tc->saldo().is_zero())
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;
_data_ulmov = "";
_num_ulmov = 0l;
_movap = FALSE;
_provv = FALSE;
_movimentato = FALSE;
// reset(); // INUTILE pulizia dell'array dei conti
_tab_conti.aggiorna_conto(tc, _anno_es, imp, _movap, _provv, somma, _movimentato, scaricato);
}
void TSaldo_agg::aggiorna(const TBill& tc, const TImporto& imp, bool somma)
{
_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)
void TSaldo_agg::aggiorna(int gruppo, int conto, long sottoconto, const real& importo, char sezione,
bool somma, bool scaricato)
{
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()
@ -148,8 +168,9 @@ void TSaldo_agg::clear_saldi(int year)
// Scorro la tabella dei conti interna _tab_conti.
// Per ogni conto cerco il record su saldi, se non c'e' lo creo.
// Se c'e' gia' lo aggiorno nel seguente modo:
//
// GLOP
///////////////////////////////////////////////////////////////////////////////
void TSaldo_agg::registra()
{
real si, r;
@ -163,14 +184,16 @@ void TSaldo_agg::registra()
for (int i = 0; i < conti; i++)
{
THash_object* hobj = _tab_conti.get_hashobj();
TConto& tcon = (TConto &)hobj->obj();
CHECK(tcon.ok(), "Tentavi di saldare un conto incompleto, eh?");
TContoExt& tcon = (TContoExt&)hobj->obj();
CHECK(tcon.ok(), "Tentavi di saldare un conto incompleto, eh? Mapporcodio! Stronzone!");
saldi.zero();
saldi.put(SLD_ANNOES, atoi(hobj->key().left(4)) );
saldi.put(SLD_GRUPPO, tcon.gruppo());
saldi.put(SLD_CONTO, tcon.conto());
saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
if (tcon.scaricato())
saldi.put(SLD_FLSCA, "X");
bool update = TRUE;
@ -181,6 +204,9 @@ void TSaldo_agg::registra()
saldi.put(SLD_GRUPPO, tcon.gruppo());
saldi.put(SLD_CONTO, tcon.conto());
saldi.put(SLD_SOTTOCONTO, tcon.sottoconto());
if (tcon.scaricato())
saldi.put(SLD_FLSCA, "X");
si = tcon.saldo();
if (si < ZERO)
{ flag_salini = 'A'; si = -si; }
@ -189,10 +215,15 @@ void TSaldo_agg::registra()
saldi.put(SLD_FLAGSALINI, flag_salini);
saldi.put(SLD_SALDO, si);
saldi.put(SLD_PDAREPRO, tcon.darepro());
saldi.put(SLD_PAVEREPRO, tcon.averepro());
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());
if (_num_ulmov != 0L) saldi.put(SLD_NUMULTMOV, _num_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_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 += tcon.dare();
saldi.put(SLD_PDARE, r);
@ -241,11 +266,9 @@ void TSaldo_agg::registra()
const int err = saldi.rewrite();
if (err != NOERR)
{
yesnofatal_box("Errore %d nell'aggiornamento del saldo %d %d %ld",
err, tcon.gruppo(), tcon.conto(), tcon.sottoconto());
}
}
TImporto sf(flag_salini, si);
const TImporto dare('D', saldi.get_real(SLD_PDARE));

17
cg/cglib04.cpp
View File

@ -4,6 +4,7 @@
#include <progind.h>
#include <stdlib.h>
#include <extcdecl.h>
#include "cglib.h"
#include "cglib04.h"
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)
{
if (prevesc) *prevesc = 0;
TTable esc("ESC");
for (int err = esc.first(); err == NOERR; err = esc.next())
{
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;
TEsercizi_contabili esc;
int e = esc.date2esc(d);
if (prevesc) *prevesc = esc.pred(e);
return e;
}

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
{
real _dare, _avere, _darepro, _averepro, _saldo;
real _dare, _avere, _darepro, _averepro, _saldofin, _saldo;
TImporto _saldo_finale;
public:
TConto(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL)
: TBill(g, c, s, t, d) {}
TConto (TToken_string& tgcsd, int from, int mode = 0)
: TBill(tgcsd, from, mode) {};
: TBill(tgcsd, from, mode) {}
real& dare() { return _dare; }
const real& dare() const { return _dare; }
@ -109,6 +109,9 @@ public:
real& saldo() { return _saldo; }
const real& saldo() const { return _saldo; }
real& saldofin() { return _saldofin; }
const real& saldofin() const { return _saldofin; }
TImporto& saldo_finale() { return _saldo_finale; }
const TImporto& saldo_finale() const { return _saldo_finale; }
};