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

38
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_DATADOC, doc_handler);
m->set_handler(F_NUMDOC, 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_DATA74TER, data74ter_handler);
m->set_handler(F_PROTIVA, protiva_handler); m->set_handler(F_PROTIVA, protiva_handler);
m->set_handler(F_CLIENTE, clifo_handler); m->set_handler(F_CLIENTE, clifo_handler);
@ -166,7 +166,6 @@ bool TPrimanota_application::user_create()
_pag = NULL; _pag = NULL;
_pag_rows = NULL; _pag_rows = NULL;
_is_saldaconto = FALSE; _is_saldaconto = FALSE;
_skip_write_scadenze = FALSE;
load_mask(0); load_mask(0);
@ -544,13 +543,6 @@ void TPrimanota_application::init_modify_mode(TMask& m)
{ {
init_mask(m); init_mask(m);
calcola_saldo(); // Verifica eventuali sbilanci contabili 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) // Controlla sulla causale se il segno del totale documento (ritsoc=FALSE)
@ -567,6 +559,8 @@ int TPrimanota_application::read(TMask& m)
{ {
m.autoload(_rel); m.autoload(_rel);
const long numreg = _rel->curr().get_long(MOV_NUMREG);
cgs().reset(); cgs().reset();
if (iva() != nessuna_iva) if (iva() != nessuna_iva)
@ -587,7 +581,7 @@ int TPrimanota_application::read(TMask& m)
_saldi.set_movprovv(_rel->lfile().get_char("PROVVIS") > ' '); _saldi.set_movprovv(_rel->lfile().get_char("PROVVIS") > ' ');
_saldi.set_movap(causale().apertura()); _saldi.set_movap(causale().apertura());
_saldi.set_anno_es(m.get_int(F_ANNOES)); _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)); _saldi.set_data_ulmov((TDate)m.get(F_DATAREG));
for (int i = 0; i < _rel->cg_items(); i++) for (int i = 0; i < _rel->cg_items(); i++)
@ -615,6 +609,10 @@ int TPrimanota_application::read(TMask& m)
disable_cgs_cells(i, tipo); disable_cgs_cells(i, tipo);
} }
partite().destroy();
if (is_pagamento())
partite().add_numreg(numreg);
if (_iva == nessuna_iva) if (_iva == nessuna_iva)
return _rel->status(); return _rel->status();
@ -657,10 +655,10 @@ int TPrimanota_application::read(TMask& m)
calcola_imp(); // Calcola totale imponibile ed imposte 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)); const TString16 dt(m.get(F_DATAREG));
set_numrif(m.get(F_NUMRIF));
set_pagamento(m.get(F_CODPAG), dt); set_pagamento(m.get(F_CODPAG), dt);
if (!read_scadenze(m)) if (!read_scadenze(m))
set_scadenze(m); set_scadenze(m);
@ -930,10 +928,20 @@ bool TPrimanota_application::remove()
_saldi.registra(); _saldi.registra();
check_saldi(); check_saldi();
if (_is_saldaconto && iva() == nessuna_iva) if (_is_saldaconto)
{ {
notify_cgline_deletion(0); // Notify deletion of all cg lines if (iva() == nessuna_iva)
_partite.rewrite(); {
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; return ok;

6
cg/cg2100b.uml
View File

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

8
cg/cg2100c.uml
View File

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

2
cg/cg2100s.uml
View File

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

7
cg/cg2101.cpp
View File

@ -160,14 +160,13 @@ bool TMovimentoPN::controlla_liquidazione(const TDate& data, bool reset) const
int TMovimentoPN::registra(bool re, bool force) 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); int err = re ? TRelation::rewrite(force) : TRelation::write(force);
if (err != NOERR) if (err != NOERR)
return err; return err;
const TRectype& m = curr();
const long numreg = m.get_long("NUMREG");
if (!re) if (!re)
_cg.renum_key("NUMREG", numreg); _cg.renum_key("NUMREG", numreg);
err = _cg.write(re); err = _cg.write(re);

11
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()) else if (!app().npart_is_prot())
{ {
if (m.get(F_NUMRIF).empty()) if (m.get(F_NUMRIF).empty())
{
m.set(F_NUMRIF, val); // copia numero documento m.set(F_NUMRIF, val); // copia numero documento
app().set_numrif(val);
}
} }
} }
} }
@ -1835,7 +1832,8 @@ bool TPrimanota_application::totdocval_handler(TMask_field& f, KEY key)
void TPrimanota_application::add_cgs_rit(bool fiscali) 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 char tipo = fiscali ? 'F' : 'S';
const int pos = type2pos(tipo); const int pos = type2pos(tipo);
@ -1853,13 +1851,13 @@ void TPrimanota_application::add_cgs_rit(bool fiscali)
else else
set_cgs_imp(pos, real2imp(imp, tipo)); set_cgs_imp(pos, real2imp(imp, tipo));
} }
m.field(F_CODIVA).on_hit();
} }
// Handler of the F_PROTIVA // Handler of the F_PROTIVA
bool TPrimanota_application::protiva_handler(TMask_field& f, KEY key) bool TPrimanota_application::protiva_handler(TMask_field& f, KEY key)
{ {
bool ok = TRUE; bool ok = TRUE;
const TString16 piva(f.get());
if (key == K_ENTER && f.dirty() && f.mask().mode() == MODE_INS) if (key == K_ENTER && f.dirty() && f.mask().mode() == MODE_INS)
{ {
const long protiva = atol(f.get()); 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()) if (app().npart_is_prot() && f.mask().is_running())
{ {
const TString16 piva(f.get());
f.mask().set(F_NUMRIF, piva); f.mask().set(F_NUMRIF, piva);
app().set_numrif(piva);
} }
} }
return ok; return ok;
} }

