896 lines
27 KiB
C++
Executable File
896 lines
27 KiB
C++
Executable File
// --------------------------------------------------------------------------
|
|
// Scadenzario
|
|
// fv 24/8/94
|
|
// --------------------------------------------------------------------------
|
|
|
|
#include <sheet.h>
|
|
|
|
#include "cg2102.h"
|
|
#include "cg2100.h"
|
|
#include "cg21sld.h"
|
|
#include "pagament.h"
|
|
|
|
#include <clifo.h>
|
|
#include <partite.h>
|
|
#include <scadenze.h>
|
|
|
|
bool TPrimanota_application::pag_notify(int r, KEY k)
|
|
{
|
|
TPagamento& pag = app().pagamento();
|
|
TSheet_field& ps = app().pags();
|
|
TMask* msk = &(app().curr_mask());
|
|
TString_array& rws = app().pag_rows();
|
|
|
|
int rdiff = atoi(msk->get(FS_RDIFFER));
|
|
|
|
// ts contiene la vecchia riga, ns la nuova
|
|
TToken_string ts(36), ns(36);
|
|
|
|
bool doit = TRUE, m_imp = FALSE, m_perc = FALSE, m_pag = FALSE;
|
|
bool m_scad = FALSE, m_tipo = FALSE, mod = FALSE;
|
|
word ahiahi = P_OK;
|
|
|
|
TString news(15), newi(15), newp(15), newt(2);
|
|
|
|
bool recalc = msk->get_bool(FS_RECALC);
|
|
bool mcomm = msk->get_bool(FS_MCOMM);
|
|
|
|
switch (k)
|
|
{
|
|
case K_SPACE:
|
|
break;
|
|
case K_ENTER:
|
|
ns = ps.row(r);
|
|
ts = rws.row(r);
|
|
|
|
news = ns.get(0);
|
|
newp = ns.get(1);
|
|
newi = ns.get(2);
|
|
newt = ns.get(3);
|
|
|
|
// qui viene il bello, si fa per dire
|
|
if (news != ts.get(0)) // modificata data scadenza
|
|
{
|
|
mod = m_scad = TRUE;
|
|
}
|
|
if (newp != ts.get(1)) // modificata percentuale
|
|
{
|
|
mod = m_perc = TRUE;
|
|
}
|
|
if (newi != ts.get(2)) // 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(3)) // modificato tipo pagamento
|
|
{
|
|
mod = m_tipo = TRUE;
|
|
}
|
|
break;
|
|
case K_DEL:
|
|
case K_INS:
|
|
doit = FALSE;
|
|
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),
|
|
rdiff, mcomm, need_recalc);
|
|
// see if rdiff changed
|
|
msk->field(FS_RDIFFER).set(pag.rate_differenziate() ? "1" : "2");
|
|
}
|
|
if (!recalc)
|
|
{
|
|
ahiahi = P_OK;
|
|
// put data as they are
|
|
TToken_string& trw = pag.rata(r);
|
|
TToken_string srw = trw;
|
|
if (m_scad) trw.add(news,3);
|
|
if (m_perc) trw.add(newp,1);
|
|
if (m_imp) trw.add(newi,4);
|
|
if (m_tipo) trw.add(newt,2);
|
|
// validate the payment
|
|
if ((ahiahi = pag.validate()) != P_OK)
|
|
pag.rata(r) = srw;
|
|
}
|
|
if (ahiahi) // any error? Rimetti le righe com'erano prima
|
|
{
|
|
beep();
|
|
|
|
// se gli errori sono voluti, spiegali
|
|
if (!recalc)
|
|
{
|
|
TString256 s;
|
|
pag.strerr(ahiahi,s);
|
|
warning_box(s);
|
|
}
|
|
|
|
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);
|
|
ps.force_update();
|
|
rws = ps.rows_array();
|
|
}
|
|
}
|
|
|
|
return doit;
|
|
}
|
|
|
|
bool TPrimanota_application::codpag_handler(TMask_field& f, KEY key)
|
|
{
|
|
TMask& m = f.mask();
|
|
|
|
if (key == K_TAB && (f.focusdirty() || !m.is_running()) && app().is_saldaconto())
|
|
{
|
|
const TString16 dt(m.get(F_DATAREG));
|
|
app().set_pagamento(f.get(), dt);
|
|
app().set_scadenze(m);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void TPrimanota_application::set_pagamento(const char* c, const char* d)
|
|
{
|
|
if (_pag != NULL) delete _pag;
|
|
_pag = new TPagamento(c,d);
|
|
}
|
|
|
|
void TPrimanota_application::set_scadenze(TMask& m)
|
|
{
|
|
real imponibile(0.0);
|
|
real imposta(0.0);
|
|
real spese(0.0);
|
|
|
|
TPagamento& pag = pagamento();
|
|
|
|
if (pag.is_new())
|
|
{
|
|
m.disable_page(2);
|
|
return;
|
|
}
|
|
else m.enable_page(2);
|
|
|
|
m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
|
|
m.set(FS_NAMEPAG, pag.name());
|
|
m.set(FS_TIPOPR, pag.desc_tpr());
|
|
m.set(FS_MCOMM, pag.mese_commerciale() ? "X" : "");
|
|
|
|
TSheet_field& iva_sh = ivas();
|
|
|
|
for (int i = 0; i < iva_sh.items(); i++)
|
|
{
|
|
TToken_string& tt = iva_sh.row(i);
|
|
const real mpo(tt.get(0));
|
|
imponibile += mpo;
|
|
const real imp(tt.get(3));
|
|
imposta += imp;
|
|
}
|
|
|
|
m.set(FS_IMPONIBILE, imponibile.string());
|
|
m.set(FS_IMPOSTA, imposta.string());
|
|
m.set(FS_SPESE, spese.string());
|
|
m.set(FS_RECALC, "X");
|
|
|
|
pag.set_total(imponibile, imposta, spese);
|
|
pag.set_rate_auto();
|
|
bool new_part = TRUE;
|
|
|
|
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
|
|
|
|
// prepara lo sheet
|
|
pag.set_sheet(ps);
|
|
_pag_rows = ps.rows_array();
|
|
|
|
// se la prima rata e' fissa non si tocca
|
|
if (pag.tipo_prima_rata() > 0)
|
|
{
|
|
ps.disable_cell(0,0);
|
|
ps.disable_cell(0,1);
|
|
ps.disable_cell(0,2);
|
|
ps.disable_cell(0,3);
|
|
}
|
|
}
|
|
|
|
bool TPrimanota_application::read_scadenze(const TMask& m)
|
|
{
|
|
real imponibile(0.0);
|
|
real imposta(0.0);
|
|
real spese(0.0);
|
|
|
|
TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
|
|
|
|
// should never happen but it doesn't hurt
|
|
if (_rel->cg(0).empty()) return FALSE;
|
|
|
|
TSheet_field& iva_sh = ivas();
|
|
|
|
for (int i = 0; i < iva_sh.items(); i++)
|
|
{
|
|
TToken_string& tt = iva_sh.row(i);
|
|
real mpo(tt.get(0));
|
|
real imp(tt.get(3));
|
|
imponibile += mpo;
|
|
imposta += imp;
|
|
}
|
|
|
|
m.field(FS_IMPONIBILE).set(imponibile.string());
|
|
m.field(FS_IMPOSTA).set(imposta.string());
|
|
m.field(FS_SPESE).set(spese.string());
|
|
m.field(FS_RECALC).set("X");
|
|
|
|
TPagamento& pag = pagamento();
|
|
pag.set_total(imponibile, imposta, spese);
|
|
|
|
TLocalisamfile partita (LF_PARTITE);
|
|
TLocalisamfile scadenza(LF_SCADENZE);
|
|
|
|
TString nreg(_rel->lfile().get("NUMREG"));
|
|
TString ndoc(_rel->lfile().get("NUMDOC"));
|
|
TString tmov(_rel->lfile().get("TIPOMOV"));
|
|
TDate ddoc(_rel->lfile().get_date("DATADOC"));
|
|
TDate dreg(_rel->lfile().get_date("DATAREG"));
|
|
TString reg (_rel->lfile().get("REG"));
|
|
TString protiva(_rel->lfile().get("PROTIVA"));
|
|
TString codcaus(_rel->lfile().get("CODCAUS"));
|
|
TString codval (_rel->lfile().get("CODVAL"));
|
|
TString cambio (_rel->lfile().get("CAMBIO"));
|
|
|
|
TString numpart = m.get(F_NUMRIF);
|
|
TString anno = m.get(F_ANNORIF);
|
|
|
|
char sezione = _rel->cg(0).get_char("SEZIONE"); // Dare/Avere
|
|
char tipocf = _rel->cg(0).get_char("TIPOC"); // Cliente || Fornitore || Uncazzo
|
|
int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("GRUPPO");
|
|
int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("CONTO");
|
|
long sottoconto = _rel->cg(0).get_long("SOTTOCONTO");
|
|
int nriga = 1;
|
|
int numrig = 1;
|
|
|
|
partita.put(PART_ANNO, anno);
|
|
partita.put(PART_NUMPART, numpart);
|
|
partita.put(PART_NRIGA, nriga);
|
|
|
|
bool fromscratch = FALSE;
|
|
|
|
if (partita.read() == NOERR)
|
|
{
|
|
// se si e' specificato un codice pagamento diverso si rifa' da capo
|
|
if (pag.code() != partita.get("CODPAG"))
|
|
fromscratch = TRUE;
|
|
// se invece la maschera contiene importi diversi da quelli
|
|
// registrati si passa la palla al culano
|
|
else if (imponibile != partita.get_real(PART_IMPORTO) ||
|
|
imposta != partita.get_real(PART_IMPOSTA) ||
|
|
spese != partita.get_real(PART_SPESE))
|
|
{
|
|
fromscratch = !yesno_box("Gli importi totali delle scadenze sono stati modificati rispetto"
|
|
" all'ultima registrazione. Si desidera mantenere"
|
|
" comunque la rateazione precedente");
|
|
// nel caso, of course, si disabilitano gli automatismi
|
|
if(!fromscratch) m.field(FS_RECALC).set("");
|
|
}
|
|
if (fromscratch)
|
|
pag.set_rate_auto();
|
|
else
|
|
{
|
|
pag.zap_rate();
|
|
|
|
for (int i = 0; ; i++)
|
|
{
|
|
// cerca rata
|
|
scadenza.zero();
|
|
scadenza.put(PART_ANNO, anno);
|
|
scadenza.put(PART_NUMPART, numpart);
|
|
scadenza.put(PART_NRATA, i+1);
|
|
|
|
if (scadenza.read() == NOERR)
|
|
{
|
|
const 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);
|
|
pag.set_rata(i, importo, scad, tipop, ulc, paid);
|
|
}
|
|
else break;
|
|
} // for
|
|
} //else
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
pag.set_sheet(ps);
|
|
_pag_rows = ps.rows_array();
|
|
|
|
// se la prima rata e' fissa non si tocca
|
|
if (pag.tipo_prima_rata() > 0)
|
|
ps.disable_cell(0,-1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void TPrimanota_application::write_scadenze(const TMask& m)
|
|
{
|
|
real imponibile(0.0);
|
|
real imposta(0.0);
|
|
real spese(0.0);
|
|
|
|
// should never happen but it doesn't hurt
|
|
CHECK(!_rel->cg(0).empty(), "Missing first line");
|
|
|
|
TLocalisamfile partita (LF_PARTITE);
|
|
TLocalisamfile scadenza(LF_SCADENZE);
|
|
|
|
TRectype& r = _rel->lfile().curr();
|
|
|
|
const long nreg = r.get_long("NUMREG");
|
|
const TString16 ndoc(r.get("NUMDOC"));
|
|
const int tmov = r.get_int("TIPOMOV");
|
|
const TDate ddoc(r.get_date("DATADOC"));
|
|
const TDate dreg(r.get_date("DATAREG"));
|
|
const TString16 reg (r.get("REG"));
|
|
const TString80 desc(r.get("DESCR"));
|
|
const int protiva = r.get_int("PROTIVA");
|
|
const TString16 codcaus(r.get("CODCAUS"));
|
|
const TString16 codval (r.get("CODVAL"));
|
|
const real cambio (r.get("CAMBIO"));
|
|
|
|
const TString16 numpart = m.get(F_NUMRIF);
|
|
const int anno = m.get_int(F_ANNORIF);
|
|
|
|
char sezione = _rel->cg(0).get_char("SEZIONE"); // Dare/Avere
|
|
char tipocf = _rel->cg(0).get_char("TIPOC"); // Cliente || Fornitore || Uncazzo
|
|
int gruppo = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("GRUPPO");
|
|
int conto = (tipocf == 'C' || tipocf == 'F') ? 0 : _rel->cg(0).get_char("CONTO");
|
|
long sottoconto = _rel->cg(0).get_long("SOTTOCONTO");
|
|
int nriga = 1;
|
|
int numrig = 1;
|
|
|
|
partita.put("ANNO", anno);
|
|
partita.put("NUMPART", numpart);
|
|
partita.put("NRIGA", nriga);
|
|
|
|
bool fromscratch = FALSE, new_part = TRUE;
|
|
|
|
TPagamento& pag = pagamento();
|
|
|
|
if (partita.read() == NOERR)
|
|
{
|
|
// se si e' specificato un codice pagamento diverso si rifa' da capo
|
|
if (pag.code() != partita.get("CODPAG"))
|
|
fromscratch = TRUE;
|
|
new_part = FALSE;
|
|
}
|
|
|
|
// riaggiusta partite e scadenze
|
|
if (new_part)
|
|
{
|
|
partita.zero();
|
|
partita.put("TIPOCF", tipocf);
|
|
partita.put("GRUPPO", gruppo);
|
|
partita.put("CONTO", conto);
|
|
partita.put("SOTTOCONTO", sottoconto);
|
|
partita.put("ANNO", anno);
|
|
partita.put("NUMPART", numpart);
|
|
partita.put("NRIGA", nriga);
|
|
}
|
|
|
|
// put data on partita
|
|
partita.put("TIPOMOV",tmov);
|
|
partita.put("NREG", nreg);
|
|
partita.put("DATAREG",dreg);
|
|
partita.put("DATADOC",ddoc);
|
|
partita.put("NUMDOC", ndoc);
|
|
partita.put("REG", reg);
|
|
partita.put("DESCR", desc);
|
|
partita.put("PROTIVA",protiva);
|
|
partita.put("CODCAUS",codcaus);
|
|
partita.put("SEZ", sezione);
|
|
partita.put("CODPAG", pag.code());
|
|
partita.put("CODVAL", codval);
|
|
partita.put("CAMBIO", cambio);
|
|
partita.put("IMPORTO",pag.imponibile());
|
|
partita.put("IMPOSTA",pag.imposta());
|
|
partita.put("SPESE", pag.spese());
|
|
partita.put("NUMRIG", numrig);
|
|
|
|
if (new_part) partita.write();
|
|
else partita.rewrite();
|
|
|
|
bool new_scad = FALSE;
|
|
|
|
for (int i = 0; i < pag.n_rate(); i++)
|
|
{
|
|
new_scad = FALSE;
|
|
scadenza.zero();
|
|
scadenza.put("ANNO", anno);
|
|
scadenza.put("NUMPART", numpart);
|
|
scadenza.put("NRATA", i+1);
|
|
|
|
if (scadenza.read() != NOERR)
|
|
{
|
|
new_scad = TRUE;
|
|
scadenza.zero();
|
|
scadenza.put("TIPOCF", tipocf);
|
|
scadenza.put("GRUPPO", gruppo);
|
|
scadenza.put("CONTO", conto);
|
|
scadenza.put("SOTTOCONTO", sottoconto);
|
|
scadenza.put("ANNO", anno);
|
|
scadenza.put("NUMPART", numpart);
|
|
scadenza.put("NRATA", i+1);
|
|
}
|
|
// set everything
|
|
scadenza.put("CODPAG", pag.code());
|
|
scadenza.put("TIPOPAG", pag.tipo_rata(i));
|
|
scadenza.put("ULTCLASS", pag.ulc_rata(i));
|
|
scadenza.put("IMPORTO", pag.tpay_rata(i));
|
|
scadenza.put("DATASCAD", pag.data_rata(i));
|
|
scadenza.put("PAGATA", pag.ratapagata(i));
|
|
|
|
if (new_scad) scadenza.write();
|
|
else scadenza.rewrite();
|
|
}
|
|
|
|
// elimina eventuali altre scadenze oltre l'ultima registrata
|
|
for (; !new_scad ; i++)
|
|
{
|
|
scadenza.zero();
|
|
scadenza.put("ANNO", anno);
|
|
scadenza.put("NUMPART", numpart);
|
|
scadenza.put("NRATA", i+1);
|
|
|
|
if (scadenza.read() == NOERR)
|
|
scadenza.remove();
|
|
else new_scad = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Sheet partite
|
|
///////////////////////////////////////////////////////////
|
|
|
|
HIDDEN int _riga;
|
|
HIDDEN TImporto _soldi, _max;
|
|
|
|
bool TPrimanota_application::edit_partite(int riga)
|
|
{
|
|
begin_wait();
|
|
|
|
const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione
|
|
|
|
TToken_string& cgr = cgs().row(riga);
|
|
const TBill b(cgr, 2, 0x3); // Legge il conto della riga selezionata
|
|
|
|
_riga = riga; // Riga correntemente in gestione
|
|
_soldi = cgr; // Importo della riga selezionata
|
|
|
|
TString80 caption("Partite aperte del conto ");
|
|
caption << b.gruppo() << ' ' << b.conto() << ' ' << b.sottoconto();
|
|
|
|
TArray_sheet a(-1, -1, 0, 0, caption, "Anno|Numero@7|Descrizione@50|Importo@15R|Sezione", 0x8);
|
|
|
|
TLocalisamfile partita(LF_PARTITE);
|
|
partita.setkey(2); // Chiave per conto
|
|
|
|
partita.zero();
|
|
if (b.tipo() != ' ') // Ignora gruppo e conto dei clifo
|
|
{
|
|
partita.put(PART_TIPOCF, b.tipo());
|
|
partita.put(PART_SOTTOCONTO, b.sottoconto());
|
|
}
|
|
else b.put(partita.curr()); // Scrive completamente i conti normali
|
|
|
|
const TRectype recpar(partita.curr());// Record campione
|
|
|
|
int ult, anno; // Anno ultima partita
|
|
TString16 last, num; // Ultimo numero partita e numero corrente
|
|
long nreg;
|
|
TString desc; // Descrizione prima partita del gruppo
|
|
TImporto saldo; // Saldo ultima parita
|
|
TToken_string r(80);
|
|
|
|
for (int err = partita.read(_isgteq); err == NOERR && partita.curr() == recpar; err = partita.next())
|
|
{
|
|
num = partita.get(PART_NUMPART);
|
|
anno = partita.get_int(PART_ANNO);
|
|
nreg = partita.get_long(PART_NREG);
|
|
|
|
if (num == last && anno == ult) // Se la partita e' la stessa ...
|
|
{
|
|
const TImporto i(partita.get_char(PART_SEZ), partita.get_real(PART_IMPORTO));
|
|
saldo += i; // ... incrementa totale
|
|
|
|
if (nreg == curreg)
|
|
{
|
|
const int numrig = partita.get_int(PART_NUMRIG);
|
|
if (numrig == (riga+1))
|
|
_soldi -= i;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!saldo.is_zero() || nreg == curreg) // Se il saldo non e' nullo allora e' aperta
|
|
{
|
|
r.cut(0);
|
|
r.add(ult); r.add(last); r.add(desc);
|
|
r.add(saldo.valore().string(".")); r.add(saldo.sezione());
|
|
a.add(r); // Aggiunge partita alla lista
|
|
}
|
|
ult = anno;
|
|
last = num;
|
|
desc = partita.get(PART_DESCR);
|
|
saldo.set(partita.get_char(PART_SEZ), partita.get_real(PART_IMPORTO));
|
|
}
|
|
}
|
|
|
|
if (!saldo.is_zero() || nreg == curreg) // Aggiunge ultima partita se aperta
|
|
{
|
|
r.cut(0);
|
|
r.add(ult); r.add(last); r.add(desc);
|
|
r.add(saldo.valore().string(".")); r.add(saldo.sezione());
|
|
a.add(r);
|
|
}
|
|
|
|
end_wait();
|
|
|
|
KEY k = a.items() > 0 ? K_ENTER : K_ESC; // Esce se non ci sono righe
|
|
while (k == K_ENTER)
|
|
{
|
|
k = a.run();
|
|
if (k == K_ENTER)
|
|
{
|
|
const int anno = a.row().get_int(0);
|
|
const TString16 num = a.row().get(1);
|
|
edit_scadenze(anno, num); // Edita pagamenti
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
int TPrimanota_application::nuovo_pagamento(TPartita& partita, int rata, int rmov, TRectype& part)
|
|
{
|
|
CHECKD(rata >= 1 && rata <= partita.rate(), "Rata errata ", rata);
|
|
CHECKD(!partita.rata_pagata(rata), "Rata pagata ", rata);
|
|
|
|
const int nriga = partita.righe();
|
|
CHECKD(nriga > 0, "Riga partita errata ", nriga);
|
|
|
|
part = partita.riga(nriga);
|
|
|
|
// PART_ANNO viene preso dalla partita base
|
|
// PART_NUMPART viene preso dalla partita base
|
|
part.put(PART_NRIGA, nriga+1); // Riga di partita
|
|
|
|
part.put(PART_TIPOMOV, causale().tipomov()); // Dati causale corrente
|
|
part.put(PART_CODCAUS, causale().codice());
|
|
|
|
part.put(PART_NREG, curr_mask().get(F_NUMREG)); // Numero operazione
|
|
part.put(PART_NUMRIG, rmov+1); // Riga su cui ho cliccato
|
|
|
|
// Copia dati movimento corrente
|
|
part.put(PART_DATAREG, curr_mask().get(F_DATAREG));
|
|
part.put(PART_DATADOC, curr_mask().get(F_DATADOC));
|
|
part.put(PART_NUMDOC, curr_mask().get(F_NUMDOC));
|
|
part.put(PART_DESCR, curr_mask().get(F_DESCR));
|
|
|
|
part.zero(PART_REG);
|
|
part.zero(PART_PROTIVA);
|
|
|
|
part.put(PART_SEZ, (partita.totale().sezione() == 'D') ? 'A' : 'D');
|
|
part.zero(PART_IMPORTO); // Azzera importi vari
|
|
part.zero(PART_IMPOSTA);
|
|
part.zero(PART_SPESE);
|
|
|
|
TString80 tmp;
|
|
|
|
part.zero(PART_CODVAL);
|
|
part.zero(PART_CAMBIO);
|
|
part.zero(PART_IMPORTOVAL);
|
|
part.zero(PART_DATACAM);
|
|
|
|
const TRectype& scadenza = partita.rata(rata);
|
|
tmp = scadenza.get(SCAD_CODPAG);
|
|
part.put(PART_CODPAG, tmp);
|
|
|
|
tmp = scadenza.get(SCAD_TIPOPAG);
|
|
part.put(PART_TIPOPAG, tmp);
|
|
|
|
int caus = 2; // Calcola riga causale per la contropartita in base al tipo pagamento
|
|
switch (atoi(tmp))
|
|
{
|
|
case 2: // Tratta
|
|
case 7: // Tratta accettata
|
|
caus = 3; break;
|
|
case 3: // Ricevuta bancaria
|
|
caus = 4; break;
|
|
case 4: // Cessione
|
|
caus = 5; break;
|
|
case 5: // Paghero'
|
|
caus = 6; break;
|
|
case 6: // Fattura di credito
|
|
caus = 7; break;
|
|
case 1: // Rimessa
|
|
case 8: // Rapporti interbancari diretti
|
|
case 9: // Bonifico
|
|
default:
|
|
caus = 2; break;
|
|
}
|
|
|
|
TBill bill; causale().bill(caus, bill);
|
|
if (bill.empty()) causale().bill(caus = 1, bill);
|
|
bill.put(part);
|
|
|
|
TBill b; b.get(partita.riga(1));
|
|
if (b.tipo() > ' ') // Se cliente o fornitore cerca sua banca
|
|
{
|
|
TRelation cliforel(LF_CLIFO);
|
|
cliforel.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
|
|
TRectype& clifo = cliforel.lfile().curr();
|
|
|
|
clifo.put(CLI_TIPOCF, b.tipo());
|
|
clifo.put(CLI_CODCF, b.codclifo());
|
|
const int err = cliforel.read();
|
|
CHECK(err == NOERR, "Chiss'e' fregato il clifo");
|
|
|
|
tmp = clifo.get(CLI_CODABI);
|
|
part.put(PART_CODABI, tmp);
|
|
tmp = clifo.get(CLI_CODCAB);
|
|
part.put(PART_CODCAB, tmp);
|
|
tmp = cliforel.lfile(LF_CFVEN).get(CLI_CODAG);
|
|
part.put(PART_CODAG, tmp);
|
|
}
|
|
else
|
|
{
|
|
part.zero(PART_CODABI);
|
|
part.zero(PART_CODCAB);
|
|
part.zero(PART_CODAG);
|
|
}
|
|
|
|
part.zero(PART_IMPTOTPAG);
|
|
part.zero(PART_SALACC);
|
|
part.zero(PART_RITENUTE);
|
|
|
|
part.zero(PART_DATARIFPAG);
|
|
part.zero(PART_NUMRIFPAG);
|
|
part.zero(PART_CHIUSA);
|
|
|
|
tmp = scadenza.get(SCAD_NRATA);
|
|
part.put(PART_NRATA, tmp);
|
|
|
|
tmp = scadenza.get(SCAD_CODABIPR);
|
|
part.put(PART_CODABIPR, tmp);
|
|
|
|
tmp = scadenza.get(SCAD_CODCABPR);
|
|
part.put(PART_CODCABPR, tmp);
|
|
|
|
return nriga+1;
|
|
}
|
|
|
|
|
|
// Edit scadenze relative all'anno/numero partita specificati
|
|
bool TPrimanota_application::edit_scadenze(int anno, const char* num)
|
|
{
|
|
TString caption; caption.format("Pagamenti della partita %s dell'anno %d", num, anno);
|
|
TArray_sheet a(-1, -1, 0, 0, caption, "Rata|Data@10|Importo@15|Descrizione@50|Riga", 0x8);
|
|
|
|
TPartita* game = _partite.partita(anno, num);
|
|
if (game == NULL)
|
|
{
|
|
game = new TPartita(anno, num);
|
|
_partite.add(game);
|
|
}
|
|
TPartita& partita = *game;
|
|
|
|
const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione corrente
|
|
|
|
TToken_string r(80); // Work string
|
|
|
|
KEY k = K_ENTER;
|
|
bool dirty = TRUE;
|
|
|
|
while (k == K_ENTER)
|
|
{
|
|
if (dirty)
|
|
{
|
|
const TString desc(partita.descrizione());
|
|
|
|
a.destroy();
|
|
long nr;
|
|
|
|
for (int s = 1; s <= partita.rate(); s++)
|
|
{
|
|
const TRectype& rata = partita.rata(s);
|
|
r.cut(0);
|
|
r.add(rata.get(SCAD_NRATA));
|
|
r.add(rata.get(SCAD_DATASCAD));
|
|
r.add(rata.get(SCAD_IMPORTO));
|
|
r.add(desc);
|
|
r.add("S");
|
|
nr = a.add(r);
|
|
if (partita.rata_pagata(s))
|
|
a.disable(nr);
|
|
|
|
for (int p = 1; p <= partita.righe(); p++)
|
|
{
|
|
const TRectype& paga = partita.riga(p);
|
|
if (paga.get_int(PART_NRATA) == s)
|
|
{
|
|
r.cut(0);
|
|
r.add(s);
|
|
r.add(paga.get(PART_DATAREG));
|
|
r.add(paga.get(PART_IMPORTO));
|
|
r.add(paga.get(PART_DESCR));
|
|
r.add(paga.get(PART_NRIGA));
|
|
nr = a.add(r);
|
|
if (paga.get_long(PART_NREG) != curreg || paga.get_int(PART_NUMRIG) != _riga+1)
|
|
a.disable(nr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
k = a.run();
|
|
if (k == K_ENTER)
|
|
{
|
|
const int rata = a.row().get_int(0);
|
|
int nrig = a.row().get_int(4); // Numero riga pagamento corrente
|
|
|
|
TRectype part(LF_PARTITE);
|
|
|
|
if (nrig == 0) // Se ho cliccato su una scadenza ...
|
|
nrig = nuovo_pagamento(partita, rata, _riga, part);
|
|
else
|
|
part = partita.riga(nrig);
|
|
|
|
dirty = edit_pagamento(partita, part);
|
|
} // if k == K_ENTER
|
|
} // while k == K_ENTER
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
static bool importopag_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (f.to_check(k))
|
|
{
|
|
TMask& m = f.mask();
|
|
const real r(m.get(S_RESIDUO));
|
|
real i(f.get());
|
|
|
|
if (i > r)
|
|
{
|
|
warning_box("Non e' possibile inserire un importo superiore al residuo");
|
|
i = r;
|
|
f.set(i.string());
|
|
}
|
|
if (i > _max.valore())
|
|
{
|
|
const TFixed_string val(_max.valore().string("."));
|
|
warning_box("La riga contabile ha un residuo di %s", (const char*)val);
|
|
f.set(val);
|
|
}
|
|
if (i == r)
|
|
{
|
|
m.set(S_SALDOACC, "X");
|
|
m.disable(S_SALDOACC);
|
|
}
|
|
else
|
|
m.enable(S_SALDOACC);
|
|
}
|
|
else
|
|
if (k == K_F8)
|
|
{
|
|
const TString& val = f.mask().get(S_RESIDUO);
|
|
f.set(val);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool TPrimanota_application::edit_pagamento(TPartita& p, TRectype& part)
|
|
{
|
|
TMask m("cg2100s");
|
|
m.set_handler(S_IMPORTOPAG, importopag_handler);
|
|
|
|
TRelation rel(LF_PARTITE); // Working relation
|
|
TLocalisamfile& partita = rel.lfile();
|
|
partita.curr() = part;
|
|
m.autoload(&rel); // Load current record on mask
|
|
|
|
const TRectype& parbas = p.riga(1);
|
|
const int rata = part.get_int(PART_NRATA);
|
|
const TRectype& scaden = p.rata(rata);
|
|
|
|
const real dapagare(scaden.get(SCAD_IMPORTO));
|
|
const real pagato(scaden.get(SCAD_IMPORTOPAG));
|
|
const real residuo = dapagare - pagato;
|
|
|
|
// Dati del documento (fattura) che ha generato la scadenza
|
|
m.set(S_NUMDOC, parbas.get(PART_NUMDOC)); // Numero documento
|
|
m.set(S_DATADOC, parbas.get(PART_DATADOC)); // Data documento
|
|
m.set(S_NUMPROT, parbas.get(PART_PROTIVA)); // Protocollo IVA
|
|
m.set(S_DESCR, parbas.get(PART_DESCR)); // Descrizione documento
|
|
|
|
// Dati della scadenza che ha generato la partita
|
|
m.set(S_RESIDUO, residuo.string()); // Residuo da pagare
|
|
m.set(S_DATASCAD, scaden.get(SCAD_DATASCAD)); // Data della scadenza
|
|
m.set(S_IMPORTO, dapagare.string()); // Importo della rata
|
|
m.set(S_IMPORTOVAL, scaden.get(SCAD_IMPORTOVAL)); // " in valuta
|
|
m.set(S_RATA, scaden.get(SCAD_NRATA));
|
|
|
|
// Memorizza importi prima di eventuali variazioni
|
|
const real importo(part.get(PART_IMPORTO));
|
|
const real ritenute(part.get(PART_RITENUTE));
|
|
|
|
_max.set(_soldi.sezione(), _soldi.valore() + importo); // Importo massimo del campo S_IMPORTOPAG
|
|
|
|
const KEY key = m.run();
|
|
if (key == K_ENTER)
|
|
{
|
|
m.autosave(&rel);
|
|
part = partita.curr();
|
|
|
|
const char sez = _soldi.sezione() == 'D' ? 'A' : 'D';
|
|
|
|
const real imp(m.get(S_IMPORTOPAG));
|
|
const TImporto impg(sez, imp-importo);
|
|
|
|
if (!impg.is_zero())
|
|
{
|
|
_soldi += impg; // Sottrai soldi spesi qui
|
|
TBill conto(m.get_int(S_GRUPPO), m.get_int(S_CONTO), m.get_long(S_SOTTOCONTO));
|
|
const int riga = bill2pos(conto, 'I');
|
|
if (riga < 0)
|
|
set_cgs_row(riga, impg, conto, m.get(S_DESCAGG), 'I');
|
|
else
|
|
add_cgs_imp(riga, impg);
|
|
}
|
|
|
|
const real rit(m.get(S_RITENUTE));
|
|
const TImporto ritg(sez, rit-ritenute);
|
|
|
|
if (!ritg.is_zero())
|
|
{
|
|
const riga = type2pos('F');
|
|
if (riga < 0)
|
|
{
|
|
TBill conto_rit; causale().bill(11, conto_rit);
|
|
set_cgs_row(riga, ritg, conto_rit, "", 'F');
|
|
}
|
|
else add_cgs_imp(riga, ritg);
|
|
}
|
|
p.add_riga(part);
|
|
}
|
|
|
|
return key == K_ENTER;
|
|
}
|