root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg2104.cpp
guy d0483278e1 Gestione prima nota con TRecord_array 
Corretta contropartita fantasma della prima riga


git-svn-id: svn://10.65.10.50/trunk@1281 c028cbd2-c16b-5b4b-a496-9718f37d4682
1995-04-20 14:29:00 +00:00

944 lines
29 KiB
C++
Executable File
Raw Blame History

// --------------------------------------------------------------------------
// 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(PART_ANNO, anno);
partita.put(PART_NUMPART, numpart);
partita.put(PART_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(PART_CODPAG))
fromscratch = TRUE;
new_part = FALSE;
}
// riaggiusta partite e scadenze
if (new_part)
{
partita.zero();
partita.put(PART_TIPOCF, tipocf);
partita.put(PART_GRUPPO, gruppo);
partita.put(PART_CONTO, conto);
partita.put(PART_SOTTOCONTO, sottoconto);
partita.put(PART_ANNO, anno);
partita.put(PART_NUMPART, numpart);
partita.put(PART_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(SCAD_TIPOCF, tipocf);
scadenza.put(SCAD_GRUPPO, gruppo);
scadenza.put(SCAD_CONTO, conto);
scadenza.put(SCAD_SOTTOCONTO, sottoconto);
scadenza.put(SCAD_ANNO, anno);
scadenza.put(SCAD_NUMPART, numpart);
scadenza.put(SCAD_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(SCAD_ANNO, anno);
scadenza.put(SCAD_NUMPART, numpart);
scadenza.put(SCAD_NRATA, i+1);
if (scadenza.read() == NOERR)
scadenza.remove();
else new_scad = TRUE;
}
}
///////////////////////////////////////////////////////////
// Sheet partite
///////////////////////////////////////////////////////////
bool TPrimanota_application::edit_partite(int riga)
{
TToken_string& cgr = cgs().row(riga);
const TBill b(cgr, 2, 0x3); // Legge il conto della riga selezionata
if (!b.ok()) return FALSE;
begin_wait();
TString 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);
const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione
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
}
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(1);
// 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); // 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;
}
// PART_TIPOC viene preso dalla partita base
// PART_GRUPPO viene preso dalla partita base
// PART_CONTO viene preso dalla partita base
// PART_SOTTOCONTO viene preso dalla partita base
TBill bill; causale().bill(caus, bill);
if (bill.empty()) causale().bill(caus = 1, bill);
bill.put(part, TRUE);
bill.get(partita.riga(1));
if (bill.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, bill.tipo());
clifo.put(CLI_CODCF, bill.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& partita = _partite.partita(anno, num);
const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione corrente
const int currig = cgs().selected()+1; // Numero riga 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) != currig)
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, currig, 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 (k == K_F8)
{
TMask& m = f.mask();
f.set(m.get(S_IMPORTO));
k = K_TAB;
}
if (f.to_check(k))
{
TMask& m = f.mask();
real i(f.get());
const real tot(m.get(S_IMPORTO));
if (i > tot)
{
warning_box("Non e' possibile inserire un importo superiore a ", tot.string("."));
i = tot;
f.set(i.string());
}
if (i == tot)
m.set(S_SALDOACC, "S");
}
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));
const char sez = part.get_char(PART_SEZ); // Sezione importo e rituenute
const char controsez = sez == 'D' ? 'A' : 'D'; // Sezione opposta
// Memorizza importi prima di eventuali variazioni
const real old_importo(part.get(PART_IMPORTO));
const real old_ritenute(part.get(PART_RITENUTE));
const TBill old_conto(m.get_int(S_GRUPPO), m.get_int(S_CONTO), m.get_long(S_SOTTOCONTO));
const int old_riga = old_conto.ok() ? bill2pos(old_conto, 'I') : -1;
const KEY key = m.run();
if (key == K_ENTER || key == K_DEL)
{
if (key == K_DEL)
{
m.reset(S_IMPORTOPAG);
m.reset(S_RITENUTE);
}
m.autosave(&rel);
part = partita.curr();
if (old_riga >= 0)
sub_cgs_imp(old_riga, old_importo);
// Importo della contropartita
const TImporto new_importo(controsez, part.get_real(PART_IMPORTO));
if (!new_importo.is_zero())
{
TBill conto; conto.get(part);
const int riga = bill2pos(conto, 'I');
if (riga < 0)
set_cgs_row(riga, new_importo, conto, part.get(PART_DESCR), 'I');
else
add_cgs_imp(riga, new_importo);
}
const real rit(part.get(PART_RITENUTE));
const TImporto grow_ritenute(controsez, rit-old_ritenute); // Variazione ritenute fiscali
if (!grow_ritenute.is_zero())
{
const riga = type2pos('F');
if (riga < 0)
{
TBill conto_rit; causale().bill(11, conto_rit);
set_cgs_row(riga, grow_ritenute, conto_rit, "", 'F');
}
else add_cgs_imp(riga, grow_ritenute);
}
if (key == K_ENTER)
p.add_riga(part);
else
p.remove_riga(part);
}
return key != K_ESC;
}
bool TPrimanota_application::notify_cgline_deletion(TPartita& partita, long nreg, int numrig)
{
bool found = FALSE;
const int riga_ritenute = type2pos('F');
for (int r = partita.righe(); r > 0; r--)
{
TRectype pag(partita.riga(r));
const long reg = pag.get_long(PART_NREG);
if (reg == nreg) // Se la registrazione corrisponde
{
const int num = pag.get_int(PART_NUMRIG);
if (num == numrig) // Se la riga corrisponde
{
const real ritenute = pag.get_real(PART_RITENUTE);
if (!ritenute.is_zero())
{
if (riga_ritenute >= 0)
sub_cgs_imp(riga_ritenute, ritenute);
else
error_box("Non esiste la riga delle ritenute di un pagamento della riga %d", numrig);
}
const real importo = pag.get_real(PART_IMPORTO);
if (!importo.is_zero())
{
TBill contro; contro.get(pag);
const int riga_contro = bill2pos(contro, 'I');
if (riga_contro >= 0)
sub_cgs_imp(riga_contro, importo);
else
error_box("Non esiste la riga dell'importo di un pagamento della riga %d", numrig);
}
partita.remove_riga(pag);
found = TRUE;
}
else
if (num > numrig) // Se la riga e' successiva
{
pag.put(PART_NUMRIG, num-1);
partita.add_riga(pag);
}
}
}
return found;
}
bool TPrimanota_application::notify_cgline_deletion(int numrig)
{
bool found = FALSE;
const long nreg = curr_mask().get_long(F_NUMREG);
_partite.add_reg_num(nreg, 0);
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