root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg2104.cpp
guy 090e470352 Gestione rate 
git-svn-id: svn://10.65.10.50/trunk@2374 c028cbd2-c16b-5b4b-a496-9718f37d4682
1996-01-03 12:10:02 +00:00

1061 lines
33 KiB
C++
Executable File
Raw Blame History

// --------------------------------------------------------------------------
// Scadenzario
// fv 24/8/94
// --------------------------------------------------------------------------
#include "pagament.h"
#include "saldacon.h"
#include "cg2102.h"
#include "cg2100.h"
#include "cg21sld.h"
#include <clifo.h>
#include <mov.h>
#include <partite.h>
#include <scadenze.h>
#include <pagsca.h>
#include <defmask.h>
TPagamento& TPrimanota_application::pagamento() const
{
CHECK(_pag, "Pagamento nullo");
return *_pag;
}
bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k)
{
TPagamento& pag = app().pagamento();
TMask* msk = &(ps.mask());
TString_array& rws = app().pag_rows();
const int rdiff = atoi(msk->get(FS_RDIFFER));
const bool in_valuta = pag.in_valuta();
const int impos = in_valuta ? 2 : 1;
// ts contiene la vecchia riga, ns la nuova
TToken_string ts(128), ns(128);
TString16 banca;
bool doit = TRUE, m_imp = FALSE, m_perc = FALSE, m_pag = FALSE;
bool m_scad = FALSE, m_tipo = FALSE, m_ulc = FALSE, mod = FALSE;
word ahiahi = P_OK;
TString news(10), newi(15), newp(15), newt(1), newu(1);
bool recalc = msk->get_bool(FS_RECALC);
bool mcomm = msk->get_bool(FS_MCOMM);
switch (k)
{
case K_ENTER:
ns = ps.row(r);
ts = rws.row(r);
news = ns.get(0); // Data scadenza
newi = ns.get(impos); // Imponibile (lire o valuta)
newp = ns.get(3); // Percentuale
newt = ns.get(4); // Tipo pagamento
newu = ns.get(5); // Ulteriore classificazione
// qui viene il bello, si fa per dire
if (news != ts.get(0)) // modificata data scadenza
mod = m_scad = TRUE;
if (newp != ts.get(3)) // modificata percentuale
mod = m_perc = TRUE;
if (newi != ts.get(impos)) // modificato importo
{
// se si modifica la percentuale l'importo non viene cagato
if ((recalc && !m_perc) || (!recalc))
mod = m_imp = TRUE;
}
if (newt != ts.get(4)) // modificato tipo pagamento
mod = m_tipo = m_ulc = TRUE;
if (newu != ts.get(5)) // modificata ulteriore classificazione
mod = m_ulc = TRUE;
break;
case K_DEL:
doit = !recalc;
if (doit)
{
pag.remove_rata(r);
const int nrate = msk->get_int(FS_NRATE) - 1;
msk->set(FS_NRATE, nrate);
}
break;
case K_INS:
// permette aggiunta e cancellazione solo se non c'e'
// ricalcolo automatico
doit = !recalc;
if (doit)
{
const int prev = r - 1;
const int nrate = msk->get_int(FS_NRATE) + 1;
const int gio_scad = pag.scad_rata(prev);
TDate data_scad(pag.data_rata(prev));
msk->set(FS_NRATE, nrate);
pag.add_rata(ZERO, gio_scad, pag.tipo_rata(prev), pag.ulc_rata(prev));
pag.next_scad(data_scad, gio_scad, pag.mese_commerciale(), r);
pag.set_datarata(r, data_scad);
pag.adjust_fixed_scad();
pag.set_sheet(ps);
rws = ps.rows_array();
}
break;
default:
break;
}
// settato da recalc_rate se occorre ridefinire lo sheet
// aggiungendo o togliendo righe
bool need_recalc = FALSE;
if (k == K_ENTER)
{
if (mod && recalc)
{
// 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_scad ? (const char*)news : NULL),
(m_tipo ? (const char*)newt : NULL),
(m_ulc ? (const char*)newu : NULL),
rdiff, mcomm, need_recalc);
// see if rdiff changed
msk->set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
msk->set(FS_NRATE, pag.n_rate());
}
if (!recalc)
{
ahiahi = P_OK;
// put data as they are
TToken_string& trw = pag.rata(r);
TToken_string srw = trw;
if (m_tipo) trw.add(newt,2);
if (m_scad) trw.add(news,3);
if (m_imp)
{
trw.add(newi,4);
const real p = pag.recalc_percrata(r);
ps.row(r).add(p.string(), 3);
rws.row(r) = ps.row(r);
ps.force_update(r);
}
}
if (ahiahi) // any error? Rimetti le righe com'erano prima
{
if (recalc)
{
TString err(80); pag.strerr(ahiahi,err);
warning_box(err);
ps.row(r) = rws.row(r);
ps.force_update(r);
}
}
else if (recalc && mod && need_recalc)
{
// ridefinisci lo sheet sulla base delle nuove rate
pag.set_sheet(ps);
rws = ps.rows_array();
}
}
return doit;
}
bool TPrimanota_application::pag_sheet_handler(TMask_field& f, KEY key)
{
bool ok = TRUE;
if (key == K_TAB || key == K_ENTER)
{
TMask& m = f.mask();
TPagamento& pag = app().pagamento();
word err = pag.validate();
if (m.edit_mode())
err &= ~(P_RSUM | P_TOTNC); // Ignora totale importi e rate
if (err != P_OK)
{
TString s(256);
pag.strerr(err, s);
ok = error_box(s);
}
if (key == K_ENTER && m.edit_mode())
{
const bool in_valuta = m.get(SK_VALUTA).not_empty();
const real tot = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE);
real imp;
for (int r = pag.n_rate()-1; r >= 0; r--)
imp += pag.tpay_rata(r);
if (imp != tot)
{
const char* const pic = in_valuta ? ".3" : ".";
const TString is(imp.string(pic));
const TString ts(tot.string(pic));
const bool recalc = yesno_box("Il totale delle rate e' %s mentre\n"
"il totale del documento in valuta e' %s.\n"
"Si desidera ricalcolare le rate e poi\n"
"registrare in un secondo momento?",
(const char*)is, (const char*)ts);
if (recalc)
{
app().set_scadenze(m);
ok = FALSE; // Permette di guardare il risultato prima di registrare
}
}
if (in_valuta)
{
const real totlit = m.get(F_TOTALE);
imp = ZERO;
for (int r = pag.n_rate()-1; r >= 0; r--)
imp += pag.tlit_rata(r);
if (imp != totlit)
{
const TString is(imp.string("."));
const TString ts(totlit.string("."));
warning_box("Il totale in lire delle rate e' %s mentre\n"
"il totale del documento e' %s.");
}
}
}
}
return ok;
}
bool TPrimanota_application::tipopag_handler(TMask_field& f, KEY key)
{
if ((key == K_TAB || key == K_ENTER) && f.dirty())
{
TMask& m = f.mask();
const int t = m.get_int(105);
const char u = m.get(106)[0];
const TPagamento& pag = app().pagamento();
const char* s = pag.desc_tipo(t, u);
m.set(107, s);
}
return TRUE;
}
bool TPrimanota_application::codpag_handler(TMask_field& f, KEY key)
{
TMask& m = f.mask();
if (m.insert_mode() && app().is_fattura())
{
if (key == K_TAB && f.focusdirty())
{
const TString16 dt(m.get(F_DATADOC));
app().set_pagamento(f.get(), dt);
app().set_scadenze(m);
}
if (key == K_ENTER && f.get().empty())
{
const char typ = app().clifo();
const long cod = m.get_long(typ == 'C' ? F_CLIENTE : F_FORNITORE);
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_TIPOCF, typ);
clifo.put(CLI_CODCF, cod);
if (clifo.read() == NOERR)
f.set(clifo.get(CLI_CODPAG));
return error_box("Il codice di pagamento e' obbligatorio!\n"
"Se possibile esso verra' proposto, ma potra'\n"
"essere modificato prima di registrare il movimento.");
}
}
return TRUE;
}
bool TPrimanota_application::annorif_handler(TMask_field& f, KEY key)
{
bool ok = TRUE;
const TMask& m = f.mask();
if (f.to_check(key) && f.get().empty() &&
(m.insert_mode() || m.get(F_NUMRIF).not_empty()))
{
const TString& anno = m.get(F_DATADOC).right(4);
f.set(anno);
ok = error_box("Il numero di riferimento partita e' obbligatorio!\n"
"Se possibile esso verra' proposto, ma potra'\n"
"essere modificato prima di registrare il movimento.");
}
return ok;
}
bool TPrimanota_application::numrif_handler(TMask_field& f, KEY key)
{
bool ok = TRUE;
if (f.to_check(key, TRUE))
{
TMask& m = f.mask();
const bool empty = f.get().blank();
if (empty && f.focusdirty() && m.insert_mode())
{
f.set(m.get(app()._npart_is_prot ? F_PROTIVA : F_NUMDOC));
if (m.get(F_CODPAG).empty())
{
TMask_field& clifo = m.field(app().iva() == iva_vendite ? F_CLIENTE : F_FORNITORE);
clifo.on_hit();
}
ok = error_box("Il numero di riferimento partita e' obbligatorio!\n"
"Se possibile esso verra' proposto, ma potra'\n"
"essere modificato prima di registrare il movimento.");
}
m.enable_page(2, !f.get().blank());
if (key == K_ENTER && m.edit_mode())
{
const TPartita* old = app().partite().first();
if (old && empty) // Se esisteva una partita ma ora non piu'
{
const KEY k = yesnocancel_box("Attenzione la fattura della partita %d %s verra' eliminata.\n"
"Premere SI per cancellarla, NO per ripristinarla, ANNULLA per modificarla",
old->anno(), (const char*)old->numero());
switch (k)
{
case K_NO:
f.set(old->numero());
if (m.get(F_ANNORIF).empty())
m.set(F_ANNORIF, old->anno());
break;
case K_ESC:
ok = FALSE;
break;
default:
break;
}
}
}
}
return ok;
}
bool TPrimanota_application::valuta_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.focusdirty())
{
TMask& m = f.mask();
TEdit_field& dc = m.efield(SK_DATACAMBIO);
if (dc.get().empty()) // Inizializza data cambio se assente
m.set(SK_DATACAMBIO, m.get(F_DATADOC), TRUE);
/*
const TDate datacam(dc.get());
const TRectype& rec = dc.browse()->cursor()->curr();
const TString& cur = rec.get("CODTAB");
TString16 key; key << f.get() << datacam.string(ANSI);
if (cur != key) // Se non esiste cambio per la nuova valuta
m.set(SK_CAMBIO, "", TRUE);
*/
}
return TRUE;
}
bool TPrimanota_application::cambio_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.focusdirty())
{
app().gioca_cambi(0x1); // Forza il ricalcolo del totale in lire
if (app().is_fattura())
{
TPagamento& pag = app().pagamento();
const real ex(f.get());
pag.set_cambio(ex);
TMask& m = f.mask();
if (m.insert_mode())
{
pag.set_rate_auto();
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
pag.set_sheet(ps);
app().pag_rows() = ps.rows_array();
}
// Copio la valuta a pagina 3
const TValuta val(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO);
val.set(m, FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO);
}
}
return TRUE;
}
bool TPrimanota_application::reset_handler(TMask_field& f, KEY key)
{
if (key == K_SPACE)
{
TMask& m = f.mask();
app().reset_pagamento(m);
app().set_scadenze(m);
}
return TRUE;
}
bool TPrimanota_application::recalc_handler(TMask_field& f, KEY key)
{
if (key == K_SPACE)
{
const bool recalc_aut = f.get().not_empty();
const TMask& m = f.mask();
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
ps.enable_column(3, recalc_aut);
ps.sheet_mask().enable(DLG_DELREC, !recalc_aut);
TPagamento& pag = app().pagamento();
if (pag.tipo_prima_rata() >= 4)
{
ps.enable_cell(0, 1, !recalc_aut);
ps.enable_cell(0, 2, !recalc_aut);
if (recalc_aut)
ps.disable_cell(0, 3);
}
ps.force_update();
}
return TRUE;
}
bool TPrimanota_application::nrate_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.focusdirty())
{
TPagamento& pag = app().pagamento();
pag.set_numero_rate(atoi(f.get()));
if (pag.dirty())
{
TMask& m = f.mask();
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
pag.set_sheet(ps);
app().pag_rows() = ps.rows_array();
}
}
return TRUE;
}
bool TPrimanota_application::codcab_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.focusdirty())
{
const TMask& m = f.mask();
const short id = f.dlg() == FS_NSCAB ? FS_NSABI : FS_VSABI;
const int pos = id == FS_NSABI ? 7 : 9; // Posizione codici ABI sullo sheet
const TString16 abi = m.get(id);
const TString16 cab = m.get(id+1);
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
for (int i = ps.items()-1; i >= 0; i--) // Setta la banca in tutte le righe
{
TToken_string& row = ps.row(i);
row.add(abi, pos);
row.add(cab, pos+1);
}
ps.force_update();
}
return TRUE;
}
bool TPrimanota_application::ratalit_handler(TMask_field& f, KEY key)
{
if (key == K_F8 || (key == K_TAB && f.get().empty()))
{
TPagamento& pag = app().pagamento();
if (pag.in_valuta())
{
TValuta v("", TDate(), pag.cambio());
const real other(f.mask().get(103));
TString16 s(v.val2lit(other).string());
f.set(s);
}
}
return TRUE;
}
bool TPrimanota_application::rataval_handler(TMask_field& f, KEY key)
{
if (key == K_F8 || (key == K_TAB && f.get().empty()))
{
TPagamento& pag = app().pagamento();
if (pag.in_valuta())
{
TValuta v("", TDate(), pag.cambio());
const real other(f.mask().get(102));
TString16 s(v.lit2val(other).string());
f.set(s);
}
}
return TRUE;
}
void TPrimanota_application::reset_pagamento(TMask&)
{
TPagamento& pag = pagamento();
pag.read();
pag.set_rate_auto();
}
void TPrimanota_application::recalc_scadenze(const TDate& d)
{
TPagamento& pag = pagamento();
pag.set_inizio(d);
// ridefinisci lo sheet sulla base delle nuove rate
TSheet_field& ps = pags();
TString_array& rws = pag_rows();
pag.set_sheet(ps);
rws = ps.rows_array();
}
void TPrimanota_application::set_pagamento(const char* c, const char* d)
{
if (_pag != NULL)
{
delete _pag;
_pag = NULL;
}
if (c != NULL || d != NULL)
_pag = new TPagamento(c, d);
}
void TPrimanota_application::set_scadenze(TMask& m)
{
const TString16 cp(m.get(F_CODPAG));
const TString16 dt(m.get(F_DATADOC));
set_pagamento(cp, dt);
real imponibile, imposta;
const real spese(0.0);
const real cambio(m.get(SK_CAMBIO));
TPagamento& pag = pagamento();
if (cambio <= 1.0)
{
imposta = m.get_real(F_IMPOSTE);
imponibile = m.get_real(F_TOTALE) - imposta;
}
else
{
pag.set_cambio(cambio);
imponibile = m.get_real(SK_TOTDOCVAL);
imposta = ZERO;
}
if (m.field(FS_RECALC).enabled())
{
m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
m.set(FS_NAMEPAG, pag.name());
m.set(FS_TIPOPR, pag.desc_tpr());
m.set(FS_MCOMM, pag.mese_commerciale() ? "X" : "");
m.set(FS_RECALC, m.insert_mode() ? "X" : "", TRUE);
m.set(FS_NRATE, pag.n_rate());
}
pag.set_total(imponibile, imposta, spese);
pag.set_rate_auto();
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
pag.set_sheet(ps); // prepara lo sheet
_pag_rows = ps.rows_array(); // copia sheet
}
bool TPrimanota_application::read_scadenze(TMask& m)
{
const TRectype& testa = _rel->curr();
const long nreg = testa.get_long(MOV_NUMREG);
const TDate datadoc = testa.get_date(MOV_DATADOC);
const TRectype& prima = _rel->cg(0);
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);
if (npart <= 0) // la gh'e' no!
return FALSE;
const TRiga_partite& partita = part.riga(npart);
TString codpag = testa.get(MOV_CODPAG);
if (partita.rate() > 0)
{
const TRiga_scadenze& primarata = partita.rata(1);
codpag = primarata.get(SCAD_CODPAG);
}
set_pagamento(codpag, datadoc.string());
const TValuta cambio(partita);
const bool in_valuta = cambio.in_valuta();
const real totale = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE);
if (totale != partita.importo(in_valuta).valore() ||
m.get_real(F_IMPOSTE) != partita.get_real(PART_IMPOSTA))
{
warning_box("Gli importi delle scadenze non corrispondono al totale documento");
}
real imponibile = partita.importo(in_valuta).valore();
real imposta = partita.get_real(PART_IMPOSTA);
real spese(0.0);
if (in_valuta)
{
cambio.lit2val(imposta);
cambio.lit2val(spese);
}
imponibile -= imposta;
TPagamento& pag = pagamento();
pag.set_total(imponibile, imposta, spese);
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
pag.zap_rate();
for (int i = 1; i <= partita.rate(); i++)
{
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);
if (in_valuta)
{
const real impval(scadenza.get(SCAD_IMPORTOVAL));
pag.set_rata(i-1, impval, importo, scad, tipop, ulc, paid);
}
else
pag.set_rata(i-1, importo, ZERO, scad, tipop, ulc, paid);
TToken_string& str = ps.row(i-1);
str.add(scadenza.get(SCAD_CODABIPR), 7);
str.add(scadenza.get(SCAD_CODCABPR), 8);
str.add(scadenza.get(SCAD_CODABI), 9);
str.add(scadenza.get(SCAD_CODCAB), 10);
if (i == 1)
{
m.set(FS_NSABI, str.get(7));
m.set(FS_NSCAB, str.get(8));
m.set(FS_VSABI, str.get(9));
m.set(FS_VSCAB, str.get(10));
m.set(FS_AGENTE, scadenza.get(SCAD_CODAG));
}
}
m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
m.set(FS_NAMEPAG, pag.name());
m.set(FS_TIPOPR, pag.desc_tpr());
m.set(FS_MCOMM, pag.mese_commerciale() ? "X" : "", TRUE);
m.set(FS_RECALC, m.insert_mode() ? "X" : "", TRUE);
m.set(FS_NRATE, pag.n_rate());
pag.set_sheet(ps);
_pag_rows = ps.rows_array();
return TRUE;
}
void TPrimanota_application::write_scadenze(const TMask& m)
{
const long nreg = m.get_long(F_NUMREG);
const int anno = m.get_int(F_ANNORIF);
const TString numpart(m.get(F_NUMRIF));
TPartita* oldgame = partite().first();
TPartita* newgame = NULL;
if (anno > 0 && !numpart.blank())
{
const TString 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 TString reg (causale().reg().name());
const TString desc(m.get(F_DESCR));
const TString codpag(m.get(F_CODPAG));
const long protiva = m.get_long(F_PROTIVA);
const TString codcaus(causale().codice());
const TValuta cambio (m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO);
const TString agente (m.get(FS_AGENTE));
const char sezione = get_cgs_imp(0).sezione(); // Dare/Avere
const TBill clifo(cgs().row(0), 2, 0x3);
newgame = new TPartita(clifo, anno, numpart);
const int row = newgame->prima_fattura(nreg); // Riga fattura di questo movimento
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_DESCR, desc);
partita.put(PART_CODCAUS, codcaus);
partita.put(PART_REG, reg);
partita.put(PART_PROTIVA, protiva);
partita.put(PART_SEZ, sezione);
partita.put(PART_IMPTOTDOC, m.get(F_TOTALE));
cambio.put(partita);
const bool in_valuta = cambio.in_valuta();
real imponibile, imponibile_val;
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);
}
partita.put(PART_IMPORTO, imponibile);
partita.put(PART_IMPORTOVAL, imponibile_val);
partita.put(PART_IMPOSTA, m.get(F_IMPOSTE));
partita.put(PART_SPESE, pag.spese());
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
partita.elimina_rata(-1);
for (i = 0; i < pag.n_rate(); i++)
{
TToken_string& row = ps.row(i);
TRiga_scadenze& scadenza = partita.new_row();
scadenza.put(SCAD_CODPAG, codpag);
scadenza.put(SCAD_TIPOPAG, pag.tipo_rata(i));
scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i));
if (partita.in_valuta())
{
scadenza.put(SCAD_IMPORTO, pag.tlit_rata(i));
scadenza.put(SCAD_IMPORTOVAL, pag.tpay_rata(i));
}
else
{
scadenza.put(SCAD_IMPORTO, pag.tpay_rata(i));
scadenza.zero(SCAD_IMPORTOVAL);
}
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_CODAG, agente);
scadenza.put(SCAD_PAGATA, pag.ratapagata(i));
}
}
if (oldgame != NULL)
{
const int rigafatt = oldgame->prima_fattura(nreg);
if (rigafatt > 0)
{
if (newgame == NULL || *oldgame != *newgame)
{
bool sposta = newgame != NULL;
if (sposta)
{
sposta = (oldgame->conto().sottoconto() == newgame->conto().sottoconto());
if (sposta)
sposta = yesno_box("Si desidera spostare la fattura ed i "
"pagamenti relativi nella nuova partita?");
}
if (sposta)
oldgame->sposta_riga(rigafatt, *newgame);
else
{
oldgame->scollega_pagamenti(rigafatt);
oldgame->rimuovi_riga(rigafatt);
}
oldgame->rewrite();
}
else
{
oldgame->sposta_riga(rigafatt, *newgame);
}
}
}
if (newgame != NULL) // Se non ho cancellato il numero partita ...
newgame->write(); // Salva nuova partita
}
///////////////////////////////////////////////////////////
// Gestione pagamenti
///////////////////////////////////////////////////////////
bool TPrimanota_application::showpartite_handler(TMask_field& f, KEY k)
{
bool ok = TRUE;
TMask& m = f.mask();
const char tipo = m.get(116)[0];
if (tipo == 'K' || (tipo == 'T' && app().causale().tipomov() == 2))
{
TSheet_field& s = *m.get_sheet();
const int riga = s.selected();
if (k == K_SPACE)
{
const bool ok = app().edit_partite(m, riga);
if (ok && riga < s.items())
k = K_ENTER;
}
if (k == K_ENTER)
{
const long curreg = app().curr_mask().get_long(F_NUMREG);
const TImporto importo(app().get_cgs_imp(riga));
const TImporto speso(app().partite().importo_speso(curreg, riga+1));
if (importo != speso)
{
const char* ss = speso.valore().string(".");
return f.error_box("L'importo deve essere %s %c", ss, speso.sezione());
}
if (tipo == 'K' && !speso.is_zero())
app().disable_cgs_cells(riga, 'K');
}
}
return ok;
}
// deleting significato
// -1 sto cancellando tutto
// 0 non sto cancellando nulla
// 1 sto cancellando la prima riga contabile
// n sto cancellando la ennesima riga contabile
bool TPrimanota_application::notify_edit_pagamento(TPartita& p, TRectype& new_pag,
const TValuta& valuta, int deleting)
{
const int nriga = new_pag.get_int(PAGSCA_NRIGA); // Riga fattura
const int nrata = new_pag.get_int(PAGSCA_NRATA); // Numero rata
const int nrigp = new_pag.get_int(PAGSCA_NRIGP); // Riga pagamento
const TRectype& old_pag = p.pagamento(nriga, nrata, nrigp);
const TRiga_partite& somma = p.riga(nrigp);
const int riga_contabile = somma.get_int(PART_NUMRIG); // Riga movimento
if (deleting >= 0)
{
const char sez = somma.sezione(); // Sezione importo e ritenute
const char controsez = sez == 'A' ? 'D' : 'A'; // Sezione contropartita
// Aggiornamento contopartita
const TImporto old_importo(controsez, old_pag.get_real(PAGSCA_IMPORTO));
TBill old_conto; old_conto.get(old_pag, TRUE);
const TImporto new_importo(controsez, new_pag.get_real(PAGSCA_IMPORTO));
TBill new_conto; new_conto.get(new_pag, TRUE);
if (old_importo != new_importo || old_conto != new_conto)
{
const int old_riga = bill2pos(old_conto, 'I');
if (old_riga >= 0)
{
const bool empty = sub_cgs_imp(old_riga, old_importo);
if (empty && (new_importo.is_zero() || new_conto != old_conto))
reset_cgs_row(old_riga);
}
// Importo della contropartita
if (!new_importo.is_zero() && new_conto.ok())
{
const int new_riga = bill2pos(new_conto, 'I');
if (new_riga < 0)
{
const int tp = somma.get_int(PART_TIPOPAG);
const int da = p.tipopag2causale(tp);
const TString descagg(causale().desc_agg(da));
set_cgs_row(new_riga, new_importo, new_conto, descagg, 'I');
}
else
add_cgs_imp(new_riga, new_importo);
}
}
// Aggiornamento ritenute
const real old_ritenute(old_pag.get(PAGSCA_RITENUTE));
const real new_ritenute(new_pag.get(PAGSCA_RITENUTE));
if (old_ritenute != new_ritenute)
{
const TImporto grow_ritenute(controsez, new_ritenute-old_ritenute);
const riga = type2pos('F');
if (riga < 0)
{
TBill conto_rit; causale().bill(11, conto_rit);
const TString desc(causale().desc_agg(11));
set_cgs_row(riga, grow_ritenute, conto_rit, desc, 'F');
}
else
{
const bool empty = add_cgs_imp(riga, grow_ritenute);
if (empty) reset_cgs_row(riga);
}
}
} // if (deleting != 0)
char old_ap, new_ap;
TImporto old_abbuono, new_abbuono, old_diffcam, new_diffcam;
const bool empty = p.modifica_pagamento(new_pag, valuta,
old_ap, old_abbuono, old_diffcam,
new_ap, new_abbuono, new_diffcam, TRUE);
if (deleting >= 0)
{
// Se c'e' differenza negli abbuoni
if (old_abbuono != new_abbuono || old_ap != new_ap)
{
if (old_ap != ' ') // Se c'era un abbuono ...
{
const int riga_abb = type2pos(old_ap);
CHECK(riga_abb >= 0, "Chiss'e' fregato gli abbuoni?");
const bool empty = add_cgs_imp(riga_abb, old_abbuono);
if (empty && new_ap != old_ap)
cgs().destroy(riga_abb);
if (deleting != riga_contabile)
{
// Sottrae l'abbuono con la sezione invertita dalla riga contabile
sub_cgs_imp(riga_contabile-1, old_abbuono);
}
}
if (new_ap != ' ') // Se ci sono abbuoni
{
const riga_abb = type2pos(new_ap);
new_abbuono.swap_section();
new_abbuono.normalize();
if (riga_abb < 0)
{
const int rc = new_ap == 'A' ? 9 : 8;
TBill conto_abb; causale().bill(rc, conto_abb);
const TString desc(causale().desc_agg(rc));
app().set_cgs_row(riga_abb, new_abbuono, conto_abb, desc, new_ap);
}
else
add_cgs_imp(riga_abb, new_abbuono);
if (deleting != riga_contabile)
{
// Aggiunge l'abbuono con la sezione invertita
sub_cgs_imp(riga_contabile-1, new_abbuono);
}
}
}
// Se c'e' variazione nella differenza cambi
if (old_diffcam != new_diffcam)
{
const int riga_diffcam = type2pos('C');
TImporto grow_diffcam(old_diffcam);
grow_diffcam -= new_diffcam;
grow_diffcam.normalize();
if (riga_diffcam < 0)
{
TBill conto_diffcam; causale().bill(12, conto_diffcam);
const TString desc(causale().desc_agg(12));
set_cgs_row(riga_diffcam, grow_diffcam, conto_diffcam, desc, 'C');
}
else
{
const bool empty = add_cgs_imp(riga_diffcam, grow_diffcam);
if (empty) cgs().destroy(riga_diffcam);
}
if (deleting != riga_contabile)
{
// Aggiunge la differenza con la sezione invertita
sub_cgs_imp(riga_contabile-1, grow_diffcam);
}
}
} // if (deleting >= 0)
return empty;
}
// Scorre tutte le righe della partita ed azzera i pagamenti relativi a alla riga contabile
// cancellata e decrementa i numeri riga superiori a numrig
bool TPrimanota_application::notify_cgline_deletion(TPartita& partita, long nreg, int numrig)
{
bool found = FALSE;
for (int p = partita.last(); p > 0; p = partita.pred(p))
{
TRiga_partite& part = partita.riga(p);
if (part.is_fattura())
{
for (int r = part.rate(); r > 0; r--)
{
const TRiga_scadenze& scad = part.rata(r);
for (int s = scad.last(); s > 0; s = scad.pred(s))
{
const TRiga_partite& sum = partita.riga(s);
if (sum.get_long(PART_NREG) == nreg &&
(numrig <= 0 || sum.get_int(PART_NUMRIG) == numrig))
{
TRectype nul_pag(scad.row(s));
nul_pag.zero(PAGSCA_IMPORTO);
nul_pag.zero(PAGSCA_IMPORTOVAL);
nul_pag.zero(PAGSCA_RITENUTE);
nul_pag.put(PAGSCA_ACCSAL, 'A');
const TValuta val; // Non cambiare valuta
notify_edit_pagamento(partita, nul_pag, val, numrig);
found = TRUE;
}
}
}
}
else
{
if (numrig > 0 && part.get_long(PART_NREG) == nreg && part.get_int(PART_NUMRIG) > numrig)
part.put(PART_NUMRIG, numrig-1);
}
}
TRecord_array& unas = partita.unassigned();
for (int u = unas.last_row(); u > 0; u = unas.pred_row(u))
{
const TRiga_partite& sum = partita.riga(u);
if (sum.get_long(PART_NREG) == nreg &&
(numrig <= 0 || sum.get_int(PART_NUMRIG) == numrig))
{
TRectype nul_pag(unas.row(u, FALSE));
nul_pag.zero(PAGSCA_IMPORTO);
nul_pag.zero(PAGSCA_IMPORTOVAL);
nul_pag.zero(PAGSCA_RITENUTE);
nul_pag.put(PAGSCA_ACCSAL, 'A'); // Inutile, ma l'ho copiato da sopra
const TValuta val; // Non cambiare valuta
notify_edit_pagamento(partita, nul_pag, val, numrig);
found = TRUE;
}
}
return found;
}
bool TPrimanota_application::notify_cgline_deletion(int numrig)
{
bool found = FALSE;
const long nreg = curr_mask().get_long(F_NUMREG);
for (TPartita* game = partite().first(); game; game = partite().next())
found |= notify_cgline_deletion(*game, nreg, numrig);
return found;
}
Reference in New Issue View Git Blame Copy Permalink