12
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_giornale_check; // Ignora controllo data stampa libro giornale
bool _skip_bollato_check; // Ignora controllo data stampa bollato bool _skip_bollato_check; // Ignora controllo data stampa bollato
bool _skip_write_scadenze; // Cancellato saldaconto, non riscrivere
bool _savenew; // Registra e nuovo bool _savenew; // Registra e nuovo
short _firstfocus; // Primo campo della maschera a prendere il focus 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) bool _is_saldaconto; // saldaconto si/no (vede parametri e causale)
TSaldo_agg _saldi; // Saldi da aggiornare TSaldo_agg _saldi; // Saldi da aggiornare
TPartite_array _partite; // Partite coinvolte 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 long _lastreg; // Numero ultima registrazione
int _mode; // Modo maschera corrente int _mode; // Modo maschera corrente
TBill _conto_ricavo; // Conto di ricavo del clifo TBill _conto_ricavo; // Conto di ricavo del clifo
TString_array _pag_rows; TString_array _pag_rows;
TString16 _numrif; // memorizza numrif per undo
static bool showpartite_handler(TMask_field& f, KEY k); static bool showpartite_handler(TMask_field& f, KEY k);
static bool speserimb_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 datacomp_handler(TMask_field& f, KEY key);
static bool data74ter_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 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 protiva_handler(TMask_field& f, KEY key);
static bool clifo_handler(TMask_field& f, KEY key); static bool clifo_handler(TMask_field& f, KEY key);
static bool totdoc_handler(TMask_field& f, KEY key); static bool totdoc_handler(TMask_field& f, KEY key);
@ -123,9 +122,6 @@ class TPrimanota_application : public TRelation_application
void reset_sheet_row(TSheet_field& s, int n); 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 protected: // TApplication
virtual void on_firm_change(); virtual void on_firm_change();
virtual void on_config_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) if (app().pagamento() != NULL)
{ {
app().pagamento()->set_numero_rate(atoi(f.get()), /*TBI*/-1); app().pagamento()->set_numero_rate(atoi(f.get()), /*TBI*/-1);
if (app().pagamento()->dirty()) if (app().pagamento()->dirty())
app().pagamento()->set_sheet(ps); app().pagamento()->set_sheet(ps);
} }
else f.set(""); 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() void TPrimanota_application::reset_pagamento()
{ {
if (_pag != NULL) 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) 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); const real spese(0.0);
TPagamento& pag = *pagamento(); 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_RDIFFER, pag.rate_differenziate() ? "1" : "2");
m.set(FS_NAMEPAG, pag.name()); m.set(FS_NAMEPAG, pag.name());
@ -399,20 +267,17 @@ bool TPrimanota_application::read_scadenze(TMask& m)
const TString16 codval (testa.get("CODVAL")); const TString16 codval (testa.get("CODVAL"));
const real cambio(testa.get("CAMBIO")); 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 TRectype& prima = _rel->cg(0);
const char sezione = prima.get_char("SEZIONE"); // Dare/Avere 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 nriga = 1;
const int numrig = 1; const int numrig = 1;
TBill clifo(gruppo, conto, sottoconto, tipocf); TBill clifo; clifo.get(prima);
TPartita part(clifo, anno, numpart); 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); int npart = part.prima_fattura(nreg);
bool fromscratch = FALSE; bool fromscratch = FALSE;
@ -420,8 +285,8 @@ bool TPrimanota_application::read_scadenze(TMask& m)
if (npart != -1) // la gh'e' if (npart != -1) // la gh'e'
{ {
TRiga_partite& partita = part.riga(npart); const TRiga_partite& partita = part.riga(npart);
TRiga_scadenze& primarata = partita.rata(1); const TRiga_scadenze& primarata = partita.rata(1);
// se si e' specificato un codice pagamento diverso si rifa' da capo // se si e' specificato un codice pagamento diverso si rifa' da capo
// la follia e' che e' sulle SCADENZE, non sulle partite, naturalmente // la follia e' che e' sulle SCADENZE, non sulle partite, naturalmente
@ -447,17 +312,14 @@ bool TPrimanota_application::read_scadenze(TMask& m)
else else
{ {
pag.zap_rate(); pag.zap_rate();
for (int i = 1; i <= partita.rate(); i++) for (int i = 1; i <= partita.rate(); i++)
{ {
TRiga_scadenze& scadenza = partita.rata(i); const TRiga_scadenze& scadenza = partita.rata(i);
real importo = scadenza.get(SCAD_IMPORTO);
real importo = scadenza.get(SCAD_IMPORTO);
const TDate scad = scadenza.get(SCAD_DATASCAD); const TDate scad = scadenza.get(SCAD_DATASCAD);
const int tipop = scadenza.get_int(SCAD_TIPOPAG); const int tipop = scadenza.get_int(SCAD_TIPOPAG);
const bool paid = scadenza.get_bool(SCAD_PAGATA); const bool paid = scadenza.get_bool(SCAD_PAGATA);
const TString16 ulc = scadenza.get(SCAD_ULTCLASS); const TString16 ulc = scadenza.get(SCAD_ULTCLASS);
pag.set_rata(i-1, importo, scad, tipop, ulc, paid); pag.set_rata(i-1, importo, scad, tipop, ulc, paid);
} }
} //else } //else
@ -475,133 +337,103 @@ bool TPrimanota_application::read_scadenze(TMask& m)
return TRUE; 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) 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); const int anno = m.get_int(F_ANNORIF);
const TString16 numpart(m.get(F_NUMRIF));
const long nreg = m.get_long(F_NUMREG);
CHECK(anno > 1900, "Anno partita non valido"); TPartita* newgame = NULL;
if (anno > 0 && numpart.not_empty())
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
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);
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);
// 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(); real imponibile(0.0);
real imposta(0.0);
real spese(0.0);
scadenza.put(SCAD_CODPAG, pag.code()); const TString16 ndoc(m.get(F_NUMDOC));
scadenza.put(SCAD_TIPOPAG, pag.tipo_rata(i)); const int tmov = causale().tipomov();
scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i)); const TDate ddoc(m.get(F_DATADOC));
scadenza.put(SCAD_IMPORTO, pag.tpay_rata(i)); const TDate dreg(m.get(F_DATAREG));
scadenza.put(SCAD_DATASCAD, pag.data_rata(i)); const TString16 reg (causale().reg().name());
scadenza.put(SCAD_PAGATA, pag.ratapagata(i)); 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);
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());
partita.elimina_rate();
for (int i = 0; i < pag.n_rate(); i++)
{
TRiga_scadenze& scadenza = 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_CODABIPR, pag.codabipr(i)); // TBI // scadenza.put(SCAD_CODABIPR, pag.codabipr(i)); // TBI
// scadenza.put(SCAD_CODCABPR, pag.codcabpr(i)); // TBI // scadenza.put(SCAD_CODCABPR, pag.codcabpr(i)); // TBI
}
} }
part.write(); 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);
}
}
}
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) 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); const long numreg = curr_mask().get_long(F_NUMREG);
int nrigp = partita.mov2rig(numreg, numrig); // Cerca riga partita relativa alla riga rmov int nrigp = partita.mov2rig(numreg, numrig); // Cerca riga partita relativa alla riga rmov
if (nrigp <= 0) // Devo creare una nuova riga di partita 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); nrigp = part.get_int(PART_NRIGA);
// Copia dati movimento corrente // Copia dati movimento corrente

