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

Fantastica gestione del saldaconto

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1850 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 1995-09-19 15:43:43 +00:00
parent 25ee972811
commit d28f09cc52
11 changed files with 392 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
cg/cg2100.cpp
View File

@ -66,7 +66,7 @@ TMask* TPrimanota_application::load_mask(int n)
{
m->set_handler(F_DATADOC, doc_handler);
m->set_handler(F_NUMDOC, doc_handler);
m->set_handler(F_NUMRIF, numrif_handler);
// m->set_handler(F_NUMRIF, numrif_handler);
m->set_handler(F_DATA74TER, data74ter_handler);
m->set_handler(F_PROTIVA, protiva_handler);
m->set_handler(F_CLIENTE, clifo_handler);
@ -166,7 +166,6 @@ bool TPrimanota_application::user_create()
_pag = NULL;
_pag_rows = NULL;
_is_saldaconto = FALSE;
_skip_write_scadenze = FALSE;
load_mask(0);
@ -544,13 +543,6 @@ void TPrimanota_application::init_modify_mode(TMask& m)
{
init_mask(m);
calcola_saldo(); // Verifica eventuali sbilanci contabili
partite().destroy();
if (iva() == nessuna_iva && is_saldaconto())
{
const long numreg = m.get_long(F_NUMREG);
partite().add_numreg(numreg);
}
}
// Controlla sulla causale se il segno del totale documento (ritsoc=FALSE)
@ -567,6 +559,8 @@ int TPrimanota_application::read(TMask& m)
{
m.autoload(_rel);
const long numreg = _rel->curr().get_long(MOV_NUMREG);
cgs().reset();
if (iva() != nessuna_iva)
@ -587,7 +581,7 @@ int TPrimanota_application::read(TMask& m)
_saldi.set_movprovv(_rel->lfile().get_char("PROVVIS") > ' ');
_saldi.set_movap(causale().apertura());
_saldi.set_anno_es(m.get_int(F_ANNOES));
_saldi.set_num_ulmov(m.get_long(F_NUMREG));
_saldi.set_num_ulmov(numreg);
_saldi.set_data_ulmov((TDate)m.get(F_DATAREG));
for (int i = 0; i < _rel->cg_items(); i++)
@ -613,7 +607,11 @@ int TPrimanota_application::read(TMask& m)
riga.add(tipo); // Tipo di riga 115
disable_cgs_cells(i, tipo);
}
}
partite().destroy();
if (is_pagamento())
partite().add_numreg(numreg);
if (_iva == nessuna_iva)
return _rel->status();
@ -656,11 +654,11 @@ int TPrimanota_application::read(TMask& m)
}
calcola_imp(); // Calcola totale imponibile ed imposte
if (is_saldaconto() && causale().tipomov() != 2) // Ci sono scadenze
const int tm = causale().tipomov();
if (tm != 0 && tm != 2) // Ci sono scadenze
{
const TString16 dt(m.get(F_DATAREG));
set_numrif(m.get(F_NUMRIF));
set_pagamento(m.get(F_CODPAG), dt);
if (!read_scadenze(m))
set_scadenze(m);
@ -930,10 +928,20 @@ bool TPrimanota_application::remove()
_saldi.registra();
check_saldi();
if (_is_saldaconto && iva() == nessuna_iva)
{
notify_cgline_deletion(0); // Notify deletion of all cg lines
_partite.rewrite();
if (_is_saldaconto)
{
if (iva() == nessuna_iva)
{
notify_cgline_deletion(0); // Notify deletion of all cg lines
partite().rewrite();
}
else
{
TMask& m = curr_mask();
m.reset(F_ANNORIF);
m.reset(F_NUMRIF);
write_scadenze(m);
}
}
}
return ok;

6
cg/cg2100b.uml
View File

@ -192,8 +192,8 @@ BEGIN
DISPLAY "Nome@50" S0
OUTPUT S_VALUTA CODTAB
CHECKTYPE NORMAL
MESSAGE EMPTY CLEAR,S_CAMBIO
MESSAGE ENABLE,S_CAMBIO
MESSAGE EMPTY CLEAR,S_CAMBIO|CLEAR,S_TOTDOCVAL
MESSAGE ENABLE,S_CAMBIO|ENABLE,S_TOTDOCVAL
END
DATE S_DATACAMBIO
@ -231,7 +231,7 @@ BEGIN
PICTURE "."
GROUP 5
FIELD TOTDOC
VALIDATE REQIF_FUNC 1 F_TOTDOCVAL
VALIDATE REQIF_FUNC 1 S_TOTDOCVAL
END
NUMBER S_TOTDOCVAL 15 2

8
cg/cg2100c.uml
View File

@ -427,8 +427,8 @@ BEGIN
OUTPUT S_VALUTA CODTAB
CHECKTYPE NORMAL
WARNING "Codice valuta assente"
MESSAGE EMPTY CLEAR,S_CAMBIO
MESSAGE ENABLE,S_CAMBIO
MESSAGE EMPTY CLEAR,S_CAMBIO|CLEAR,S_TOTDOCVAL
MESSAGE ENABLE,S_CAMBIO|ENABLE,S_TOTDOCVAL
END
DATE S_DATACAMBIO
@ -449,9 +449,9 @@ BEGIN
CHECKTYPE NORMAL
END
NUMBER S_CAMBIO 12 5
NUMBER S_CAMBIO 15 5
BEGIN
PROMPT 58 12 "Cambio "
PROMPT 55 12 "Cambio "
HELP "Cambio della valuta per operazione con l'estero"
FIELD CAMBIO
FLAGS "RU"

2
cg/cg2100s.uml
View File

@ -253,13 +253,13 @@ END
STRING S_CODDESC 5
BEGIN
PROMPT 2 14 "Descriz. agg. "
FLAGS "U"
USE %DPN
INPUT CODTAB S_CODDESC
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@50" S0
OUTPUT S_CODDESC CODTAB
OUTPUT S_DESCAGG S0
CHECKTYPE NORMAL
END
STRING S_DESCAGG 50

7
cg/cg2101.cpp
View File

@ -160,13 +160,12 @@ bool TMovimentoPN::controlla_liquidazione(const TDate& data, bool reset) const
int TMovimentoPN::registra(bool re, bool force)
{
const TRectype& m = lfile().curr();
const long numreg = m.get_long("NUMREG");
int err = re ? TRelation::rewrite(force) : TRelation::write(force);
if (err != NOERR)
return err;
const TRectype& m = curr();
const long numreg = m.get_long("NUMREG");
if (!re)
_cg.renum_key("NUMREG", numreg);

15
cg/cg2102.cpp
View File

@ -1543,10 +1543,7 @@ bool TPrimanota_application::doc_handler(TMask_field& f, KEY key)
else if (!app().npart_is_prot())
{
if (m.get(F_NUMRIF).empty())
{
m.set(F_NUMRIF, val); // copia numero documento
app().set_numrif(val);
}
}
}
}
@ -1834,8 +1831,9 @@ bool TPrimanota_application::totdocval_handler(TMask_field& f, KEY key)
}
void TPrimanota_application::add_cgs_rit(bool fiscali)
{
const real imp(curr_mask().get(fiscali ? F_RITFIS : F_RITSOC));
{
TMask& m = curr_mask();
const real imp(m.get(fiscali ? F_RITFIS : F_RITSOC));
const char tipo = fiscali ? 'F' : 'S';
const int pos = type2pos(tipo);
@ -1853,13 +1851,13 @@ void TPrimanota_application::add_cgs_rit(bool fiscali)
else
set_cgs_imp(pos, real2imp(imp, tipo));
}
m.field(F_CODIVA).on_hit();
}
// Handler of the F_PROTIVA
bool TPrimanota_application::protiva_handler(TMask_field& f, KEY key)
{
bool ok = TRUE;
const TString16 piva(f.get());
if (key == K_ENTER && f.dirty() && f.mask().mode() == MODE_INS)
{
const long protiva = atol(f.get());
@ -1873,10 +1871,11 @@ bool TPrimanota_application::protiva_handler(TMask_field& f, KEY key)
{
if (app().npart_is_prot() && f.mask().is_running())
{
const TString16 piva(f.get());
f.mask().set(F_NUMRIF, piva);
app().set_numrif(piva);
}
}
}
return ok;
}

