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

Nuova gestione pagamenti in valuta

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@2548 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
villa 1996-02-02 11:09:18 +00:00
parent c2179c9034
commit 7d041654d5
4 changed files with 584 additions and 420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
cg/cg2102.cpp
View File

@ -1315,8 +1315,9 @@ bool TPrimanota_application::iva_notify(TSheet_field& iva, int r, KEY k)
if (a.is_fattura() && m.insert_mode())
{
TPagamento& pag = a.pagamento();
real imposta, imponibile;
if (pag.in_valuta())
real imposta, imponibile;
bool inv = pag.in_valuta();
if (inv)
{
imposta = m.get_real(F_IMPOSTE) / pag.cambio(); imposta.round(3);
imponibile = m.get_real(SK_TOTDOCVAL) - imposta;
@ -1326,9 +1327,9 @@ bool TPrimanota_application::iva_notify(TSheet_field& iva, int r, KEY k)
imposta = m.get_real(F_IMPOSTE);
imponibile = m.get_real(F_TOTALE) - imposta;
}
imposta.round(pag.round()); imponibile.round(pag.round());
real pimposta(pag.imposta()); real pimponibile(pag.imponibile());
pimposta.round(pag.round()); pimponibile.round(pag.round());
imposta.round(pag.round(inv)); imponibile.round(pag.round(inv));
real pimposta(pag.imposta(inv)); real pimponibile(pag.imponibile(inv));
pimposta.round(pag.round(inv)); pimponibile.round(pag.round(inv));
if (pimposta != imposta || pimponibile != imponibile)
a.set_scadenze(m); // Ricalcola rate

120
cg/cg2104.cpp
View File

@ -38,11 +38,11 @@ bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
TToken_string ts(128), ns(128);
TString16 banca;
bool doit = TRUE, m_imp = FALSE, m_perc = FALSE, m_pag = FALSE;
bool doit = TRUE, m_impl = FALSE, m_impv = FALSE, m_perc = FALSE, m_pag = FALSE;
bool m_scad = FALSE, m_tipo = FALSE, m_ulc = FALSE, mod = FALSE, m_implit = FALSE;
word ahiahi = P_OK;
TString news(10), newi(15), newp(15), newil(15), newt(1), newu(1);
TString news(10), newl(15), newv(15), newp(15), newt(1), newu(1);
bool recalc = msk->get_bool(FS_RECALC);
bool mcomm = msk->get_bool(FS_MCOMM);
@ -60,26 +60,29 @@ bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
ts = rws.row(r);
news = ns.get(0); // Data scadenza
newi = ns.get(impos); // Imponibile (lire o valuta)
newl = ns.get(1); // Imponibile (lire)
newv = ns.get(2); // Imponibile (valuta)
newp = ns.get(3); // Percentuale
newt = ns.get(4); // Tipo pagamento
newu = ns.get(5); // Ulteriore classificazione
if (in_valuta)
{
newil = ns.get(1);
m_implit = real(newil) != real(ts.get(1));
}
// qui viene il bello, si fa per dire
if (news != ts.get(0)) // modificata data scadenza
mod = m_scad = TRUE;
if (real(newp) != real(ts.get(3))) // modificata percentuale
mod = m_perc = TRUE;
if (real(newi) != real(ts.get(impos))) // modificato importo
if (real(newl) != real(ts.get(1))) // modificato importo lire
{
// se si modifica la percentuale l'importo non viene cagato
// se si modifica la percentuale nessun importo viene cagato
if ((recalc && !m_perc) || (!recalc))
mod = m_imp = TRUE;
mod = m_impl = TRUE;
}
if (in_valuta && real(newv) != real(ts.get(2)))
{
// se si modifica la percentuale nessun importo viene cagato
if ((recalc && !m_perc) || (!recalc))
mod = m_impv = TRUE;
}
if (newt != ts.get(4)) // modificato tipo pagamento
mod = m_tipo = m_ulc = TRUE;
@ -133,13 +136,14 @@ bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
{
// ricalcola sheet come sai fare tu
ahiahi = pag.recalc_rate(r, m_perc,
((m_perc || m_imp) ?
(m_perc ? (const char*)newp : (const char*)newi) :
NULL),
((m_perc || m_impv) ?
(m_perc ? (const char*)newp : (const char*)newv) : NULL),
(m_impl ? (const char*)newl : NULL),
(m_scad ? (const char*)news : NULL),
(m_tipo ? (const char*)newt : NULL),
(m_ulc ? (const char*)newu : NULL),
rdiff, mcomm, need_recalc);
rdiff, mcomm, need_recalc);
// see if rdiff changed
msk->set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
msk->set(FS_NRATE, pag.n_rate());
@ -165,10 +169,19 @@ bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
trw.add(scd, 0);
}
}
if (m_imp)
if (m_impl)
{
trw.add(newi,4);
const real p = pag.recalc_percrata(r);
trw.add(newl,7);
// *** TBC la percentuale viene ricalcolata solo se si modifica in valuta
// const real p = pag.recalc_percrata(r, FALSE);
// ps.row(r).add(p.string(), 3);
// **********************************************************************
ps.force_update(r);
}
if (m_impv)
{
trw.add(newv,4);
const real p = pag.recalc_percrata(r, TRUE);
ps.row(r).add(p.string(), 3);
ps.force_update(r);
}
@ -178,11 +191,6 @@ bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
if (mod)
rws.row(r) = ps.row(r);
}
if (in_valuta && m_implit)
{
pag.set_implit(r, real(newil));
rws.row(r) = ps.row(r);
}
if (ahiahi) // any error? Rimetti le righe com'erano prima
{
@ -218,7 +226,7 @@ bool TPrimanota_application::pag_sheet_handler(TMask_field& f, KEY key)
pag.set_datadoc(dt);
word err = pag.validate();
if (m.edit_mode())
err &= ~(P_RSUM | P_TOTNC); // Ignora totale importi e rate
err &= ~(P_RSUM | P_TOTNCLIT | P_TOTNCVAL ); // Ignora totale importi e rate
if (err != P_OK)
{
TString s(256);
@ -233,7 +241,7 @@ bool TPrimanota_application::pag_sheet_handler(TMask_field& f, KEY key)
{
const real tot = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE);
for (int r = pag.n_rate()-1; r >= 0; r--)
imp += pag.tpay_rata(r);
imp += pag.tval_rata(r);
if (imp != tot)
{
const char* const pic = in_valuta ? ".3" : ".";
@ -524,17 +532,14 @@ bool TPrimanota_application::recalc_handler(TMask_field& f, KEY key)
{
// SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO
pag.set_tpr4(FALSE);
bool yak = pag.tpay_rata(0) != pag.importo_da_non_dividere();
bool yak = pag.tlit_rata(0) != pag.importo_da_non_dividere(FALSE);
if (pag.in_valuta()) yak |= (pag.tval_rata(0) != pag.importo_da_non_dividere(TRUE));
if (yak)
{
if (yesno_box("L'importo della prima rata e' stato modificato. "
"Con il ricalcolo automatico esso non sara' piu'"
" modificabile. Si desidera "
#ifdef DBG
"un sapiente pompino?"))
#else
"riportare le rate alle condizioni iniziali?"))
#endif
{
pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3);
m.set(FS_TIPOPR, pag.desc_tpr());
@ -672,22 +677,22 @@ void TPrimanota_application::set_totale_pagamento()
const TMask& m = curr_mask();
TPagamento& pag = pagamento();
pag.set_cambio(m.get_real(SK_CAMBIO), FALSE);
real cambio = m.get_real(SK_CAMBIO);
if (pag.in_valuta())
if (!cambio.is_zero())
{
imposta = m.get_real(F_IMPOSTE) / pag.cambio(); imposta.round(3);
imponibile = m.get_real(SK_TOTDOCVAL) - imposta;
const real totlit = m.get_real(F_TOTALE);
pag.set_totlit(totlit);
imposta = m.get_real(F_IMPOSTE);
real imposval = imposta/cambio; imposval.round(3);
real imponval = m.get_real(SK_TOTDOCVAL) - imposval;
imponibile = m.get_real(F_TOTALE) - imposta;
pag.set_total_valuta(imponval, imposval, spese, cambio, imponibile, imposta, spese);
}
else
{
imposta = m.get_real(F_IMPOSTE);
imponibile = m.get_real(F_TOTALE) - imposta;
pag.set_total(imponibile, imposta, spese);
}
pag.set_total(imponibile, imposta, spese);
}
void TPrimanota_application::set_scadenze(TMask& m)
@ -777,7 +782,7 @@ bool TPrimanota_application::read_scadenze(TMask& m)
pag.set_rata(i-1, impval, importo, scad, tipop, ulc, prot);
}
else
pag.set_rata(i-1, importo, ZERO, scad, tipop, ulc, prot);
pag.set_rata(i-1, ZERO, importo, scad, tipop, ulc, prot);
TToken_string& str = ps.row(i-1);
str.add(scadenza.get(SCAD_CODABIPR), 7);
@ -878,12 +883,8 @@ void TPrimanota_application::write_scadenze(const TMask& m)
for (int i = pag.n_rate()-1; i >= 0; i--)
{
if (in_valuta)
{
imponibile_val += pag.tpay_rata(i);
imponibile += pag.tlit_rata(i);
}
else
imponibile += pag.tpay_rata(i);
imponibile_val += pag.tval_rata(i);
imponibile += pag.tlit_rata(i);
}
partita.put(PART_IMPORTO, imponibile);
@ -899,21 +900,20 @@ void TPrimanota_application::write_scadenze(const TMask& m)
TToken_string& row = ps.row(i);
TRiga_scadenze& scadenza = partita.new_row();
scadenza.put(SCAD_CODPAG, codpag); // Codice pagamento
scadenza.put(SCAD_CODAG, agente); // Codice agente
scadenza.put(SCAD_DATASCAD, row.get(0)); // 0 = Data scadenza
scadenza.put(SCAD_IMPORTO, row.get()); // 1 = Importo
scadenza.put(SCAD_IMPORTOVAL, row.get()); // 2 = Importo in valuta
row.get(); // 4 = Percentuale
scadenza.put(SCAD_TIPOPAG, row.get()); // 5 = Tipo pagamento
scadenza.put(SCAD_ULTCLASS, row.get()); // 6 = Ulteriore classificazione
scadenza.put(SCAD_CODABIPR, row.get()); // 7 = Ns ABI
scadenza.put(SCAD_CODCABPR, row.get()); // 8 = Ns CAB
scadenza.put(SCAD_CODABI, row.get()); // 9 = Vs ABI
scadenza.put(SCAD_CODCAB, row.get()); //10 = Vs CAB
scadenza.put(SCAD_DESCR, row.get()); //11 = Note
scadenza.put(SCAD_BLOCCATA, row.get()); //12 = Non pagabile
scadenza.put(SCAD_CODPAG, codpag);
scadenza.put(SCAD_TIPOPAG, pag.tipo_rata(i));
scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i));
scadenza.put(SCAD_IMPORTO, pag.tlit_rata(i));
scadenza.put(SCAD_IMPORTO, row.get(1)); // 1 = Importo
scadenza.put(SCAD_IMPORTOVAL, row.get(2)); // 2 = Importo in valuta
scadenza.put(SCAD_DATASCAD, pag.data_rata(i));
scadenza.put(SCAD_CODABIPR, row.get(7));
scadenza.put(SCAD_CODCABPR, row.get(8));
scadenza.put(SCAD_CODABI, row.get(9));
scadenza.put(SCAD_CODCAB, row.get(10));
scadenza.put(SCAD_DESCR, row.get(11)); //11 = Note
scadenza.put(SCAD_BLOCCATA, row.get(12)); //12 = Non pagabile
scadenza.put(SCAD_CODAG, agente);
}
}

