d5c63d37e3
Files correlati : cg2.exe cg3.exe cg3600b.msk Ricompilazione Demo : [ ] Commento : CM20049 Registrazione di fattura: quando passo nella parte iva dell'operazione il cursore è sulla riga Iva ma il conto che mi fa vedere dove espone il saldo è quello del fornitore.Mi chiedevo se per le registrazioni iva il saldo viene dato solo ed esclusivamente cliccando sulle righe della parte contabile. Mi aiutate a capire ? CM20050 Causale senza tipo documento ma con tipo movimento fattura. Non controlla registrando il valore delle rate se diverso dal valore indicato in testata. Lo fa solo se richiamo in variazione la registrazione. CM20051 Dalla visualizzazione mastrino se clicco su nuovo mi lascia inserire un nuovo movimento, però quando do fine per ritornare alla visualizzazione del mastrino deve chiedermi se voglio o meno riaggioanre la visualizzazione. git-svn-id: svn://10.65.10.50/trunk@11526 c028cbd2-c16b-5b4b-a496-9718f37d4682
1402 lines
44 KiB
C++
Executable File
1402 lines
44 KiB
C++
Executable File
// --------------------------------------------------------------------------
|
|
// Scadenzario
|
|
// fv 24/8/94
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include <msksheet.h>
|
|
#include "cgpagame.h"
|
|
#include "cgsaldac.h"
|
|
|
|
#include "cg2102.h"
|
|
#include "cg2100.h"
|
|
#include "cg21sld.h"
|
|
|
|
#include <clifo.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)
|
|
{
|
|
TMask* msk = &(ps.mask());
|
|
|
|
// if (!msk->is_running()) return TRUE; // Necessario per evitare il CHECK sul pagamento nullo
|
|
if (!app().is_fattura() || app()._pag == NULL) return TRUE; // Necessario per evitare il CHECK sul pagamento nullo
|
|
|
|
TPagamento& pag = app().pagamento();
|
|
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& trs = ps.row(r);
|
|
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);
|
|
}
|
|
trs.add(news, 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);
|
|
trs.add(p.string(), 3);
|
|
}
|
|
}
|
|
if (m_impv)
|
|
{
|
|
trw.add(newv,4);
|
|
const real p = pag.recalc_percrata(r, TRUE);
|
|
trs.add(p.string(), 3);
|
|
}
|
|
if (mod)
|
|
{
|
|
rws.row(r) = trs;
|
|
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();
|
|
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 TString& codval = m.get(SK_VALUTA);
|
|
const bool in_valuta = pag.in_valuta();
|
|
real imp;
|
|
|
|
if (key == K_ENTER)
|
|
{
|
|
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)
|
|
{
|
|
TCurrency curr(imp, in_valuta ? (const char*)codval : "");
|
|
const TString is = curr.string(TRUE);
|
|
curr.set_num(tot);
|
|
const TString ts = curr.string(TRUE);
|
|
ok = yesno_box(FR("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)
|
|
{
|
|
TCurrency curr(imp);
|
|
const TString is = curr.string(TRUE);
|
|
curr.set_num(totlit);
|
|
const TString ts = curr.string(TRUE);
|
|
const TRectype & rec = cache().get("%VAL", TCurrency::get_firm_val());
|
|
const char * name = (const char *) rec.get("S0");
|
|
|
|
ok = yesno_box(FR("Il totale in %s delle rate e' %s mentre\n"
|
|
"il totale del documento e' %s.\n"
|
|
"Si desidera registrare ugualmente?"),
|
|
name, (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.empty())
|
|
{
|
|
ok = f.error_box(TR("Il codice di pagamento e' obbligatorio!"));
|
|
|
|
// Nella maschera iva cerco di reperirlo dal cliente
|
|
if (m.id2pos(F_CLIENTE) > 0)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 (f.empty() && !m.get(F_NUMRIF).blank())
|
|
{
|
|
const TString& anno = m.get(F_DATADOC).right(4);
|
|
f.set(anno);
|
|
ok = error_box(TR("L'anno di riferimento partita e' obbligatorio!"));
|
|
}
|
|
}
|
|
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();
|
|
const bool moviva = a.iva() != nessuna_iva; // Maschera IVA?
|
|
|
|
bool required = m.insert_mode() && a.is_fattura();
|
|
required &= key == K_ENTER || f.focusdirty();
|
|
if (moviva)
|
|
required &= !(m.get_bool(F_SOLAIVA) || m.field(F_OCCASEDIT).active());
|
|
|
|
if (required && f.get().blank())
|
|
{
|
|
if (moviva && m.field(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(TR("Il numero di riferimento partita e' obbligatorio!"));
|
|
}
|
|
|
|
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(FR("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() && val != TCurrency::get_firm_val();
|
|
|
|
if (full)
|
|
{
|
|
TEdit_field& dc = m.efield(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)
|
|
if (m.get(SK_CAMBIO).empty())
|
|
{
|
|
TCursor& cur = *dc.browse()->cursor();
|
|
if (cur.items() == 0) // Uso cambio standard
|
|
{
|
|
const TRectype& recval = cache().get("%VAL", val);
|
|
dc.set(recval.get("D0"));
|
|
m.enable(SK_CAMBIO); // Abilito per far funzionare la prossima riga
|
|
m.set(SK_CAMBIO, recval.get("S4"), TRUE);
|
|
}
|
|
}
|
|
|
|
if (m.id2pos(F_VALUTAINTRA) >= 0)
|
|
{
|
|
TEdit_field& vi = m.efield(F_VALUTAINTRA);
|
|
if (vi.active() && vi.empty())
|
|
{
|
|
m.set(F_VALUTAINTRA, val);
|
|
m.set(F_CAMBIOINTRA, m.get(SK_CAMBIO), TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m.set(SK_CAMBIO, "", TRUE);
|
|
m.set(SK_TOTDOCVAL, "", TRUE);
|
|
if (m.id2pos(SK_CONTROEURO) >= 0)
|
|
m.set(SK_CONTROEURO, "", 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
|
|
::handler_data_cambio(f, key);
|
|
}
|
|
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(TR("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(FR("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().set_banche(m);
|
|
app().pag_rows() = ps.rows_array();
|
|
}
|
|
TString8 r; r.format("%d", pag.n_rate());
|
|
f.set(r);
|
|
}
|
|
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)
|
|
{
|
|
TMask& m = app().curr_mask();
|
|
if (key == K_F8 || (key == K_TAB && f.get().empty() && m.is_running()))
|
|
{
|
|
const TPagamento& pag = app().pagamento();
|
|
if (pag.in_valuta())
|
|
{
|
|
const TValuta v(m, FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO, SK_CONTROEURO);
|
|
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, SK_CONTROEURO);
|
|
const real other(f.mask().get(102));
|
|
TString80 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.id2pos(F_IMPOSTE) >= 0 ? m.get_real(F_IMPOSTE) : ZERO;
|
|
const real imponibile = m.get_real(F_TOTALE) - imposta;
|
|
const real spese = ZERO;
|
|
|
|
const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO, SK_CONTROEURO);
|
|
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, cambio.codice());
|
|
}
|
|
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_banche(TMask& m)
|
|
{
|
|
// Aggiunge banche: CM000033
|
|
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
|
|
bool update = FALSE;
|
|
for (int i = ps.items()-1; i >= 0; i--)
|
|
{
|
|
TToken_string& row = ps.row(i);
|
|
if (row.get_char(7) <= ' ')
|
|
{
|
|
row.add(m.get(FS_NSABI), 7);
|
|
row.add(m.get(FS_NSCAB), 8);
|
|
update = TRUE;
|
|
}
|
|
if (row.get_char(9) <= ' ')
|
|
{
|
|
row.add(m.get(FS_VSABI), 9);
|
|
row.add(m.get(FS_VSCAB), 10);
|
|
update = TRUE;
|
|
}
|
|
}
|
|
if (update)
|
|
ps.force_update();
|
|
}
|
|
|
|
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);
|
|
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
|
|
set_banche(m);
|
|
_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())
|
|
{
|
|
const TCurrency totdoc_c(totale, m.get(SK_VALUTA));
|
|
const TCurrency totdoc_s(partita.importo(in_valuta).valore(), m.get(SK_VALUTA));
|
|
const TString i1 = totdoc_c.string(TRUE);
|
|
const TString i2 = totdoc_s.string(TRUE);
|
|
warning_box(FR("Il totale documento (%s) non corrisponde a quello del saldaconto (%s)."),
|
|
(const char*)i1, (const char*)i2);
|
|
}
|
|
if (iva() != nessuna_iva)
|
|
{
|
|
if (m.get_real(F_IMPOSTE) != partita.get_real(PART_IMPOSTA))
|
|
{
|
|
const TCurrency imposte_c(m.get_real(F_IMPOSTE));
|
|
const TCurrency imposte_s(partita.get_real(PART_IMPOSTA));
|
|
const TString i1 = imposte_c.string(TRUE);
|
|
const TString i2 = imposte_s.string(TRUE);
|
|
warning_box(FR("Il totale delle imposte (%s) non corrisponde a quello del saldaconto (%s)."),
|
|
(const char*)i1, (const char*)i2);
|
|
}
|
|
}
|
|
|
|
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
|
|
{
|
|
TString_array& a = cgs().rows_array();
|
|
if (iva() != nessuna_iva)
|
|
{
|
|
const char tipocf = clifo();
|
|
const long codcf = curr_mask().get_long(tipocf == 'C' ? F_CLIENTE : F_FORNITORE);
|
|
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);
|
|
}
|
|
else
|
|
{
|
|
for (int r = 0; r < a.items(); r++)
|
|
{
|
|
TToken_string& row = a.row(r);
|
|
bill.get(row, 2, 0x1);
|
|
if (bill.tipo() > ' ')
|
|
return r;
|
|
}
|
|
if (a.items() > 0)
|
|
{
|
|
TToken_string& row = a.row(0);
|
|
bill.get(row, 2, 0x1);
|
|
return 0;
|
|
}
|
|
else
|
|
bill.set(0, 0, 0, ' ');
|
|
}
|
|
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 TString8 codcaus = causale().codice();
|
|
const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO, SK_CONTROEURO);
|
|
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_SEZ, sezione);
|
|
if (iva() != nessuna_iva)
|
|
partita.put(PART_PROTIVA, m.get_long(F_PROTIVA));
|
|
|
|
const TImporto totdoc = get_cgs_imp(riga_clifo);
|
|
partita.put(PART_IMPTOTDOC, totdoc.valore());
|
|
|
|
cambio.put(partita);
|
|
const bool in_valuta = cambio.in_valuta();
|
|
|
|
if (in_valuta)
|
|
partita.put(PART_IMPTOTVAL, m.get(SK_TOTDOCVAL));
|
|
|
|
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_SPESE, pag.spese());
|
|
if (iva() != nessuna_iva)
|
|
partita.put(PART_IMPOSTA, m.get(F_IMPOSTE));
|
|
|
|
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(FR("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.insert_mode() ? NUMREG_PROVVISORIO : 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);
|
|
const TCurrency curr(speso.valore());
|
|
msg.format(FR("L'importo sul saldaconto della riga %d e' %s"), (riga+1), (const char*)curr.string(TRUE));
|
|
if (!speso.is_zero())
|
|
msg << (speso.sezione() == 'A' ? TR(" Avere") : TR(" Dare"));
|
|
return f.error_box(msg);
|
|
}
|
|
f.set_focus();
|
|
}
|
|
}
|
|
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();
|
|
TBill new_conto; new_conto.get(new_pag, TRUE);
|
|
|
|
if (_as400 || !new_conto.ok())
|
|
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));
|
|
|
|
if (old_importo != new_importo || old_conto != new_conto)
|
|
{
|
|
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);
|
|
}
|
|
else
|
|
if (!old_importo.is_zero())
|
|
{
|
|
TImporto imp = old_importo; imp.swap_section();
|
|
set_cgs_row(old_riga, imp, old_conto, "", 'I');
|
|
}
|
|
|
|
|
|
|
|
// Importo della contropartita
|
|
if (!new_importo.is_zero() && new_conto.ok())
|
|
{
|
|
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));
|
|
new_riga = set_cgs_row(new_riga, new_importo, new_conto, descagg, 'I');
|
|
|
|
TToken_string& cli_row = sheet.row(riga_contabile-1);
|
|
TBill contro; contro.get(cli_row, 9, 0x3);
|
|
if (!contro.ok()) // Completa controparita della riga cliente se necessario
|
|
new_conto.add_to(cli_row, 9, 0x3);
|
|
TString80 descr = cli_row.get(CG_DESCR-FIRST_FIELD);
|
|
if (descr.blank()) // Compila descrizione della riga cliente se necessario
|
|
{
|
|
descr = somma.get(PART_DESCR);
|
|
cli_row.add(descr, CG_DESCR-FIRST_FIELD);
|
|
}
|
|
|
|
// Compila contropartita della nuova riga
|
|
TBill clifo; clifo.get(cli_row, 2, 0x3);
|
|
TToken_string& new_row = sheet.row(new_riga);
|
|
clifo.add_to(new_row, 9, 0x3);
|
|
}
|
|
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 TMask& m = curr_mask();
|
|
const long nreg = m.insert_mode() ? NUMREG_PROVVISORIO : m.get_long(F_NUMREG);
|
|
|
|
// if (curr_mask().edit_mode())
|
|
// partite().add_numreg(nreg); // Gia' fatto dalla read
|
|
|
|
for (TPartita* game = partite().first(); game; game = partite().next())
|
|
found |= notify_cgline_deletion(*game, nreg, numrig);
|
|
|
|
return found;
|
|
} |