14
cg/cg2102.h
View File

@ -53,25 +53,24 @@ class TPrimanota_application : public TRelation_application
bool _skip_giornale_check; // Ignora controllo data stampa libro giornale
bool _skip_bollato_check; // Ignora controllo data stampa bollato
bool _skip_write_scadenze; // Cancellato saldaconto, non riscrivere
bool _savenew; // Registra e nuovo
short _firstfocus; // Primo campo della maschera a prendere il focus
bool _sheet_shown; // Lo sheet IVA e' gia' stato visualizzato una volta?
bool _sheet_shown; // Lo sheet e' gia' stato visualizzato una volta?
bool _is_saldaconto; // saldaconto si/no (vede parametri e causale)
TSaldo_agg _saldi; // Saldi da aggiornare
TPartite_array _partite; // Partite coinvolte
TMask* _msk[4]; // Maschere di query, cg, iva
TMask* _msk[4]; // Maschere di query, cg, iva, occasionali
long _lastreg; // Numero ultima registrazione
int _mode; // Modo maschera corrente
TBill _conto_ricavo; // Conto di ricavo del clifo
TString_array _pag_rows;
TString16 _numrif; // memorizza numrif per undo
static bool showpartite_handler(TMask_field& f, KEY k);
static bool speserimb_handler(TMask_field& f, KEY k);
@ -88,7 +87,7 @@ class TPrimanota_application : public TRelation_application
static bool datacomp_handler(TMask_field& f, KEY key);
static bool data74ter_handler(TMask_field& f, KEY key);
static bool doc_handler(TMask_field& f, KEY key);
static bool numrif_handler(TMask_field& f, KEY key);
// static bool numrif_handler(TMask_field& f, KEY key);
static bool protiva_handler(TMask_field& f, KEY key);
static bool clifo_handler(TMask_field& f, KEY key);
static bool totdoc_handler(TMask_field& f, KEY key);
@ -122,10 +121,7 @@ class TPrimanota_application : public TRelation_application
static bool pag_notify(TSheet_field& s, int r, KEY key);
void reset_sheet_row(TSheet_field& s, int n);
void set_numrif(const char* s) { _numrif = s; }
const char* get_numrif() { return _numrif; }
protected: // TApplication
virtual void on_firm_change();
virtual void on_config_change();

362
cg/cg2104.cpp
View File