743
cg/pagament.cpp
View File

File diff suppressed because it is too large Load Diff

130
cg/pagament.h
View File

@ -21,22 +21,28 @@ const word P_SCAD = 0x0004; // scadenze non consecutive
const word P_INIZIO = 0x0008; // data 1a rata < data inizio pagamenti
const word P_NEG = 0x0010; // importo specificato < minimo possibile
const word P_TROP = 0x0020; // importo specificato > massimo possibile
const word P_TOTNC = 0x0040; // totale importi != totale pagamento
const word P_TOTNCLIT= 0x0040; // totale importi in lire != totale pagamento
const word P_MCOMM = 0x0080; // inconsistenza mese commerciale/scadenze
const word P_ZERO = 0x0100; // importo di una rata uguale a zero
const word P_ZEROLIT = 0x0100; // importo di una rata in lire uguale a zero
const word P_SCWIDE = 0x0200; // date di scadenza separate da piu' di 10000 giorni
const word P_TOOMANY = 0x0400; // troppe rate (piu' di 999)
const word P_TOTNCVAL= 0x0800; // totale importi in valuta != totale pagamento
const word P_ZEROVAL = 0x1000; // importo di una rata in valuta uguale a zero
class TPagamento : public TObject
{
TString _code; // codice
TString _name; // descrizione
real _imponibile; // imponibile da affettare
real _imposta; // imposta da affettare
real _spese; // spese da affettare
real _cambio; // cambio valuta
real _totlit; // imponibile in lire
TDistrib _slicer; // affettatrice
real _imponval; // imponibile da affettare
real _imposval; // imposta da affettare
real _speseval; // spese da affettare
real _imponlit; // imponibile da affettare in lire (se imp. in valuta)
real _imposlit; // imposta da affettare in lire
real _speselit; // spese da affettare in lire
real _cambio; // cambio valuta (TBZ?)
TDistrib _slicerlit; // affettatrice lire
TDistrib _slicerval; // affettatrice valuta
bool _new; // non letto da database
TString_array _rate; // rate medesime
char _inscad; // inizio scadenze: S1
@ -47,11 +53,14 @@ class TPagamento : public TObject
TDate _inizio; // data inizio pagamenti
TDate _datadoc; // data documento
bool _inited; // vero se c'e' un movimento di riferimento
real _firstr; // importo da pagare in prima rata (o distribuire se tpr == 0)
real _secndr; // importo da distribuire
real _firstr; // importo da pagare/distribuire in prima rata
real _secndr; // importo da distribuire/pagare
real _firstl; // importo da pagare/distribuire in lire (se valuta)
real _secndl; // importo da distribuire/pagare in lire
int _fixd[3]; // giorni scadenza fissa, se desiderati
int _round; // decimali arrotondamento importo
int _roundlit; // decimali arrotondamento importo in lire (sempre 0 per ora)
int _roundval; // decimali arrotondamento importo in valuta
int _int_rate;
int _rata_ifield(int n, int f) const;
@ -64,57 +73,66 @@ class TPagamento : public TObject
TString16 _def_ulc; // ulteriore classificazione default
bool _was_tpr4; // chiederne ragione ai responsabili morali (bonazzi, gabriella)
bool _in_valuta; // in valuta o non
protected:
protected:
// gestione casino se si modificano importi o percentuali rate
word change_value(int rata, real new_val, int rdiff, bool is_perc, bool mcomm);
word change_value_differenziate(int rata, real value, bool is_perc);
word change_value_uguali(int rata, real value, bool is_perc);
word change_value_uguali_prossima(int rata, real value, bool is_perc);
word change_value_uguali_possible(int rata, real value, bool is_perc);
word change_value(int rata, real new_val, int rdiff, bool is_perc, bool mcomm, bool v);
word change_value_differenziate(int rata, real value, bool is_perc, bool v);
word change_value_uguali(int rata, real value, bool is_perc, bool v);
word change_value_uguali_prossima(int rata, real value, bool is_perc, bool v);
word change_value_uguali_possible(int rata, real value, bool is_perc, bool v);
// aggiusta parametri diversi da importo se si sono aggiunte rate
void adjust_parameters(bool mcomm);
// riaggiusta le percentuali o gli importi rispetto al dato modificato
void adjust_perc_imp(bool is_perc, int rdiff);
void adjust_perc_imp(bool is_perc, int rdiff, bool v);
// riaggiusta le percentuali rispetto al dato modificato
void adjust_perc(int rdiff);
// riaggiusta l'importo in lire per consistenza con il totale documento in lire
void adjust_importo_lire();
void adjust_perc(int rdiff, bool v);
// controlla il segno di un valore in base a _tpr e row
bool sign_ok(const real& val, int row) const;
public:
// pregasi notare la straordinaria dovizia di const
const int n_rate() const { return _rate.items(); }
bool is_new() const { return _new; }
bool dirty() const { return _dirty; }
const int n_rate() const { return _rate.items(); }
bool is_new() const { return _new; }
bool dirty() const { return _dirty; }
const real& imponibile() const { return _imponibile; }
const real& imposta() const { return _imposta; }
const real& spese() const { return _spese; }
const real& imponibile(bool v = FALSE) { return v ? _imponval : _imponlit; }
const real& imposta(bool v = FALSE) { return v ? _imposval : _imposlit; }
const real& spese(bool v = FALSE) { return v ? _speseval : _speselit; }
const real& imponlit() const { return _imponlit; }
const real& imposlit() const { return _imposlit; }
const real& speselit() const { return _speselit; }
const real& imponval() const { return _imponval; }
const real& imposval() const { return _imposval; }
const real& speseval() const { return _speseval; }
const real& importo_da_dividere() const;
const real& importo_da_non_dividere() const;
const real& importo_da_dividere(bool v = FALSE) const;
const real& importo_da_non_dividere(bool v = FALSE) const;
const int round() const { return _round; }
real tval_rata(int n) const { return _rata_rfield(n,4);}
real tlit_rata(int n) const { return _rata_rfield(n,7);}
int scad_rata(int n) const { return _rata_ifield(n,0);}
real perc_rata(int n) const { return _rata_rfield(n,1);}
int tipo_rata(int n) const { return _rata_ifield(n,2);}
TDate data_rata(int n) const { return _rata_dfield(n,3);}
real tpay_rata(int n) const { return _rata_rfield(n,4);}
real importo_rata(int n, bool v = FALSE) const
{ return v ? tval_rata(n) : tlit_rata(n); }
const char* ulc_rata(int n) const { return _rata_sfield(n,5);}
bool ratapagata(int n) const { return _rata_sfield(n,6)[0] > ' ';}
real tlit_rata(int n) const { return _rata_rfield(n,7);}
char inizio_scadenza() const { return _inscad; }
bool mese_commerciale() const { return _mcomm; }
bool rate_differenziate() const { return _rdiff; }
int tipo_prima_rata() const { return _tpr; }
int intervallo_rate() const { return _int_rate; }
int decs() const { return _round; }
int round(bool v) const { return v ? _roundval : _roundlit; }
const TString& name() const { return _name; }
const TString& code() const { return _code; }
@ -133,20 +151,23 @@ public:
void set_tipo_prima_rata(int v, int sscad = -1);
void set_percrata(int n, real r);
void set_datarata(int n, const TDate & d);
real recalc_percrata(int i);
real recalc_percrata(int i, bool valuta);
// gestisce da se' casi con e senza valuta
void set_numero_rate(int n, int sscad = -1, int rdiff = 1);
void set_inizio(const TDate& d); // resetta tutto
void set_datadoc(const TDate & d) { _datadoc = d;}
void set_inizio_scadenza(char v) { _inscad = v; }
void set_code(const char* c) { _code = c; }
void set_round(int n) { _round = n; }
void set_cambio(const real& ex, bool recalc_lit);
bool in_valuta() const { return _cambio != 1.0; }
const real& cambio() const { return _cambio; }
void set_roundval(int n) { _roundval = n; }
void set_cambio(const real& ex, bool recalc_lit);
bool in_valuta() const;
const real& cambio() const { return _cambio; }
// check consistency: returns word with errors flagged, 0 if ok
word validate() const;
// writes description of errors err in s
void strerr(word err, TString& s);
// read/write from database
@ -154,20 +175,21 @@ public:
bool read(TTable* cpg = NULL, TTable* rpg = NULL);
// chiamabili solo da relapp, agiscono solo su %RPG
int write(TTable& rpg);
int write (TTable& rpg);
int rewrite(TTable& rpg);
int remove(TTable& rpg);
int remove (TTable& rpg);
// modifica rate manualmente o non
TToken_string& rata(int r) { return (TToken_string&)_rate[r]; }
TToken_string& add_rata (real perc, int day, int type, const char* ulc = "");
TToken_string& add_rata ();
TToken_string& set_rata (int index, real perc, int day, int type,
// setta rata senza automatismi, un importo solo (valuta o no)
TToken_string& set_rata (int index, real perc, int day, int type, bool valuta,
const char* ulc = NULL, const char* imp = NULL,
const char* data = NULL);
// questa calcola percentuali e scadenze a partire dagli importi
TToken_string& set_rata(int index, const real& howmuch, const real& quanto,
// calcola percentuali e scadenze a partire dagli importi
TToken_string& set_rata(int index, const real& impval, const real& implit,
const TDate& date, int type, const char* ulc, bool pagata);
// settano tipo rata e ult. class default per le rate; se bool = TRUE
@ -182,24 +204,22 @@ public:
void set_rate_auto();
// data una rata esistente, riaggiusta gli importi usando lo slicer e
// le scadenze usando la data di inizio
void set_imprata(int i, const real& r);
// setta l'importo in lire di una rata
void set_implit(int i, const real & r);
// setta l'imponibile in lire totale
void set_totlit(const real & r);
void set_imprata(int i, const real& r, bool val);
// slicer interface
void set_total(const real& ib, const real& im, const real& sp);
// only one of these must be called
void set_total(const real& ib, const real& im, const real& sp, bool valuta = FALSE);
void set_total_valuta(const real& ib, const real& im, const real& sp, const real& cambio,
const real& ibl, const real& iml, const real& spl);
// istanzia uno sheet field come diobue comanda
void set_sheet(TSheet_field& sf, int sscad = -1);
// ricalcola automaticamente tutto il ricalcolabile
// alla modifica di una percentuale (o di un importo)
// ritorna TRUE se non si poteva; non occorre che sia inizializzato
// con un importo
word recalc_rate(int row, bool is_perc_modified, const char* new_value,
const char* scad, const char* typ, const char* ulc, int rdiff,
bool mcomm, bool& need_recalc);
// ritorna TRUE (con errori OR-ati) se non si poteva;
word recalc_rate(int row, bool is_perc_modified, const char* new_value,
const char* new_lire, const char* scad, const char* typ,
const char* ulc, int rdiff, bool mcomm, bool& need_recalc);
// aggiusta scadenze fisse (tutte in un colpo)
void adjust_fixed_scad();