323
cg/saldacon.cpp
View File

@ -32,23 +32,38 @@ TObject* TTree_rectype::dup() const
return r; 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 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 RecDes* recd = rec_des(); // Descrizione del record della testata
row.zero(); row.zero();
const KeyDes& kd = recd->Ky[numkey]; const KeyDes& kd = recd->Ky[0]; // Memento! Gli indici delle chiavi partono da zero!
for (int i = recd->Ky[numkey].NkFields-1; i >= 0; i--) for (int i = kd.NkFields-1; i >= 0; i--)
{ {
const int nf = kd.FieldSeq[i] % MaxFields; const int nf = kd.FieldSeq[i] % MaxFields;
const RecFieldDes& rf = recd->Fd[nf]; const RecFieldDes& rf = recd->Fd[nf];
const char* name = rf.Name; const char* name = rf.Name;
const TString& val = get(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() int TTree_rectype::fill_array()
{ {
TRectype* row = (TRectype*)_recarr.key().dup(); TRectype* row = (TRectype*)_recarr.key().dup();
@ -94,7 +109,7 @@ int TTree_rectype::rewrite(TBaseisamfile& f) const
return err; return err;
} }
int TTree_rectype::remove(TBaseisamfile& f) int TTree_rectype::remove(TBaseisamfile& f) const
{ {
int err = TRectype::remove(f); int err = TRectype::remove(f);
if (err == NOERR) if (err == NOERR)
@ -195,14 +210,12 @@ TRiga_scadenze::TRiga_scadenze(TRiga_partite* r)
: TTree_rectype(LF_SCADENZE, LF_PAGSCA, "NRIGP"), _riga(r) : TTree_rectype(LF_SCADENZE, LF_PAGSCA, "NRIGP"), _riga(r)
{ {
CHECK(_riga, "Riga nulla"); CHECK(_riga, "Riga nulla");
r->copy_key_to_row(*this);
} }
TRiga_scadenze::TRiga_scadenze(const TRiga_scadenze& s) TRiga_scadenze::TRiga_scadenze(const TRiga_scadenze& s)
: TTree_rectype(s), _riga(s._riga) : TTree_rectype(s), _riga(s._riga)
{}
{
CHECK(_riga, "Riga nulla");
}
TPartita& TRiga_scadenze::partita() const TPartita& TRiga_scadenze::partita() const
{ {
@ -411,14 +424,13 @@ bool TRiga_scadenze::modifica_pagamento(const TRectype& new_pag, const TValuta&
return empty; return empty;
} }
bool TPartita::modifica_pagamento(const TRectype& new_pag) bool TRiga_scadenze::elimina_pagamento(int p)
{ {
char old_ap, new_ap; TRectype old_pag(row(p));
TImporto old_abbuono, new_abbuono, old_diffcam, new_diffcam; old_pag.put(PAGSCA_ACCSAL, "A");
TValuta valuta; old_pag.zero(PAGSCA_IMPORTO);
return modifica_pagamento(new_pag, valuta, old_pag.zero(PAGSCA_IMPORTOVAL);
old_ap, old_abbuono, old_diffcam, return partita().modifica_pagamento(old_pag);
new_ap, new_abbuono, new_diffcam);
} }
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
@ -429,26 +441,31 @@ TRiga_partite::TRiga_partite(TPartita* game)
: TTree_rectype(LF_PARTITE, LF_SCADENZE, SCAD_NRATA), _partita(game) : TTree_rectype(LF_PARTITE, LF_SCADENZE, SCAD_NRATA), _partita(game)
{ {
CHECK(_partita, "Partita nulla"); 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) TRiga_partite::TRiga_partite(const TRiga_partite& r)
: TTree_rectype(r), _partita(r._partita) : TTree_rectype(r), _partita(r._partita)
{ {}
CHECK(_partita, "Partita nulla");
}
TRiga_scadenze& TRiga_partite::new_row(int r) TRiga_scadenze& TRiga_partite::new_row(int r)
{ {
if (r <= 0) r = last()+1; TRiga_scadenze& scad = (TRiga_scadenze&)TTree_rectype::new_row(r);
scad._riga = this;
return scad;
}
if (_recarr.rows() == 0) void TRiga_partite::elimina_rate()
{
for (int r = rate(); r > 0; r--)
{ {
TRiga_scadenze* scad = new TRiga_scadenze(this); TRiga_scadenze& scad = rata(r);
copy_key_to_row(*scad); for (int p = scad.last(); p > 0; p = scad.pred(p))
_recarr.set_key(scad); // Altrimenti le righe sarebbero dei TRectype! scad.elimina_pagamento(p);
rows_array().destroy_row(r);
} }
return (TRiga_scadenze&)_recarr.row(r, TRUE);
} }
int TRiga_partite::read(TBaseisamfile& f, word op) 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) if (err == NOERR && get_int(PART_TIPOMOV) == 1)
{ {
TRiga_scadenze* s = new TRiga_scadenze(this); TRiga_scadenze* s = new TRiga_scadenze(this);
copy_key_to_row(*s); err = rows_array().read(s); // Deve esistere almento una scadenza
err = _recarr.read(s); // Deve esistere almento una scadenza
} }
else else
_recarr.destroy_rows(); rows_array().destroy_rows();
return err; return err;
} }
@ -513,35 +529,44 @@ TPartita::TPartita(const TBill& clifo, int anno, const char* num)
read(clifo, anno, num); read(clifo, anno, num);
} }
TPartita::TPartita() int TPartita::compare(const TSortable& s) const
: _part(LF_PARTITE, PART_NRIGA), _unassigned(LF_PAGSCA, "NRIGP") {
{} 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 // 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 _conto = clifo;
partita->put(PART_TIPOCF, clifo.tipo()); // Tipo 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() <= ' ') if (clifo.tipo() <= ' ')
{ {
partita->put(PART_GRUPPO, clifo.gruppo()); // Scrivi gruppo e conto solamente str.cut(0); str << clifo.gruppo();
partita->put(PART_CONTO, clifo.conto()); // nei conti normali (no clifo) 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);
} }
partita->put(PART_SOTTOCONTO, clifo.sottoconto()); // Sottoconto o codice clifo str.cut(0); str << clifo.sottoconto();
partita->put(PART_ANNO, anno); // Anno partita partita->renum_key(PART_SOTTOCONTO, str); // Sottoconto o codice clifo
partita->put(PART_NUMPART, num); // Numero partita str.cut(0); str << anno();
partita->renum_key(PART_ANNO, str); // Anno partita
partita->renum_key(PART_NUMPART, num); // Numero partita
_part.read(partita); _part.read(partita);
TRectype unas(LF_PAGSCA); // Record campione pagamenti non assegnati TRectype* unas = new TRectype(LF_PAGSCA); // Record pagamenti non assegnati
unas.zero(); partita->copy_key_to_row(*unas);
unas.put(PART_TIPOCF, partita->get(PART_TIPOCF)); // Copia chiave partite unas->put(PART_NRIGA, (int)UNASSIGNED);
unas.put(PART_GRUPPO, partita->get(PART_GRUPPO)); unas->put(SCAD_NRATA, (int)UNASSIGNED);
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);
_unassigned.read(unas); _unassigned.read(unas);
return ok(); return ok();
@ -549,15 +574,20 @@ bool TPartita::read(const TBill& clifo, int anno, const char* num)
bool TPartita::reread() bool TPartita::reread()
{ {
TBill zio; return read(conto(), anno(), numero());
conto(zio);
const int year = anno();
const TString16 num = numero();
return read(zio, year, num);
} }
bool TPartita::write(bool re) const 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); int err = _part.write(re);
if (err == NOERR) if (err == NOERR)
err = _unassigned.write(re); 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 // Crea un nuova riga partite
TRiga_partite& TPartita::nuova_riga() TRiga_partite& TPartita::new_row(int r)
{ {
TRiga_partite& nuova = (TRiga_partite&)_part.row(last()+1, TRUE); if (r <= 0)
const TRiga_partite& prima = riga(first()); for (r = 1; esiste(r); r++);
nuova.put(PART_GRUPPOCL, prima.get(PART_GRUPPOCL)); CHECKD(!esiste(r), "Ue' pirla!, esiste gia' la riga ", r);
nuova.put(PART_CONTOCL, prima.get(PART_CONTOCL)); TRiga_partite& nuova = (TRiga_partite&)_part.row(r, TRUE);
return nuova; return nuova;
} }
@ -619,11 +649,11 @@ bool TPartita::esiste(int nriga, int nrata, int nrigp) const
if (nrigp <= 0) if (nrigp <= 0)
{ {
const TRiga_partite& r = riga(nriga); const TRiga_partite& r = riga(nriga);
return r.rows_array().exist(nrata); return r.exist(nrata);
} }
const TRiga_scadenze& r = rata(nriga, 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 // 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; saldo += imp;
} }
// Controlla se esistono pagamenti riferiti alla riga nrigp
bool TPartita::utilizzata(int nrigp) const bool TPartita::utilizzata(int nrigp) const
{ {
for (int p = last(); p > 0; p = pred(p)) for (int p = last(); p > 0; p = pred(p))
{ {
const TRiga_partite& fatt = riga(p); const TRiga_partite& fatt = riga(p);
const int tipomov = fatt.get_int(PART_TIPOMOV); for (int r = fatt.rate(); r > 0; r--)
if (tipomov == 1)
{ {
for (int r = fatt.rate(); r > 0; r--) const TRiga_scadenze& scad = fatt.rata(r);
{ if (scad.rows_array().exist(nrigp))
const TRiga_scadenze& scad = fatt.rata(r); return TRUE;
if (scad.rows_array().exist(nrigp))
return TRUE;
}
} }
} }
return _unassigned.exist(nrigp); return _unassigned.exist(nrigp);
@ -813,15 +839,29 @@ bool TPartita::modifica_pagamento(const TRectype& new_pag, const TValuta& valuta
else else
_unassigned.row(nrigp, FALSE) = new_pag; _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)) if (empty && !utilizzata(nrigp))
_part.destroy_row(nrigp); rimuovi_riga(nrigp);
return empty; 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 TPartita::chiusa(bool update)
{ {
bool chiusa = FALSE; bool chiusa = FALSE;
@ -869,73 +909,124 @@ bool TPartita::chiusa(bool update)
return chiusa; 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& 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); 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_ANNO);
knames.add(PART_NUMPART); knames.add(PART_NUMPART);
knames.add(PART_NRIGA); knames.add(PART_NRIGA);
knames.add(SCAD_NRATA);
for (int f = 0; f < row.items(); f++) knames.add(PAGSCA_NRIGP);
{
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++) for (int i = 1; i <= row.rate(); i++)
{ {
TRiga_scadenze& scd = row.rata(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)) for (int j = scd.last(); j > 0; j = scd.pred(j))
{ {
TRectype& pag = scd.row(j); const TRectype& pag = scd.row(j);
TRectype& npg = nsc.new_row();
knames = ""; CHECK(j < address_size, "Bad nrigp address");
knames.add(PAGSCA_NUMPART); if (address[j] == 0)
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); const TRiga_partite& vecchia = riga(j);
if (knames.get_pos(fnam) == -1) TRiga_partite& nuova = part.new_row(part.esiste(j) ? 0 :j);
npg.put(fnam, pag.get(fnam)); 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) // Sposta i pagamenti della riga r, dalla rata s compresa in poi, sui non assegnati
void TPartita::scollega_pagamenti(int r, int s)
{ {
TRiga_partite& row = riga(r); 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)) 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_NRIGA, (int)TPartita::UNASSIGNED);
pag.put(PAGSCA_NRATA, (int)TPartita::UNASSIGNED); pag.put(PAGSCA_NRATA, (int)TPartita::UNASSIGNED);
_unassigned.add_row(pag); _unassigned.add_row(pag);

40
cg/saldacon.h
View File

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