@ -178,7 +178,7 @@ bool TPrimanota_application::nrate_handler(TMask_field& f, KEY key)
if (app().pagamento() != NULL)
{
app().pagamento()->set_numero_rate(atoi(f.get()), /*TBI*/-1);
if (app().pagamento()->dirty())
if (app().pagamento()->dirty())
app().pagamento()->set_sheet(ps);
}
else f.set("");
@ -187,89 +187,6 @@ bool TPrimanota_application::nrate_handler(TMask_field& f, KEY key)
}
bool TPrimanota_application::numrif_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.mask().is_running() && f.focusdirty())
{
TMask& m = f.mask();
const TString& val = f.get();
// questo evita due handlerate visto che e' in fondo alla pagina
if (val == app().get_numrif()) return TRUE;
// se cambiato chiedo conferma:
// se svuotato, azzero il cazzoconto
if (val.empty())
{
if (yesno_box("Si desidera l'azzeramento delle scadenze?"))
{
// sbraga giu' il saldaconto: andra' tutto kancellato
// se c'era
app().remove_scadenze(f.mask(), app().get_numrif());
f.set(""); // non dovrebbe servire, ma...
f.mask().disable_page(2);
}
else { f.set(app().get_numrif()); }
}
else
{
TString16 oldnr = app().get_numrif();
if (oldnr.empty())
{
// se numrif era vuoto, mi limito a costruire il nuovo saldaminchia
// con questo numrif
if (yesno_box("Si desidera la ridefinizione delle scadenze?"))
{
// deve esserci la data rif.
if (f.mask().get(F_ANNORIF).empty())
{
error_box("Non e' indicato l'anno riferimento partita");
f.set("");
return TRUE;
}
// lo ridefinisco da capo
// con il nuovo porcodio, riabilitando se
// non c'era
// deve essere indicato il pagamento, se no guai
if (app().pagamento() == NULL)
{
TString16 codpag = f.mask().get(F_CODPAG);
if (codpag.empty())
{
error_box("Deve essere specificato il codice pagamento");
f.set("");
}
else
{
f.mask().enable_page(2);
app().set_pagamento(codpag, f.mask().get(F_DATADOC));
app().set_scadenze(f.mask());
}
}
else
{
app().reset_pagamento();
app().set_scadenze(m);
f.mask().enable_page(2);
}
}
else { f.set(""); }
}
else
{
// trattasi di variazione: devo chiedere se vuole spostare i
// pagamenti, e se non vuole li lascio con codice 9999 (??? TBC)
if (yesno_box("Confermare la modifica numero riferimento partita"))
app().renumber_partita(f.mask(), oldnr, f.get());
else f.set(app().get_numrif());
}
}
app().set_numrif(f.get());
}
return TRUE;
}
void TPrimanota_application::reset_pagamento()
{
if (_pag != NULL)
@ -279,49 +196,6 @@ void TPrimanota_application::reset_pagamento()
}
}
void TPrimanota_application::renumber_partita(TMask& m, const char* oldp, const char* newp)
{
const TRectype& testa = _rel->lfile().curr();
const long nreg = testa.get_long("NUMREG");
const TString16 ndoc(testa.get("NUMDOC"));
const int tmov = testa.get_int("TIPOMOV");
const TDate ddoc(testa.get_date("DATADOC"));
const TDate dreg(testa.get_date("DATAREG"));
const TString16 reg (testa.get("REG"));
const long protiva = testa.get_long("PROTIVA");
const TString16 codcaus(testa.get("CODCAUS"));
const TString16 codval (testa.get("CODVAL"));
const real cambio(testa.get("CAMBIO"));
const TString16 numpart(m.get(F_NUMRIF));
const int anno = m.get_int(F_ANNORIF);
const TRectype& prima = _rel->cg(0);
const char sezione = prima.get_char("SEZIONE"); // Dare/Avere
const char tipocf = prima.get_char("TIPOC"); // Cliente || Fornitore || Uncazzo
const int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : prima.get_int("GRUPPO");
const int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : prima.get_int("CONTO");
const long sottoconto = prima.get_long("SOTTOCONTO");
const int nriga = 1;
const int numrig = 1;
TBill clifo(gruppo, conto, sottoconto, tipocf);
TPartita oldpart(clifo, anno, oldp);
TPartita newpart(clifo, anno, newp);
int npart = oldpart.prima_fattura(nreg);
if (oldpart.primo_pagamento() != -1)
{
if (!yesno_box("Si desidera spostare i pagamenti sulla nuova partita?"))
oldpart.scollega_pagamenti(npart);
}
oldpart.riassegna_riga(npart, newpart, TRUE);
oldpart.rewrite();
newpart.rewrite();
}
void TPrimanota_application::set_pagamento(const char* c, const char* d)
{
@ -336,12 +210,6 @@ void TPrimanota_application::set_scadenze(TMask& m)
const real spese(0.0);
TPagamento& pag = *pagamento();
if (pag.is_new())
{
// m.disable_page(2);
return;
}
else m.enable_page(2);
m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
m.set(FS_NAMEPAG, pag.name());
@ -399,20 +267,17 @@ bool TPrimanota_application::read_scadenze(TMask& m)
const TString16 codval (testa.get("CODVAL"));
const real cambio(testa.get("CAMBIO"));
const TString16 numpart(m.get(F_NUMRIF));
const int anno = m.get_int(F_ANNORIF);
const TRectype& prima = _rel->cg(0);
const char sezione = prima.get_char("SEZIONE"); // Dare/Avere
const char tipocf = prima.get_char("TIPOC"); // Cliente || Fornitore || Uncazzo
const int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : prima.get_int("GRUPPO");
const int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : prima.get_int("CONTO");
const long sottoconto = prima.get_long("SOTTOCONTO");
const int nriga = 1;
const int numrig = 1;
TBill clifo(gruppo, conto, sottoconto, tipocf);
TPartita part(clifo, anno, numpart);
TBill clifo; clifo.get(prima);
const int anno = m.get_int(F_ANNORIF);
const TString16 numpart(m.get(F_NUMRIF));
partite().destroy();
const TPartita& part = partite().partita(clifo, anno, numpart);
int npart = part.prima_fattura(nreg);
bool fromscratch = FALSE;
@ -420,8 +285,8 @@ bool TPrimanota_application::read_scadenze(TMask& m)
if (npart != -1) // la gh'e'
{
TRiga_partite& partita = part.riga(npart);
TRiga_scadenze& primarata = partita.rata(1);
const TRiga_partite& partita = part.riga(npart);
const TRiga_scadenze& primarata = partita.rata(1);
// se si e' specificato un codice pagamento diverso si rifa' da capo
// la follia e' che e' sulle SCADENZE, non sulle partite, naturalmente
@ -447,17 +312,14 @@ bool TPrimanota_application::read_scadenze(TMask& m)
else
{
pag.zap_rate();
for (int i = 1; i <= partita.rate(); i++)
{
TRiga_scadenze& scadenza = partita.rata(i);
real importo = scadenza.get(SCAD_IMPORTO);
const TRiga_scadenze& scadenza = partita.rata(i);
real importo = scadenza.get(SCAD_IMPORTO);
const TDate scad = scadenza.get(SCAD_DATASCAD);
const int tipop = scadenza.get_int(SCAD_TIPOPAG);
const bool paid = scadenza.get_bool(SCAD_PAGATA);
const TString16 ulc = scadenza.get(SCAD_ULTCLASS);
pag.set_rata(i-1, importo, scad, tipop, ulc, paid);
}
} //else
@ -475,133 +337,103 @@ bool TPrimanota_application::read_scadenze(TMask& m)
return TRUE;
}
void TPrimanota_application::remove_scadenze(const TMask& m, const char* nr)
{
TString numrif(nr);
if (numrif.empty()) return;
TRectype& r = _rel->lfile().curr();
const long nreg = r.get_long("NUMREG");
// rimuovi se ci sono
const char tipocf = _rel->cg(0).get_char("TIPOC"); // Cliente || Fornitore || Uncazzo
const int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("GRUPPO");
const int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("CONTO");
const long sottoconto = _rel->cg(0).get_long("SOTTOCONTO");
const int anno = m.get_int(F_ANNORIF);
TBill clifo(gruppo, conto, sottoconto, tipocf);
TPartita part(clifo, anno, numrif);
if (part.ok())
{
// check pagamenti effettuati
bool nopag = part.primo_pagamento(nreg) == -1;
if (nopag)
{
int npart = part.prima_fattura(nreg);
part.rimuovi_riga(npart);
part.rewrite();
_skip_write_scadenze = TRUE;
}
else warning_box("Esistono pagamenti gia' effettuati: rimozione impossibile");
}
}
void TPrimanota_application::write_scadenze(const TMask& m)
{
real imponibile(0.0);
real imposta(0.0);
real spese(0.0);
if (_skip_write_scadenze)
{
_skip_write_scadenze = FALSE;
return;
}
// should never happen but it doesn't hurt
CHECK(!_rel->cg(0).empty(), "Missing first line");
TRectype& r = _rel->lfile().curr();
const long nreg = r.get_long("NUMREG");
const TString16 ndoc(r.get("NUMDOC"));
const int tmov = r.get_int("TIPOMOV");
const TDate ddoc(r.get_date("DATADOC"));
const TDate dreg(r.get_date("DATAREG"));
const TString16 reg (r.get("REG"));
const TString80 desc(r.get("DESCR"));
const long protiva = r.get_long("PROTIVA");
const TString16 codcaus(r.get("CODCAUS"));
const TString16 codval (r.get("CODVAL"));
const real cambio (r.get("CAMBIO"));
const TString16 numpart = m.get(F_NUMRIF);
{
const int anno = m.get_int(F_ANNORIF);
CHECK(anno > 1900, "Anno partita non valido");
const TString16 numpart(m.get(F_NUMRIF));
const long nreg = m.get_long(F_NUMREG);
char sezione = _rel->cg(0).get_char("SEZIONE"); // Dare/Avere
char tipocf = _rel->cg(0).get_char("TIPOC"); // Cliente || Fornitore || Uncazzo
int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("GRUPPO");
int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("CONTO");
long sottoconto = _rel->cg(0).get_long("SOTTOCONTO");
TBill clifo(gruppo, conto, sottoconto, tipocf);
TPartita part(clifo, anno, numpart);
int numrig = 1; // TBC
TPartita* newgame = NULL;
if (anno > 0 && numpart.not_empty())
{
real imponibile(0.0);
real imposta(0.0);
real spese(0.0);
const TString16 ndoc(m.get(F_NUMDOC));
const int tmov = causale().tipomov();
const TDate ddoc(m.get(F_DATADOC));
const TDate dreg(m.get(F_DATAREG));
const TString16 reg (causale().reg().name());
const TString80 desc(m.get(F_DESCR));
const long protiva = m.get_long(F_PROTIVA);
const TString16 codcaus(causale().codice());
const TString16 codval (m.get(S_VALUTA));
const real cambio (m.get(S_CAMBIO));
const char sezione = get_cgs_imp(0).sezione(); // Dare/Avere
CHECK(sezione > ' ', "Invalid section in row 0");
const TBill clifo(cgs().row(0), 2, 0x3);
newgame = new TPartita(clifo, anno, numpart);
int row = part.prima_fattura(nreg);
// TBC controllo aggiunta su partita se ridefinita a culo
TRiga_partite& partita = row == -1 ? part.nuova_riga() : part.riga(row);
const int row = newgame->prima_fattura(nreg);
TRiga_partite& partita = row <= 0 ? newgame->new_row() : newgame->riga(row);
TPagamento& pag = *pagamento();
// put data on partita
partita.put(PART_TIPOMOV, tmov);
partita.put(PART_NREG, nreg);
partita.put(PART_NUMRIG, 1);
partita.put(PART_DATAREG, dreg);
partita.put(PART_DATADOC, ddoc);
partita.put(PART_NUMDOC, ndoc);
partita.put(PART_REG, reg);
partita.put(PART_DESCR, desc);
partita.put(PART_PROTIVA, protiva);
partita.put(PART_CODCAUS, codcaus);
partita.put(PART_SEZ, sezione);
partita.put(PART_CODVAL, codval);
partita.put(PART_CAMBIO, cambio);
partita.put(PART_IMPORTO, pag.imponibile()+pag.imposta());
partita.put(PART_IMPOSTA, pag.imposta());
partita.put(PART_SPESE, pag.spese());
TPagamento& pag = *pagamento();
// put data on partita
partita.put(PART_TIPOMOV, tmov);
partita.put(PART_NREG, nreg);
partita.put(PART_DATAREG, dreg);
partita.put(PART_DATADOC, ddoc);
partita.put(PART_NUMDOC, ndoc);
partita.put(PART_REG, reg);
partita.put(PART_DESCR, desc);
partita.put(PART_PROTIVA, protiva);
partita.put(PART_CODCAUS, codcaus);
partita.put(PART_SEZ, sezione);
// partita.put(PART_CODPAG, pag.code());
partita.put(PART_CODVAL, codval);
partita.put(PART_CAMBIO, cambio);
partita.put(PART_IMPORTO, pag.imponibile()+pag.imposta()); // TBC sommare le spese?
partita.put(PART_IMPOSTA, pag.imposta());
partita.put(PART_SPESE, pag.spese());
partita.put(PART_NUMRIG, numrig);
partita.elimina_rate();
for (int i = 0; i < pag.n_rate(); i++)
{
TRiga_scadenze& scadenza = partita.new_row();
// TBC se devono cominciare da n != 1, si riveda questo
// appropriatamente
partita.elimina_rate();
TString16 np = partita.get(PART_NUMPART);
TString16 nr = partita.get(PART_NRIGA);
for (int i = 0; i < pag.n_rate(); i++)
{
TRiga_scadenze& scadenza = (TRiga_scadenze&)partita.new_row();
scadenza.put(SCAD_CODPAG, pag.code());
scadenza.put(SCAD_TIPOPAG, pag.tipo_rata(i));
scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i));
scadenza.put(SCAD_IMPORTO, pag.tpay_rata(i));
scadenza.put(SCAD_DATASCAD, pag.data_rata(i));
scadenza.put(SCAD_PAGATA, pag.ratapagata(i));
scadenza.put(SCAD_CODPAG, pag.code());
scadenza.put(SCAD_TIPOPAG, pag.tipo_rata(i));
scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i));
scadenza.put(SCAD_IMPORTO, pag.tpay_rata(i));
scadenza.put(SCAD_DATASCAD, pag.data_rata(i));
scadenza.put(SCAD_PAGATA, pag.ratapagata(i));
// scadenza.put(SCAD_CODABIPR, pag.codabipr(i)); // TBI
// scadenza.put(SCAD_CODCABPR, pag.codcabpr(i)); // TBI
}
}
TPartita* oldgame = partite().first();
if (oldgame != NULL)
{
const int primafatt = oldgame->prima_fattura(nreg);
if (primafatt > 0)
{
if (*oldgame != *newgame)
{
bool sposta = newgame != NULL;
if (sposta)
{
sposta = (oldgame->conto() == newgame->conto());
if (sposta)
sposta = yesno_box("Spostare le righe nella nuova partita?");
}
if (sposta)
oldgame->sposta_riga(primafatt, *newgame);
else
oldgame->scollega_pagamenti(primafatt);
oldgame->rewrite();
}
else
{
oldgame->sposta_riga(primafatt, *newgame);
}
}
}
part.write();
if (newgame != NULL)
newgame->write();
}

