root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg2104.cpp
guy ceb86a9c6b cg0500.cpp Corretta lettura anno iva da config 
cg2100.cpp     Rifatta gestione pagamento immediato
cg2102.cpp     COrretto handler della data di registrazione
cg2104.cpp     Corretta gestione numero di riferimento partita
cg2105.cpp     Proposto in automatico l'importo dei pagamenti
cg2200.cpp     Azzerata ad ogni ciclo la maschera dei provisori
cg3100.cpp     Eliminati tutti gli accessi diretti alla tabella esercizi
cg3600.cpp     Aggiunta gestione e salvataggio colonne
cglib04.cpp    Tolti accessi diretti alla tabella degli esercizi
pagament.cpp   Corretta creazione nuove rate rispettando le classificazioni


git-svn-id: svn://10.65.10.50/trunk@3985 c028cbd2-c16b-5b4b-a496-9718f37d4682
1996-12-10 08:23:20 +00:00

1280 lines
40 KiB
C++
Executable File
Raw Blame History

// --------------------------------------------------------------------------
// Scadenzario
// fv 24/8/94
// --------------------------------------------------------------------------
#include "pagament.h"
#include "saldacon.h"
#include "utility.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 = msk->get_int(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_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), newl(15), newv(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_SPACE:
{
const bool can = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X';
ps.sheet_mask().enable(DLG_DELREC, can);
}
break;
case K_ENTER:
ns = ps.row(r);
ts = rws.row(r);
news = ns.get(0); // Data scadenza
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
// 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(newl) != real(ts.get(1))) // modificato importo lire
{
// se si modifica la percentuale nessun importo viene cagato
if ((recalc && !m_perc) || (!recalc))
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;
if (newu != ts.get(5)) // modificata ulteriore classificazione
mod = m_ulc = TRUE;
else if (m_tipo) {
// forza reset di ulc se si e' modificato il tipo rata
m_ulc = TRUE;
newu = "";
}
break;
case K_DEL:
doit = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X';
if (doit)
{
pag.remove_rata(r);
msk->set(FS_NRATE, pag.n_rate());
}
break;
case K_INS:
// permette aggiunta e cancellazione solo se non c'e' ricalcolo automatico
doit = !recalc;
break;
case K_CTRL+K_INS: // Post inserimento
{
const int prev = r - 1;
const int gio_scad = pag.scad_rata(prev);
TDate data_scad(pag.data_rata(prev));
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_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);
// 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_ulc)
trw.add(newu, 5);
if (m_scad)
{
trw.add(news,3);
if (r > 0)
{
TDate d(news);
int scd = (int)(d - pag.data_rata(r-1));
if (pag.mese_commerciale() && (scd % 30) != 0)
scd = 30 * ((scd/30)+1);
trw.add(scd, 0);
}
}
if (m_impl)
{
trw.add(newl,7);
if (!in_valuta)
{
// si ricalcola la percentuale a modifica importo in lire solo
// se non c'e' l'importo 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);
}
else
if (m_tipo)
ps.force_update(r);
if (mod)
rws.row(r) = ps.row(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();
const TDate dt(m.get(F_DATADOC));
pag.set_datadoc(dt);
word err = pag.validate();
if (m.edit_mode())
err &= ~(P_RSUM | P_TOTNCLIT | P_TOTNCVAL ); // Ignora totale importi e rate
if (err != P_OK)
{
TString s(256);
pag.strerr(err, s);
return f.error_box(s);
}
const bool in_valuta = m.get(SK_VALUTA).not_empty();
real imp;
if (key == K_ENTER && m.edit_mode())
{
real tot = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE);
for (int r = pag.n_rate()-1; r >= 0; r--)
imp += in_valuta ? pag.tval_rata(r) : pag.tlit_rata(r);
imp.round(pag.round(in_valuta));
tot.round(pag.round(in_valuta));
if (imp != tot)
{
const char* const pic = in_valuta ? ".3" : ".";
const TString is(imp.string(pic));
const TString ts(tot.string(pic));
ok = yesno_box("Il totale delle rate e' %s mentre\n"
"il totale del documento e' %s.\n"
"Si desidera registrare ugualmente?",
(const char*)is, (const char*)ts);
}
}
if (key == K_ENTER && 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);
imp.round(pag.round(FALSE));
if (imp != totlit)
{
const TString is(imp.string("."));
const TString ts(totlit.string("."));
ok = yesno_box("Il totale in lire delle rate e' %s mentre\n"
"il totale del documento e' %s.\n"
"Si desidera registrare ugualmente?",
(const char*)is, (const char*)ts);
}
}
}
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();
int t = m.get_int(105);
if (t <= 0)
{
t = 1;
f.set("1");
}
const char u = m.get(106)[0];
const TPagamento& pag = app().pagamento();
bool ok;
const char* s = pag.desc_tipo(t, u, &ok);
if (!ok) m.reset(106);
m.set(107, s);
}
return TRUE;
}
bool TPrimanota_application::codpag_handler(TMask_field& f, KEY key)
{
bool ok = TRUE;
TMask& m = f.mask();
TPrimanota_application& a = app();
const bool set_scad = a.is_fattura() && m.page_enabled(2); // E' attiva pagina 3
if (key == K_ENTER)
{
if (set_scad && f.get().empty())
{
f.error_box("Il codice di pagamento e' obbligatorio!");
/*
"Se possibile esso verra' proposto, ma potra'\n"
"essere modificato prima di registrare il movimento.");
*/
const char typ = a.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)
{
const TString& cp = clifo.get(CLI_CODPAG);
if (cp.not_empty())
{
f.set(cp);
key = K_TAB;
}
}
ok = FALSE;
}
}
if (key == K_TAB && f.focusdirty() && m.insert_mode() && set_scad)
a.set_scadenze(m);
return ok;
}
bool TPrimanota_application::annorif_handler(TMask_field& f, KEY key)
{
bool ok = TRUE;
if (f.to_check(key))
{
const TMask& m = f.mask();
if (!m.get(F_NUMRIF).blank() && f.get().empty())
{
const TString& anno = m.get(F_DATADOC).right(4);
f.set(anno);
ok = error_box("L'anno di riferimento partita e' obbligatorio!");
/*
"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))
{
TPrimanota_application& a = app();
TMask& m = f.mask();
bool required = m.insert_mode() && a.is_fattura();
required &= key == K_ENTER || f.focusdirty();
required &= !(m.get_bool(F_SOLAIVA) || m.field(F_OCCASEDIT).active());
if (required && f.get().blank())
{
if (m.get(F_CODPAG).empty())
{
TMask_field& clifo = m.field(a.iva() == iva_vendite ? F_CLIENTE : F_FORNITORE);
clifo.set_dirty();
clifo.on_hit();
}
TMask_field& anno = m.field(F_ANNORIF);
if (m.get(F_ANNORIF).empty())
m.set(F_ANNORIF, m.get(F_DATADOC).right(4));
f.set(m.get(a._npart_is_prot ? F_PROTIVA : F_NUMDOC));
key = K_TAB; // Forza la successiva activate_numrif
ok = f.error_box("Il numero di riferimento partita e' obbligatorio!");
/*
"Se possibile esso verra' proposto, ma potra'\n"
"essere modificato prima di registrare il movimento.");
*/
}
if (key == K_TAB && a.is_fattura())
a.activate_numrif(m, TRUE);
if (ok && key == K_ENTER && m.edit_mode())
{
const TPartita* old = a.partite().first();
if (old && old->ok() && f.get().blank()) // 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.to_check(key, TRUE))
{
TMask& m = f.mask();
const TString val = f.get();
const bool full = val.not_empty();
if (full)
{
TMask_field& dc = m.field(SK_DATACAMBIO);
if (dc.get().empty()) // Inizializza data cambio se assente
dc.set(m.get(F_DATADOC));
if (f.focusdirty())
{
dc.set_dirty();
dc.check(RUNNING_CHECK); // Forza ricerca cambio
dc.on_hit(); // Forza messaggi (eventuale copia a pag. 3)
}
}
else
{
m.set(SK_CAMBIO, "", TRUE);
m.set(SK_TOTDOCVAL, "", TRUE);
}
m.enable(SK_CAMBIO, full);
m.enable(SK_TOTDOCVAL, full);
if (app().is_fattura())
m.set(FS_VALUTA, val); // Copia a pagina 3
}
return TRUE;
}
bool TPrimanota_application::datacambio_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.to_check(key, TRUE))
{
if (app().is_fattura())
f.mask().set(FS_DATACAMBIO, f.get()); // Copia a pagina 3
}
return TRUE;
}
bool TPrimanota_application::cambio_handler(TMask_field& f, KEY key)
{
if (key == K_TAB && f.to_check(key, TRUE))
{
TMask& m = f.mask();
TPrimanota_application& a = app();
bool update = a.is_fattura(); // Devo ricopiarmi a pagina 3?
if (f.focusdirty())
{
// Forza il ricalcolo del totale in lire se necessario
a.gioca_cambi(m.insert_mode() ? 0x1 : 0x0);
}
else
update &= !m.is_running();
if (update)
m.set(FS_CAMBIO, f.get()); // Copia a pagina 3
}
return TRUE;
}
bool TPrimanota_application::reset_handler(TMask_field& f, KEY key)
{
if (key == K_SPACE)
{
TMask& m = f.mask();
app().reset_pagamento();
app().set_scadenze(m);
}
return TRUE;
}
bool TPrimanota_application::recalc_handler(TMask_field& f, KEY key)
{
TPrimanota_application& a = app();
if (key == K_SPACE && a.is_fattura())
{
TMask& m = f.mask();
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
TPagamento& pag = a.pagamento();
const bool recalc_aut = f.get().not_empty();
if (!recalc_aut && pag.tipo_prima_rata() > 3)
{
// SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO
pag.set_tipo_prima_rata(pag.tipo_prima_rata() - 3);
m.set(FS_TIPOPR, pag.desc_tpr());
pag.set_tpr4(TRUE);
}
else if (recalc_aut && pag.was_tpr4())
{
// SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO
pag.set_tpr4(FALSE);
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 "
"riportare le rate alle condizioni iniziali?"))
{
pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3);
m.set(FS_TIPOPR, pag.desc_tpr());
a.reset_pagamento();
a.set_scadenze(m);
}
else warning_box("Il tipo prima rata e' stato modificato in \"%s\" per "
"poter mantenere la rateazione scelta e la possibilita' di "
"ricalcolo automatico",
pag.desc_tpr());
}
else
{
pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3);
m.set(FS_TIPOPR, pag.desc_tpr());
}
}
const bool on = pag.tipo_prima_rata() < 4 || !recalc_aut;
ps.enable_cell(0, 1, on);
ps.enable_cell(0, 2, on);
ps.enable_cell(0, 3, on);
ps.enable_column(3, recalc_aut);
ps.sheet_mask().enable(DLG_DELREC, !recalc_aut);
}
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();
}
f.set(format("%d", pag.n_rate()));
}
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()))
{
const TPagamento& pag = app().pagamento();
if (pag.in_valuta())
{
const TValuta v(app().curr_mask(), FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO);
const real other(f.mask().get(103));
const char* 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())
{
const TValuta v(app().curr_mask(), FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO);
const real other(f.mask().get(102));
TString16 s(v.lit2val(other).string());
f.set(s);
}
}
return TRUE;
}
void TPrimanota_application::reset_pagamento()
{
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)
{
if (!TDate::isdate(d))
d = "";
_pag = new TPagamento(c, d);
}
}
void TPrimanota_application::set_totale_pagamento(bool update)
{
const TMask& m = curr_mask();
TPagamento& pag = pagamento();
const real imposta = m.get_real(F_IMPOSTE);
const real imponibile = m.get_real(F_TOTALE) - imposta;
const real spese = ZERO;
const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO);
if (cambio.in_valuta())
{
const real imposval = cambio.lit2val(imposta);
const real imponval = m.get_real(SK_TOTDOCVAL) - imposval;
pag.set_total_valuta(imponval, imposval, spese, cambio.cambio(),
imponibile, imposta, spese);
}
else
{
pag.set_total(imponibile, imposta, spese);
}
if (update)
{
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
pagamento().set_sheet(ps); // Aggiorna lo sheet
pag_rows() = ps.rows_array(); // copia sheet
}
}
void TPrimanota_application::set_scadenze(TMask& m)
{
const TString cp(m.get(F_CODPAG));
const TString dt(m.get(F_DATADOC));
set_pagamento(cp, dt);
set_totale_pagamento(FALSE);
TPagamento& pag = pagamento();
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_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 int anno = m.get_int(F_ANNORIF);
const TString16 numpart(m.get(F_NUMRIF));
if (anno <= 0 || numpart.blank()) // Partita vuota
return FALSE;
TBill clifo; cerca_conto_cf(clifo);
const TPartita& part = partite().partita(clifo, anno, numpart);
const TRectype& testa = _rel->curr();
const long nreg = testa.get_long(MOV_NUMREG);
const TDate datadoc = testa.get_date(MOV_DATADOC);
const int npart = part.prima_fattura(nreg);
if (npart <= 0) // Non esiste una riga per questo movimento
{
partite().destroy();
return FALSE; // Non dovrebbe succedere mai, in quanto gia' beccato sopra!
}
// Determino il codice pagamento dalla riga di fattura
TString codpag;
const TRiga_partite& partita = part.riga(npart);
if (partita.rate() > 0)
{
const TRiga_scadenze& primarata = partita.rata(1);
codpag = primarata.get(SCAD_CODPAG);
}
set_pagamento(codpag, datadoc.string());
TPagamento& pag = pagamento();
const bool in_valuta = m.get(SK_VALUTA).not_empty();
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");
}
set_totale_pagamento(FALSE);
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
const int protette = partita.ultima_rata_con_abbuoni_diffcam();
pag.zap_rate(); // Azzera pagamento
for (int i = 1; i <= partita.rate(); i++) // E' necessario andare in avanti!!!
{
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 prot = i <= protette; // Non cancellabile
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, prot);
}
else
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);
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));
}
str.add(scadenza.get(SCAD_DESCR), 11);
str.add(scadenza.get(SCAD_BLOCCATA), 12);
str.add(prot ? "X" : " ", 13);
}
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;
}
int TPrimanota_application::cerca_conto_cf(TBill& bill) const
{
const char tipocf = clifo();
const long codcf = curr_mask().get_long(tipocf == 'C' ? F_CLIENTE : F_FORNITORE);
TString_array& a = cgs().rows_array();
for (int r = 0; r < a.items(); r++)
{
TToken_string& row = a.row(r);
bill.get(row, 2, 0x1);
if (bill.tipo() == tipocf && bill.codclifo() == codcf)
return r;
}
bill.set(0, 0, codcf, tipocf);
return -1;
}
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;
int nuova_riga = 0;
if (anno > 0 && !numpart.blank() && m.page_enabled(2))
{
const int tmov = causale().tipomov();
const TString desc(m.get(F_DESCR));
const TString codpag(m.get(F_CODPAG));
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
TBill clifo;
const int riga_clifo = cerca_conto_cf(clifo);
CHECK(riga_clifo >= 0, "Impossibile generare la fattura senza gruppo/conto cliente");
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);
nuova_riga = partita.get_int(PART_NRIGA);
TPagamento& pag = pagamento();
// put data on partita
partita.put(PART_TIPOMOV, tmov);
partita.put(PART_NREG, nreg);
partita.put(PART_NUMRIG, riga_clifo+1);
partita.put(PART_DATAREG, m.get(F_DATAREG));
partita.put(PART_DATADOC, m.get(F_DATADOC));
partita.put(PART_NUMDOC, m.get(F_NUMDOC));
partita.put(PART_DESCR, desc);
partita.put(PART_CODCAUS, codcaus);
partita.put(PART_REG, causale().reg().name());
partita.put(PART_PROTIVA, m.get_long(F_PROTIVA));
partita.put(PART_SEZ, sezione);
const TImporto totdoc = get_cgs_imp(riga_clifo);
partita.put(PART_IMPTOTDOC, totdoc.valore());
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.tval_rata(i);
imponibile += pag.tlit_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); // Elimina tutte le rate eventuali
for (i = 0; i < ps.items(); i++)
{
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(); // 3 = Percentuale
scadenza.put(SCAD_TIPOPAG, row.get()); // 4 = Tipo pagamento
scadenza.put(SCAD_ULTCLASS, row.get()); // 5 = Ulteriore classificazione
row.get(); // 6 = Descrizione pagamento
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
}
}
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 e gli eventuali\n"
"pagamenti relativi nella partita %d %s?", anno, (const char*)numpart);
}
if (sposta)
{
oldgame->sposta_riga(rigafatt, *newgame, nuova_riga);
}
else
{
oldgame->scollega_pagamenti(rigafatt);
oldgame->rimuovi_riga(rigafatt);
}
oldgame->rewrite();
}
else
{
oldgame->sposta_riga(rigafatt, *newgame, nuova_riga);
}
}
}
if (newgame != NULL) // Se non ho cancellato il numero partita ...
{
newgame->write(); // Salva nuova partita
delete newgame;
}
}
///////////////////////////////////////////////////////////
// Gestione pagamenti
///////////////////////////////////////////////////////////
bool TPrimanota_application::showpartite_handler(TMask_field& f, KEY k)
{
bool ok = TRUE;
TMask& m = f.mask();
TPrimanota_application& a = app();
TMask& cm = a.curr_mask();
const char tipo = m.get(CG_ROWTYPE)[0];
const bool is_nota = tipo == 'T' && a.causale().tipomov() == 2 && cm.field(F_NUMRIF).active();
const bool tras = a._as400 && a.causale().tipomov() > 1 && m.get(CG_TIPO).not_empty();
if (tipo == 'K' || is_nota || tras)
{
TSheet_field& s = *m.get_sheet();
const int riga = s.selected();
if (k == K_SPACE)
{
const bool ok = a.edit_partite(m, riga);
if (ok && riga < s.items())
k = K_ENTER;
}
if (k == K_ENTER)
{
const long curreg = cm.get_long(F_NUMREG);
const TImporto importo(a.get_cgs_imp(riga));
const TImporto speso(a.partite().importo_speso(curreg, riga+1));
if (tipo == 'K' && !speso.is_zero())
{
a.disable_cgs_cells(riga, 'K');
a.cgs().force_update(riga);
}
if (importo != speso)
{
TString msg(128);
msg << "L'importo sul saldaconto della riga " << (riga+1) << " e' "
<< speso.valore().string(".");
if (!speso.is_zero())
msg << (speso.sezione() == 'A' ? " Avere" : " Dare");
return f.error_box(msg);
}
}
}
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
TSheet_field& sheet = cgs();
if (_as400)
deleting = -1; // Ignora contropartite
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))
sheet.destroy(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(RIGA_RITENUTE, conto_rit);
const TString desc(causale().desc_agg(RIGA_RITENUTE));
set_cgs_row(riga, grow_ritenute, conto_rit, desc, 'F');
}
else
{
const bool empty = add_cgs_imp(riga, grow_ritenute);
if (empty) sheet.destroy(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)
sheet.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' ? RIGA_ABBUONI_ATTIVI : RIGA_ABBUONI_PASSIVI;
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(RIGA_DIFFCAM, conto_diffcam);
const TString desc(causale().desc_agg(RIGA_DIFFCAM));
set_cgs_row(riga_diffcam, grow_diffcam, conto_diffcam, desc, 'C');
}
else
{
const bool empty = add_cgs_imp(riga_diffcam, grow_diffcam);
if (empty)
sheet.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;
// Al primo "giro" elimino i pagamenti dalla rate
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;
}
}
}
}
}
// Alla fine del "giro" elimino i pagamenti non assegnati
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;
}
}
// Al secondo "giro" decremento NRIGP dalle righe di pagamento
if (numrig > 0)
{
for (p = partita.last(); p > 0; p = partita.pred(p))
{
TRiga_partite& part = partita.riga(p);
if (!part.is_fattura())
{
if (part.get_long(PART_NREG) == nreg)
{
const int nr = part.get_int(PART_NUMRIG);
if (nr > numrig)
part.put(PART_NUMRIG, nr-1);
}
}
}
}
return found;
}
bool TPrimanota_application::notify_cgline_deletion(int numrig)
{
bool found = FALSE;
const long nreg = curr_mask().get_long(F_NUMREG);
partite().add_numreg(nreg);
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