5
cg/cg2105.cpp
View File

@ -877,14 +877,13 @@ bool TPrimanota_application::edit_partite(int riga)
int TPrimanota_application::nuovo_pagamento(TPartita& partita, int nriga, int rata, int numrig)
{
TBill conto; partita.conto(conto); // Legge conto principale
const TBill& conto = partita.conto(); // Legge conto principale
const long numreg = curr_mask().get_long(F_NUMREG);
int nrigp = partita.mov2rig(numreg, numrig); // Cerca riga partita relativa alla riga rmov
if (nrigp <= 0) // Devo creare una nuova riga di partita
{
TRiga_partite& part = partita.nuova_riga(); // Creazione nuova riga vuota
TRiga_partite& part = partita.new_row(); // Creazione nuova riga vuota
nrigp = part.get_int(PART_NRIGA);
// Copia dati movimento corrente

349
cg/saldacon.cpp
View File

@ -32,23 +32,38 @@ TObject* TTree_rectype::dup() const
return r;
}
void TTree_rectype::renum_key(const char* field, const char* val)
{
TRectype::renum_key(field, val);
_recarr.renum_key(field, val);
}
void TTree_rectype::copy_key_to_row(TRectype& row) const
{
const int numkey = 0; // Memento! Gli indici delle chiavi partono da zero!
RecDes* recd = rec_des(); // Descrizione del record della testata
row.zero();
const KeyDes& kd = recd->Ky[numkey];
for (int i = recd->Ky[numkey].NkFields-1; i >= 0; i--)
const KeyDes& kd = recd->Ky[0]; // Memento! Gli indici delle chiavi partono da zero!
for (int i = kd.NkFields-1; i >= 0; i--)
{
const int nf = kd.FieldSeq[i] % MaxFields;
const RecFieldDes& rf = recd->Fd[nf];
const char* name = rf.Name;
const TString& val = get(name);
row.put(name, val);
row.renum_key(name, val);
}
}
TRectype& TTree_rectype::new_row(int r)
{
if (r <= 0)
r = last()+1;
CHECKD(!exist(r), "Ue' pirla!, esiste gia' la riga ", r);
TRectype& row = rows_array().row(r, TRUE);
return row;
}
int TTree_rectype::fill_array()
{
TRectype* row = (TRectype*)_recarr.key().dup();
@ -94,7 +109,7 @@ int TTree_rectype::rewrite(TBaseisamfile& f) const
return err;
}
int TTree_rectype::remove(TBaseisamfile& f)
int TTree_rectype::remove(TBaseisamfile& f) const
{
int err = TRectype::remove(f);
if (err == NOERR)
@ -195,14 +210,12 @@ TRiga_scadenze::TRiga_scadenze(TRiga_partite* r)
: TTree_rectype(LF_SCADENZE, LF_PAGSCA, "NRIGP"), _riga(r)
{
CHECK(_riga, "Riga nulla");
r->copy_key_to_row(*this);
}
TRiga_scadenze::TRiga_scadenze(const TRiga_scadenze& s)
: TTree_rectype(s), _riga(s._riga)
{
CHECK(_riga, "Riga nulla");
}
{}
TPartita& TRiga_scadenze::partita() const
{
@ -411,14 +424,13 @@ bool TRiga_scadenze::modifica_pagamento(const TRectype& new_pag, const TValuta&
return empty;
}
bool TPartita::modifica_pagamento(const TRectype& new_pag)
bool TRiga_scadenze::elimina_pagamento(int p)
{
char old_ap, new_ap;
TImporto old_abbuono, new_abbuono, old_diffcam, new_diffcam;
TValuta valuta;
return modifica_pagamento(new_pag, valuta,
old_ap, old_abbuono, old_diffcam,
new_ap, new_abbuono, new_diffcam);
TRectype old_pag(row(p));
old_pag.put(PAGSCA_ACCSAL, "A");
old_pag.zero(PAGSCA_IMPORTO);
old_pag.zero(PAGSCA_IMPORTOVAL);
return partita().modifica_pagamento(old_pag);
}
///////////////////////////////////////////////////////////
@ -429,26 +441,31 @@ TRiga_partite::TRiga_partite(TPartita* game)
: TTree_rectype(LF_PARTITE, LF_SCADENZE, SCAD_NRATA), _partita(game)
{
CHECK(_partita, "Partita nulla");
TRiga_scadenze* scad = new TRiga_scadenze(this);
copy_key_to_row(*this);
rows_array().set_key(scad); // Altrimenti le righe sarebbero dei TRectype!
}
TRiga_partite::TRiga_partite(const TRiga_partite& r)
: TTree_rectype(r), _partita(r._partita)
{
CHECK(_partita, "Partita nulla");
}
{}
TRiga_scadenze& TRiga_partite::new_row(int r)
{
if (r <= 0) r = last()+1;
if (_recarr.rows() == 0)
{
TRiga_scadenze& scad = (TRiga_scadenze&)TTree_rectype::new_row(r);
scad._riga = this;
return scad;
}
void TRiga_partite::elimina_rate()
{
for (int r = rate(); r > 0; r--)
{
TRiga_scadenze* scad = new TRiga_scadenze(this);
copy_key_to_row(*scad);
_recarr.set_key(scad); // Altrimenti le righe sarebbero dei TRectype!
}
return (TRiga_scadenze&)_recarr.row(r, TRUE);
TRiga_scadenze& scad = rata(r);
for (int p = scad.last(); p > 0; p = scad.pred(p))
scad.elimina_pagamento(p);
rows_array().destroy_row(r);
}
}
int TRiga_partite::read(TBaseisamfile& f, word op)
@ -457,11 +474,10 @@ int TRiga_partite::read(TBaseisamfile& f, word op)
if (err == NOERR && get_int(PART_TIPOMOV) == 1)
{
TRiga_scadenze* s = new TRiga_scadenze(this);
copy_key_to_row(*s);
err = _recarr.read(s); // Deve esistere almento una scadenza
err = rows_array().read(s); // Deve esistere almento una scadenza
}
else
_recarr.destroy_rows();
rows_array().destroy_rows();
return err;
}
@ -513,35 +529,44 @@ TPartita::TPartita(const TBill& clifo, int anno, const char* num)
read(clifo, anno, num);
}
TPartita::TPartita()
: _part(LF_PARTITE, PART_NRIGA), _unassigned(LF_PAGSCA, "NRIGP")
{}
int TPartita::compare(const TSortable& s) const
{
TString80 key; key.format("%c%6ld%4d%s", conto().tipo(), conto().sottoconto(),
anno(), (const char*)numero());
const TPartita& p = (const TPartita&)s;
TString80 par; par.format("%c%6ld%4d%s", p.conto().tipo(), p.conto().sottoconto(),
p.anno(), (const char*)p.numero());
return strcmp(key, par);
}
// Costruisce le righe della partita
bool TPartita::read(const TBill& clifo, int anno, const char* num)
bool TPartita::read(const TBill& clifo, int year, const char* num)
{
TRiga_partite* partita = new TRiga_partite(this); // Record campione della partita
partita->put(PART_TIPOCF, clifo.tipo()); // Tipo clifo
_conto = clifo;
_anno = year;
_num = num;
TRiga_partite* partita = new TRiga_partite(this); // Record campione della partita
TString16 str;
str << clifo.tipo();
partita->renum_key(PART_TIPOCF, str); // Tipo clifo
if (clifo.tipo() <= ' ')
{
partita->put(PART_GRUPPO, clifo.gruppo()); // Scrivi gruppo e conto solamente
partita->put(PART_CONTO, clifo.conto()); // nei conti normali (no clifo)
}
partita->put(PART_SOTTOCONTO, clifo.sottoconto()); // Sottoconto o codice clifo
partita->put(PART_ANNO, anno); // Anno partita
partita->put(PART_NUMPART, num); // Numero partita
{
str.cut(0); str << clifo.gruppo();
partita->renum_key(PART_GRUPPO, str); // Scrivi gruppo e conto solamente
str.cut(0); str << clifo.conto(); // nei conti normali (no clifo)
partita->renum_key(PART_CONTO, str);
}
str.cut(0); str << clifo.sottoconto();
partita->renum_key(PART_SOTTOCONTO, str); // Sottoconto o codice clifo
str.cut(0); str << anno();
partita->renum_key(PART_ANNO, str); // Anno partita
partita->renum_key(PART_NUMPART, num); // Numero partita
_part.read(partita);
TRectype unas(LF_PAGSCA); // Record campione pagamenti non assegnati
unas.zero();
unas.put(PART_TIPOCF, partita->get(PART_TIPOCF)); // Copia chiave partite
unas.put(PART_GRUPPO, partita->get(PART_GRUPPO));
unas.put(PART_CONTO, partita->get(PART_CONTO));
unas.put(PART_SOTTOCONTO, partita->get(PART_SOTTOCONTO));
unas.put(PART_ANNO, partita->get(PART_ANNO));
unas.put(PART_NUMPART, partita->get(PART_NUMPART));
unas.put(PART_NRIGA, (int)UNASSIGNED);
unas.put(SCAD_NRATA, (int)UNASSIGNED);
TRectype* unas = new TRectype(LF_PAGSCA); // Record pagamenti non assegnati
partita->copy_key_to_row(*unas);
unas->put(PART_NRIGA, (int)UNASSIGNED);
unas->put(SCAD_NRATA, (int)UNASSIGNED);
_unassigned.read(unas);
return ok();
@ -549,15 +574,20 @@ bool TPartita::read(const TBill& clifo, int anno, const char* num)
bool TPartita::reread()
{
TBill zio;
conto(zio);
const int year = anno();
const TString16 num = numero();
return read(zio, year, num);
return read(conto(), anno(), numero());
}
bool TPartita::write(bool re) const
{
if (conto().tipo() > ' ')
{
for (int r = last(); r > 0; r = pred(r))
{
TRiga_partite& row = riga(r);
row.put(PART_GRUPPOCL, conto().gruppo());
row.put(PART_GRUPPOCL, conto().conto());
}
}
int err = _part.write(re);
if (err == NOERR)
err = _unassigned.write(re);
@ -572,13 +602,13 @@ bool TPartita::remove()
}
// Crea un nuova riga partite e gli copia la chiave principale e il conto cliente/fornitore
TRiga_partite& TPartita::nuova_riga()
{
TRiga_partite& nuova = (TRiga_partite&)_part.row(last()+1, TRUE);
const TRiga_partite& prima = riga(first());
nuova.put(PART_GRUPPOCL, prima.get(PART_GRUPPOCL));
nuova.put(PART_CONTOCL, prima.get(PART_CONTOCL));
// Crea un nuova riga partite
TRiga_partite& TPartita::new_row(int r)
{
if (r <= 0)
for (r = 1; esiste(r); r++);
CHECKD(!esiste(r), "Ue' pirla!, esiste gia' la riga ", r);
TRiga_partite& nuova = (TRiga_partite&)_part.row(r, TRUE);
return nuova;
}
@ -619,11 +649,11 @@ bool TPartita::esiste(int nriga, int nrata, int nrigp) const
if (nrigp <= 0)
{
const TRiga_partite& r = riga(nriga);
return r.rows_array().exist(nrata);
return r.exist(nrata);
}
const TRiga_scadenze& r = rata(nriga, nrata);
return r.rows_array().exist(nrigp);
return r.exist(nrigp);
}
// Ritorna l'importo in lire speso su di una riga contabile
@ -762,21 +792,17 @@ void TPartita::calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImp
saldo += imp;
}
// Controlla se esistono pagamenti riferiti alla riga nrigp
bool TPartita::utilizzata(int nrigp) const
{
for (int p = last(); p > 0; p = pred(p))
{
const TRiga_partite& fatt = riga(p);
const int tipomov = fatt.get_int(PART_TIPOMOV);
if (tipomov == 1)
for (int r = fatt.rate(); r > 0; r--)
{
for (int r = fatt.rate(); r > 0; r--)
{
const TRiga_scadenze& scad = fatt.rata(r);
if (scad.rows_array().exist(nrigp))
return TRUE;
}
const TRiga_scadenze& scad = fatt.rata(r);
if (scad.rows_array().exist(nrigp))
return TRUE;
}
}
return _unassigned.exist(nrigp);
@ -812,16 +838,30 @@ bool TPartita::modifica_pagamento(const TRectype& new_pag, const TValuta& valuta
_unassigned.destroy_row(nrigp);
else
_unassigned.row(nrigp, FALSE) = new_pag;
old_ap = new_ap = ' '; // Non ci possono essere abbuoni di sorta!
// Non ci possono essere abbuoni o differenze cambio di sorta!
old_ap = new_ap = ' ';
old_abb = new_abb = old_diffcam = new_diffcam = TImporto('D', ZERO);
}
if (empty && !utilizzata(nrigp))
_part.destroy_row(nrigp);
rimuovi_riga(nrigp);
return empty;
}
bool TPartita::modifica_pagamento(const TRectype& new_pag)
{
char old_ap, new_ap;
TImporto old_abbuono, new_abbuono, old_diffcam, new_diffcam;
TValuta valuta;
return modifica_pagamento(new_pag, valuta,
old_ap, old_abbuono, old_diffcam,
new_ap, new_abbuono, new_diffcam);
}
bool TPartita::chiusa(bool update)
{
bool chiusa = FALSE;
@ -869,73 +909,124 @@ bool TPartita::chiusa(bool update)
return chiusa;
}
void TPartita::riassegna_riga(int r, TPartita& part, bool remove)
{
void TPartita::rimuovi_riga(int r)
{
TRiga_partite& row = riga(r);
TRiga_partite& nrw = part.nuova_riga();
if (row.rate() > 0)
{
row.elimina_rate();
}
else
{
CHECKD(!utilizzata(r), "Can't remove still referenced row ", r);
}
_part.destroy_row(r);
}
static void somma(const TRectype& vec, TRectype& nuo, const char* field)
{
real totale(vec.get(field));
totale += nuo.get_real(field);
nuo.put(field, totale);
}
void TPartita::sposta_riga(int r, TPartita& part)
{
const TRiga_partite& row = riga(r);
const long nreg = row.get_long(PART_NREG);
const int prima = part.prima_fattura(nreg);
TRiga_partite& nrw = part.riga(prima);
const int address_size = last()+1;
int* address = new int[address_size];
memset(address, 0, address_size*sizeof(int));
TToken_string knames(256);
// copy all non-key fields
knames.add(PART_TIPOCF);
knames.add(PART_GRUPPO);
knames.add(PART_CONTO);
knames.add(PART_SOTTOCONTO);
knames.add(PART_ANNO);
knames.add(PART_NUMPART);
knames.add(PART_NRIGA);
knames.add(SCAD_NRATA);
knames.add(PAGSCA_NRIGP);
for (int f = 0; f < row.items(); f++)
{
const char* fnam = row.fieldname(f);
if (knames.get_pos(fnam) == -1)
nrw.put(fnam, row.get(fnam));
}
for (int i = 1; i <= row.rate(); i++)
{
TRiga_scadenze& scd = row.rata(i);
TRiga_scadenze& nsc = nrw.new_row();
// copy all non-key fields
knames = "";
knames.add(SCAD_ANNO);
knames.add(SCAD_NUMPART);
knames.add(SCAD_NRIGA);
knames.add(SCAD_NRATA);
for (int f = 0; f < scd.items(); f++)
{
const char* fnam = scd.fieldname(f);
if (knames.get_pos(fnam) == -1)
nsc.put(fnam, scd.get(fnam));
}
for (int j = scd.last(); j > 0; j = scd.pred(j))
{
TRectype& pag = scd.row(j);
TRectype& npg = nsc.new_row();
knames = "";
knames.add(PAGSCA_NUMPART);
knames.add(PAGSCA_NRIGA);
knames.add(PAGSCA_NRATA);
knames.add(PAGSCA_NRIGP);
for (int f = 0; f < pag.items(); f++)
{
const char* fnam = pag.fieldname(f);
if (knames.get_pos(fnam) == -1)
npg.put(fnam, pag.get(fnam));
const TRectype& pag = scd.row(j);
CHECK(j < address_size, "Bad nrigp address");
if (address[j] == 0)
{
const TRiga_partite& vecchia = riga(j);
TRiga_partite& nuova = part.new_row(part.esiste(j) ? 0 :j);
for (int f = 0; f < vecchia.items(); f++)
{
const char* fnam = vecchia.fieldname(f);
if (knames.get_pos(fnam) < 0)
nuova.put(fnam, vecchia.get(fnam));
}
nuova.zero(PART_IMPORTO);
nuova.zero(PART_IMPORTOVAL);
nuova.zero(PART_ABBUONI);
nuova.zero(PART_DIFFCAM);
address[j] = nuova.get_int(PART_NRIGA);
}
const int nrigp = address[j];
TRectype npg(LF_PAGSCA);
if (part.esiste(r, i, nrigp))
{
npg = part.pagamento(r, i, nrigp);
somma(pag, npg, PART_IMPORTO);
somma(pag, npg, PART_IMPORTOVAL);
somma(pag, npg, PART_ABBUONI);
somma(pag, npg, PART_DIFFCAM);
npg.put(PAGSCA_ACCSAL, 'A');
}
else
{
if (nrw.exist(i))
npg = nrw.rata(i).new_row(nrigp);
else
npg = part.unassigned().row(nrigp, TRUE);
for (int f = 0; f < pag.items(); f++)
{
const char* fnam = pag.fieldname(f);
if (knames.get_pos(fnam) < 0)
npg.put(fnam, pag.get(fnam));
}
}
part.modifica_pagamento(npg);
scd.elimina_pagamento(j);
}
}
}
if (remove) rimuovi_riga(r);
delete address;
rimuovi_riga(r);
}
void TPartita::scollega_pagamenti(int r)
{
TRiga_partite& row = riga(r);
// Sposta i pagamenti della riga r, dalla rata s compresa in poi, sui non assegnati
void TPartita::scollega_pagamenti(int r, int s)
{
CHECKD(s >= 0, "Impossibile scollegare la rata ", s);
for (int i = 0; i < row.rate(); i++)
const TRiga_partite& row = riga(r);
for (int i = row.rate(); i >= s; i--)
{
TRiga_scadenze& sc = row.rata(i+1);
TRiga_scadenze& sc = row.rata(i);
for (int j = sc.last(); j > 0; j = sc.pred(j))
{
TRectype& pag = sc.row(j);
TRectype& pag = sc.row(j);
CHECK(pag.get_real(PAGSCA_ABBUONI).is_zero(), "Can't remove payment with ABBUONI");
CHECK(pag.get_real(PAGSCA_DIFFCAM).is_zero(), "Can't remove payment with DIFFCAM");
pag.put(PAGSCA_ACCSAL, 'A');
pag.put(PAGSCA_NRIGA, (int)TPartita::UNASSIGNED);
pag.put(PAGSCA_NRATA, (int)TPartita::UNASSIGNED);
_unassigned.add_row(pag);

42
cg/saldacon.h
View File

@ -25,8 +25,6 @@ class TTree_rectype : public TRectype
{
protected:
TRecord_array _recarr;
void copy_key_to_row(TRectype& row) const;
int fill_array();
protected: // TRectype
@ -36,7 +34,8 @@ protected: // TRectype
virtual int next(TBaseisamfile& f);
virtual int write(TBaseisamfile& f) const;
virtual int rewrite(TBaseisamfile& f) const;
virtual int remove(TBaseisamfile& f);
virtual int remove(TBaseisamfile& f) const;
virtual void renum_key(const char* field, const char* val);
const TRecord_array& rows_array() const { return _recarr; }
TRecord_array& rows_array() { return _recarr; }
@ -44,13 +43,15 @@ protected: // TRectype
public:
const TRectype& row(int r) const { return _recarr.row(r); }
TRectype& row(int r) { return _recarr.row(r, TRUE); }
TRectype& new_row(int r = -1) { return _recarr.row(r > 0 ? r : last()+1, TRUE); }
TRectype& new_row(int r = 0);
void destroy_rows() { _recarr.destroy_rows(); }
void copy_key_to_row(TRectype& row) const;
int first() const { return _recarr.first_row(); }
int last() const { return _recarr.last_row(); }
int pred(int r) const { return _recarr.pred_row(r); }
int succ(int r) const { return _recarr.succ_row(r); }
bool exist(int r) const { return _recarr.exist(r); }
TTree_rectype(const TRectype& testata, const TRectype& riga, const char* num);
TTree_rectype(int testata, int riga, const char* num);
@ -118,6 +119,7 @@ protected:
bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta,
char& old_ap, TImporto& old_abb, TImporto& old_diffcam,
char& new_ap, TImporto& new_abb, TImporto& new_diffcam);
bool elimina_pagamento(int p);
protected: // TRecord_tree
virtual TObject* dup() const { return new TRiga_scadenze(*this); }
@ -152,8 +154,8 @@ public: // TTree_rectype
public:
int rate() const { return _recarr.rows(); }
TRiga_scadenze& rata(int r) const { return (TRiga_scadenze&)_recarr.row(r); }
void elimina_rate() { _recarr.destroy_rows(); }
TRiga_scadenze& new_row(int r = -1);
void elimina_rate();
TRiga_scadenze& new_row(int r = 0);
int ultimo_pagamento(int rata) const;
char sezione() const { return get_char(PART_SEZ); }
@ -169,29 +171,34 @@ public:
virtual ~TRiga_partite() {}
};
class TPartita : public TObject
{
class TPartita : public TSortable
{
TBill _conto;
int _anno;
TString16 _num;
TRecord_array _part;
TRecord_array _unassigned;
public: // TObject
virtual bool ok() const { return _part.rows() > 0; }
virtual int compare(const TSortable& s) const;
public:
enum { UNASSIGNED = 9999 };
TRiga_partite& riga(int r) const { return (TRiga_partite&)_part.row(r); }
TRiga_partite& nuova_riga();
void rimuovi_riga(int r) { _part.destroy_row(r); }
TRiga_partite& new_row(int r = 0);
void rimuovi_riga(int r);
TRiga_scadenze& rata(int nriga, int nrata) const;
TRectype& pagamento(int nriga, int nrata, int nrigp);
bool rata_chiusa(int nriga, int nrata) const;
bool esiste(int nriga, int nrata = 0, int nrigp = 0) const;
// assegna riga e figli a altra partita, distruggendola se remove e' TRUE
void riassegna_riga(int r, TPartita& part, bool remove = TRUE);
// assegna riga e figli ad altra partita
void sposta_riga(int r, TPartita& part);
// de-assegna tutti i pagamenti di una riga e li distrugge
void scollega_pagamenti(int r);
void scollega_pagamenti(int riga, int rata = 0);
int succ(int r) const { return _part.succ_row(r); }
int pred(int r) const { return _part.pred_row(r); }
@ -214,10 +221,10 @@ public:
bool chiusa(bool update = FALSE);
void conto(TBill& c) const { c.get(_part.key()); }
int anno() const { return _part.key().get_int(PART_ANNO); }
const TString& numero() const { return _part.key().get(PART_NUMPART); }
const TString& descrizione() const { return _part.key().get(PART_DESCR); }
const TBill& conto() const { return _conto; }
int anno() const { return _anno; }
const TString& numero() const { return _num; }
const TString& descrizione() const;
TImporto importo_speso(long numreg, int numrig) const;
void update_reg(long nreg, const TRectype& mov);
@ -229,7 +236,6 @@ public:
bool modifica_pagamento(const TRectype& new_pag);
TPartita(const TBill& clifo, int anno, const char* num);
TPartita();
};