893 lines
23 KiB
C++
Executable File
893 lines
23 KiB
C++
Executable File
// 770100.cpp - Scheda percipienti
|
|
#include <relapp.h>
|
|
#include <msksheet.h>
|
|
#include <tabutil.h>
|
|
#include <mailbox.h>
|
|
|
|
#include "scperc.h"
|
|
#include "rver.h"
|
|
#include "rpag.h"
|
|
#include "perc.h"
|
|
|
|
#include "770101.h"
|
|
#include "770102.h"
|
|
#include "770100a.h"
|
|
#include "770.h"
|
|
#include "77lib.h"
|
|
|
|
HIDDEN TString80 __tmp;
|
|
HIDDEN const int NUM_COL_VERS = 8; // Contano da 0
|
|
HIDDEN const int NUM_COL_PAG = 9; // " " " " "
|
|
|
|
TSchedaPercipienti::TSchedaPercipienti(): _rel(NULL), _flag_cg(FALSE)
|
|
{
|
|
_from_modify = FALSE;
|
|
memset(_msk, 0, sizeof(_msk));
|
|
}
|
|
|
|
void TSchedaPercipienti::update_lasts(TMask& m)
|
|
{
|
|
if (m.mode() == MODE_MOD)
|
|
{
|
|
const long codditta = m.get_long(F_CODDITTA);
|
|
const char tipoa = m.get(F_TIPOA)[0];
|
|
const long codanagr = m.get_long(F_CODANAGR);
|
|
const int nprog = m.get_int(F_NPROG);
|
|
|
|
// Determino ultimo numero di riga usato nei PAGAMENTI
|
|
_rpag->zero();
|
|
_rpag->put("CODDITTA", (long) codditta);
|
|
_rpag->put("TIPOA", tipoa);
|
|
_rpag->put("CODANAGR", (long) codanagr);
|
|
_rpag->put("NPROG", nprog);
|
|
|
|
TRectype dep(_rpag->curr());
|
|
long nriga = 0L;
|
|
|
|
for (_rpag->read(); !_rpag->eof(); _rpag->next())
|
|
{
|
|
if (_rpag->curr() > dep) break;
|
|
nriga = _rpag->get_long("NRIGA");
|
|
}
|
|
_lastpag = nriga;
|
|
|
|
// Determino ultimo numero di riga usato nei VERSAMENTI
|
|
_rver->zero();
|
|
_rver->put("CODDITTA", (long) codditta);
|
|
_rver->put("TIPOA", tipoa);
|
|
_rver->put("CODANAGR", (long) codanagr);
|
|
_rver->put("NPROG", nprog);
|
|
|
|
TRectype dep2(_rver->curr());
|
|
long nrigav = 0L;
|
|
|
|
for (_rver->read(); !_rver->eof(); _rver->next())
|
|
{
|
|
if (_rver->curr() > dep2) break;
|
|
nrigav = _rver->get_long("NRIGA");
|
|
}
|
|
_lastvers = nrigav;
|
|
}
|
|
else
|
|
_lastpag = _lastvers = 0L;
|
|
}
|
|
|
|
bool TSchedaPercipienti::changing_mask(int mode)
|
|
{
|
|
if (mode == MODE_QUERY)
|
|
return _mode != MODE_QUERY;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
TMask* TSchedaPercipienti::get_mask(int mode)
|
|
{
|
|
const int m = (mode == MODE_QUERY) ? 0 : 1;
|
|
_mode = mode;
|
|
return load_mask(m);
|
|
}
|
|
|
|
|
|
TMask* TSchedaPercipienti::load_mask(int n)
|
|
{
|
|
if (_msk[n] != NULL)
|
|
return _msk[n];
|
|
|
|
TFilename name("770100"); name << char(n == 0 ? 'a' : 'b');
|
|
TMask* m = new TMask(name);
|
|
|
|
switch (n)
|
|
{
|
|
case 0:
|
|
m->set_handler(F_NPROG, nprog_handler);
|
|
m->set_handler(F_CODDITTA, codditta_handler);
|
|
m->set_handler(F_CODANAGRCOM, codanagr_handler);
|
|
m->set_handler(F_CODANAGRPERC, codanagr_handler);
|
|
break;
|
|
case 1:
|
|
{
|
|
m->set_handler(F_DATADOC, check_handler);
|
|
m->set_handler(F_CODCAUS, check_causale);
|
|
m->set_handler(F_SPESE, check_spese);
|
|
m->set_handler(F_COMPENS, check_compensi);
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Handler versamenti
|
|
////////////////////////////////////////////////////////////////////////
|
|
TSheet_field& vers = (TSheet_field&) m->field(F_VERSAMENTI);
|
|
vers.set_notify(vers_notify);
|
|
vers.sheet_mask().set_handler(F_VERS_1015, vers1015_handler);
|
|
vers.sheet_mask().set_handler(DLG_SELPAG, pag_select);
|
|
vers.sheet_mask().set_handler(DLG_AZZERA, ver_azzera);
|
|
vers.sheet_mask().set_handler(F_TIPOVERS, tipo_hndl);
|
|
vers.sheet_mask().set_handler(F_LUOVERS, luo_hndl);
|
|
vers.sheet_mask().set_handler(F_ABI, abicab_hndl);
|
|
vers.sheet_mask().set_handler(F_CAB, abicab_hndl);
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
// Handler pagamenti
|
|
////////////////////////////////////////////////////////////////////////
|
|
TSheet_field& pags = (TSheet_field&) m->field(F_PAGAMENTI);
|
|
pags.set_notify(pags_notify);
|
|
pags.sheet_mask().set_handler(MPAG_COMPENSO, compenso_handler);
|
|
pags.sheet_mask().set_handler(MPAG_IMPONIBILE, imponibile_handler);
|
|
pags.sheet_mask().set_handler(MPAG_PERCRA, percra_handler);
|
|
pags.sheet_mask().set_handler(MPAG_NETTO, netto_handler);
|
|
pags.sheet_mask().set_handler(MPAG_SPESA, spesa_handler);
|
|
pags.sheet_mask().set_handler(MPAG_RITPAG, check_ritenuta);
|
|
pags.sheet_mask().set_handler(DLG_AZZERAPAG, pag_azzera);
|
|
}
|
|
break;
|
|
default:
|
|
CHECKD(0, "Che strano genere di maschera e' la ", n);
|
|
break;
|
|
}
|
|
return _msk[n] = m;
|
|
}
|
|
|
|
// Ricerca e output dell'ultimo nprog del percipiente scelto
|
|
bool TSchedaPercipienti::setta_nprog(TMask& m, const bool variazione, const char* codanag)
|
|
{
|
|
long nprog = 0L;
|
|
TString16 numdoc;
|
|
const char tipoa = m.get(F_TIPOA)[0];
|
|
TString16 codanagr(codanag ? codanag : m.get(F_CODANAGR));
|
|
const long codditta = app().tipo_coll()==nessuno ? get_firm_770() : app().get_firm();
|
|
|
|
// Scrivi nprog solo se il percipiente ESISTE sull'arkivio, non SEMPRE
|
|
if (!app().esiste_perc(m, codanagr))
|
|
return TRUE;
|
|
|
|
TLocalisamfile scperc(LF_SCPERC, FALSE);
|
|
scperc.zero();
|
|
scperc.put("CODDITTA", codditta);
|
|
scperc.put("TIPOA", tipoa);
|
|
scperc.put("CODANAGR", codanagr);
|
|
if (variazione)
|
|
{
|
|
scperc.put("CODANAGR", codanagr);
|
|
scperc.put("DATADOC", app()._coll._datadoc);
|
|
scperc.setkey(2);
|
|
}
|
|
|
|
TRectype rec(scperc.curr());
|
|
bool trovato = FALSE;
|
|
bool one_rec = FALSE;
|
|
|
|
scperc.read();
|
|
|
|
if (scperc.eof())
|
|
{
|
|
one_rec = TRUE;
|
|
nprog = scperc.get_long("NPROG");
|
|
numdoc = scperc.get("NUMDOC");
|
|
|
|
trovato = scperc.curr() == rec;
|
|
|
|
/* if (variazione)
|
|
trovato = scperc.curr() == rec; // (numdoc == app()._coll._numdoc);
|
|
else
|
|
trovato = scperc.curr() == rec; */
|
|
}
|
|
else
|
|
for ( ; !scperc.eof(); scperc.next())
|
|
{
|
|
if (trovato || scperc.curr() > rec) break;
|
|
numdoc = scperc.get("NUMDOC");
|
|
numdoc.trim();
|
|
nprog = scperc.get_long("NPROG");
|
|
|
|
// trovato = scperc.curr() == rec;
|
|
|
|
if (variazione)
|
|
trovato = (numdoc == app()._coll._numdoc);
|
|
}
|
|
|
|
// Azzero nprog se la scheda non e' quella giusta
|
|
if (variazione || one_rec)
|
|
if (!trovato) nprog = 0L;
|
|
|
|
app()._last_scheda = nprog;
|
|
|
|
m.set(F_NPROG, variazione ? nprog : nprog+1);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TSchedaPercipienti::codditta_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_TAB && !(f.mask().is_running()) )
|
|
{
|
|
TString16 codditta;
|
|
// Se chiamata dalla contabilita' prendo ditta con get_firm
|
|
if (app().tipo_coll() == nessuno)
|
|
codditta << get_firm_770();
|
|
else
|
|
codditta << app().get_firm();
|
|
|
|
if (codditta != "0")
|
|
{
|
|
f.set(codditta);
|
|
f.check();
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TSchedaPercipienti::codanagr_handler(TMask_field& f, KEY k)
|
|
{
|
|
// if (k == K_TAB && f.focusdirty())
|
|
// Faccio sempre l'output di codesto numeretto
|
|
if (k == K_TAB)
|
|
{
|
|
TMask& m = f.mask();
|
|
const bool variazione = app().coll_variazione();
|
|
char tipo = f.mask().get(F_TIPOA)[0];
|
|
TString16 codanagr(f.get());
|
|
if (codanagr.not_empty())
|
|
setta_nprog(m, variazione, codanagr);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TSchedaPercipienti::esiste_perc(TMask& m, const char* codanag)
|
|
{
|
|
const char tipoa = m.get(F_TIPOA)[0];
|
|
TString16 codanagr(codanag ? codanag : m.get(F_CODANAGR));
|
|
|
|
// Controllo che l'anagrafica esista
|
|
TLocalisamfile anag(LF_ANAG);
|
|
anag.zero();
|
|
anag.put("TIPOA", tipoa);
|
|
anag.put("CODANAGR", codanagr);
|
|
const bool esiste_anagr = anag.read() == NOERR;
|
|
|
|
return esiste_anagr;
|
|
}
|
|
|
|
// Passa al modo inserimento/modifica.
|
|
bool TSchedaPercipienti::nprog_handler(TMask_field& f, KEY key)
|
|
{
|
|
if (!f.mask().is_running())
|
|
return TRUE;
|
|
|
|
const int nprog = atoi(f.get());
|
|
|
|
if (key == K_ENTER)
|
|
if (app()._flag_cg)
|
|
{
|
|
app()._flag_cg = FALSE; // avoid recursion
|
|
if (nprog==0 || !app().esiste_perc(f.mask()))
|
|
return FALSE;
|
|
|
|
f.mask().stop_run(K_AUTO_ENTER);
|
|
}
|
|
|
|
if (key == K_TAB)
|
|
{
|
|
if (nprog==0 || !app().esiste_perc(f.mask()))
|
|
return FALSE;
|
|
f.mask().stop_run(K_AUTO_ENTER); // entra in modo modifica/inserimento
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TSchedaPercipienti::user_create()
|
|
{
|
|
_per = new TLocalisamfile(LF_PERC);
|
|
_rel = new TSchedaPE;
|
|
_rver = new TLocalisamfile(LF_RVER);
|
|
_rpag = new TLocalisamfile(LF_RPAG);
|
|
|
|
_pags = new TNikArray_sheet(-1, -1, 0, 0, "Selezione Pagamenti",
|
|
"@1|Data@11|Compenso@16|Spese@16|Ritenuta@16|",
|
|
0,NULL_WIN,5);
|
|
|
|
set_search_field(F_CODANAGRPERC);
|
|
|
|
// Collegamento da contabilita'
|
|
TMailbox m;
|
|
TMessage* msg = m.next_s("LINK770");
|
|
|
|
if (msg != NULL)
|
|
{
|
|
if ( !_coll.read(msg->body()) )
|
|
#ifdef DBG
|
|
return warning_box("Errore nei parametri passati");
|
|
#endif
|
|
;
|
|
|
|
const long ditta_cg = get_firm();
|
|
if (!exist_dichiar_770(ditta_cg))
|
|
if (yesno_box("Creo la dichiarazione per la ditta %ld", ditta_cg))
|
|
if (!enter_dichiar_770(ditta_cg))
|
|
#ifdef DBG
|
|
return warning_box("Creazione dichiarazione fallita!");
|
|
#endif
|
|
;
|
|
|
|
}
|
|
|
|
load_mask(0);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool TSchedaPercipienti::user_destroy()
|
|
{
|
|
if (_msk[1] != NULL) delete _msk[1];
|
|
if (_msk[0] != NULL) delete _msk[0];
|
|
|
|
delete _rel; delete _per; delete _rver;
|
|
delete _rpag; delete _pags;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// COMPILA_TESTATA
|
|
//
|
|
// Usata nel collegamento da cg
|
|
//
|
|
void TSchedaPercipienti::compila_testata(TMask& m)
|
|
{
|
|
m.set(F_DATADOC, _coll._datadoc);
|
|
m.set(F_NUMDOC, _coll._numdoc);
|
|
m.set(F_IVA, _coll._imposte.string());
|
|
m.set(F_SPESE, _coll._spese.string());
|
|
m.set(F_COMPENS, _coll._compenso.string());
|
|
|
|
switch (tipo_coll())
|
|
{
|
|
case occasionale:
|
|
m.set(F_COMPENS, _coll._compenso.string());
|
|
m.set(F_TOTDOC, _coll._compenso.string());
|
|
break;
|
|
case fattura:
|
|
m.set(F_TOTDOC, _coll._totdoc.string());
|
|
m.set(F_TOTRIT, _coll._ritenute.string());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool TSchedaPercipienti::coll_variazione() const
|
|
{
|
|
return _coll._immissione == 'M' || tipo_coll() == pagamento ||
|
|
tipo_coll() == pagamento_piu_perc;
|
|
}
|
|
|
|
void TSchedaPercipienti::get_ragsoc(const char* tipoa, const long codanagr)
|
|
{
|
|
TLocalisamfile anag(LF_ANAG);
|
|
anag.zero();
|
|
anag.setkey(1);
|
|
anag.put("TIPOA", tipoa);
|
|
anag.put("CODANAGR", codanagr);
|
|
const int rc = anag.read();
|
|
if (rc != NOERR)
|
|
anag.zero();
|
|
_ragsoc = anag.get("RAGSOC");
|
|
}
|
|
|
|
void TSchedaPercipienti::init_modify_mode(TMask& m)
|
|
{
|
|
_from_modify = TRUE;
|
|
_codanagr = m.get_long(F_CODANAGR);
|
|
_tipoa = m.get(F_TIPOA);
|
|
get_ragsoc(_tipoa, _codanagr);
|
|
init_mask(m);
|
|
}
|
|
|
|
void TSchedaPercipienti::init_insert_mode(TMask& m)
|
|
{
|
|
init_mask(m);
|
|
}
|
|
|
|
void TSchedaPercipienti::on_config_change()
|
|
{
|
|
TConfig conf(CONFIG_STUDIO);
|
|
_anno_dic = (int)conf.get_long(ANNO_SEL, NULL);
|
|
}
|
|
|
|
void TSchedaPercipienti::init_query_mode(TMask& m)
|
|
{
|
|
m.set(F_ANNODIC, _anno_dic);
|
|
|
|
// Controllo se chiamata dalla contabilita'
|
|
if (tipo_coll() != nessuno)
|
|
{
|
|
const bool variazione = coll_variazione();
|
|
_flag_cg = TRUE;
|
|
TString16 tipo("");
|
|
tipo << _coll._tipo;
|
|
m.set(F_TIPOA, tipo);
|
|
if (_coll._codanagr != 0L)
|
|
{
|
|
m.set(F_CODANAGR, _coll._codanagr);
|
|
m.set(F_CODANAGRPERC, _coll._codanagr, TRUE);
|
|
m.set(F_CODANAGRCOM, _coll._codanagr);
|
|
}
|
|
|
|
switch (tipo_coll())
|
|
{
|
|
case fattura:
|
|
setta_nprog(m, variazione);
|
|
m.send_key(K_AUTO_ENTER,0);
|
|
return;
|
|
break;
|
|
case pagamento:
|
|
if (coll_datanum())
|
|
{
|
|
setta_nprog(m, variazione);
|
|
m.send_key(K_AUTO_ENTER, 0);
|
|
}
|
|
return;
|
|
break;
|
|
case occasionale:
|
|
/*
|
|
setta_nprog(m,FALSE); // Sempre in aggiunta
|
|
m.send_key(K_AUTO_ENTER, 0); */
|
|
return;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (_from_modify)
|
|
{
|
|
m.set(F_TIPOA, _tipoa);
|
|
m.set(F_CODANAGR, _codanagr);
|
|
m.set(F_CODANAGRPERC, _codanagr);
|
|
m.set(F_CODANAGRCOM, _codanagr);
|
|
m.set(F_RAGSOCPER, _ragsoc);
|
|
m.set(F_RAGSOCCOM, _ragsoc);
|
|
}
|
|
else
|
|
{
|
|
m.send_key(K_SHIFT+K_CTRL+'h', -1); // group 1 Scelta ANAGR
|
|
m.send_key(K_SHIFT+K_CTRL+'s', -2); // group 3 Ricerca su DATI PER
|
|
}
|
|
|
|
_from_modify = FALSE;
|
|
|
|
// forza il ricalcolo dell'ultimo numero disponibile
|
|
TString16 dummy(m.get(F_NPROG));
|
|
if (dummy.not_empty())
|
|
setta_nprog(m);
|
|
}
|
|
|
|
void TSchedaPercipienti::init_query_insert_mode(TMask& m)
|
|
{
|
|
m.set(F_ANNODIC, _anno_dic);
|
|
|
|
// Se vengo da modifica mantieni la selezione precedente
|
|
if (_from_modify)
|
|
{
|
|
m.set(F_TIPOA, _tipoa);
|
|
m.set(F_CODANAGR, _codanagr);
|
|
m.set(F_CODANAGRPERC, _codanagr);
|
|
m.set(F_CODANAGRCOM, _codanagr);
|
|
m.set(F_RAGSOCPER, _ragsoc);
|
|
m.set(F_RAGSOCCOM, _ragsoc);
|
|
}
|
|
else
|
|
{
|
|
m.send_key(K_SHIFT+K_CTRL+'h', -2); // group 3 Nasconde ricerca su PERC
|
|
m.send_key(K_SHIFT+K_CTRL+'s', -1); // group 1 Ricerca su ANAGR
|
|
}
|
|
}
|
|
|
|
void TSchedaPercipienti::rec2row(TToken_string& r, TRectype& rec, int row)
|
|
{
|
|
TString16 dver, dpag, serie, numero, rite;
|
|
TString16 comp, impo, perc, spesa, netto;
|
|
TString16 nrigavers, numpag, progrbanca;
|
|
TString SsnPerc, SsnCompl;
|
|
|
|
r = "";
|
|
if (rec.num() == LF_RVER)
|
|
{
|
|
char v1015 = rec.get_bool("VERS1015") ? 'X' : ' ';
|
|
dver = rec.get("DATAVERS");
|
|
char tv = rec.get_char("TIPOVERS");
|
|
char lv = rec.get_char("LUOVERS");
|
|
serie = rec.get("SERIE");
|
|
numero = rec.get("NUMERO");
|
|
rite = rec.get("RITENUTA");
|
|
progrbanca = rec.get("PROGBANC");
|
|
nrigavers = rec.get("NRIGA");
|
|
|
|
if (rite.empty()) rite = " ";
|
|
if (progrbanca.empty()) progrbanca = " ";
|
|
if (nrigavers.empty()) nrigavers = " ";
|
|
if (serie.empty()) serie = " ";
|
|
if (numero.empty()) numero = " ";
|
|
|
|
r.add(v1015, 0);
|
|
r.add(dver,1);
|
|
r.add(lv == '\0' ? ' ' : lv);
|
|
r.add(tv == '\0' ? ' ' : tv);
|
|
r.add(serie);
|
|
r.add(numero);
|
|
r.add(progrbanca);
|
|
r.add(rite);
|
|
r.add(nrigavers);
|
|
|
|
if (v1015 == 'X')
|
|
disable_vers_cells(row);
|
|
else
|
|
enable_vers_cells(row);
|
|
}
|
|
|
|
if (rec.num() == LF_RPAG)
|
|
{
|
|
dpag = rec.get("DATAPAG");
|
|
comp = rec.get("COMPENSO");
|
|
impo = rec.get("IMPONIBILE");
|
|
perc = rec.get("PERC");
|
|
rite = rec.get("RITENUTA");
|
|
spesa = rec.get("SPESA");
|
|
netto = rec.get("NETTO");
|
|
SsnPerc = rec.get("CTSSNPERC");
|
|
SsnCompl = rec.get("CTSSNCOMP");
|
|
nrigavers = rec.get("NUMVERS");
|
|
|
|
r.add(dpag); r.add(comp);
|
|
r.add(spesa); r.add(impo);
|
|
r.add(perc); r.add(rite);
|
|
r.add(SsnPerc); r.add(SsnCompl);
|
|
r.add(netto);
|
|
r.add(nrigavers);
|
|
}
|
|
}
|
|
|
|
int TSchedaPercipienti::read(TMask& m)
|
|
{
|
|
m.autoload(_rel);
|
|
|
|
TSheet_field& pags = (TSheet_field&)m.field(F_PAGAMENTI);
|
|
pags.destroy();
|
|
|
|
for (int r = 0; r < _rel->pag_items(); r++)
|
|
rec2row(pags.row(r), _rel->pag(r), r);
|
|
|
|
TSheet_field& vers = (TSheet_field&)m.field(F_VERSAMENTI);
|
|
vers.destroy();
|
|
|
|
for (r = 0; r < _rel->ver_items(); r++)
|
|
rec2row(vers.row(r), _rel->ver(r), r);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void TSchedaPercipienti::enable_vers_cells(int r, bool enable)
|
|
{
|
|
TSheet_field& ver = vers();
|
|
for (int i=1; i<NUM_COL_VERS; i++)
|
|
enable ? ver.enable_cell(r,i) : ver.disable_cell(r,i);
|
|
}
|
|
|
|
void TSchedaPercipienti::new_row(TSheet_field& ver_pag, int r, bool vers)
|
|
{
|
|
TToken_string& riga = ver_pag.row(r);
|
|
|
|
if (vers)
|
|
riga.add(++_lastvers, NUM_COL_VERS);
|
|
else
|
|
riga.add(-1, NUM_COL_PAG);
|
|
}
|
|
|
|
//
|
|
// FILL_SHEET
|
|
//
|
|
// Determino QUI un progressivo unico per i pagamenti e i versamenti
|
|
// (NUMVERS e NUMPAG: vedi new_row())
|
|
//
|
|
void TSchedaPercipienti::fill_sheet(TMask& m)
|
|
{
|
|
TSheet_field& pags = (TSheet_field&)m.field(F_PAGAMENTI);
|
|
for (int r = pags.items(); r < 16; r++)
|
|
new_row(pags, r, FALSE);
|
|
|
|
TSheet_field& vers = (TSheet_field&)m.field(F_VERSAMENTI);
|
|
for (r = vers.items(); r < 16; r++)
|
|
new_row(vers, r, TRUE);
|
|
}
|
|
|
|
bool TSchedaPercipienti::scrivi_dati_per(TRectype& rec)
|
|
{
|
|
TLocalisamfile dati_per(LF_PERC);
|
|
const long codditta = rec.get_long("CODDITTA");
|
|
char tipoa = rec.get_char("TIPOA");
|
|
const long codanagr = rec.get_long("CODANAGR");
|
|
|
|
dati_per.zero();
|
|
dati_per.put("CODDITTA", codditta);
|
|
dati_per.put("TIPOA", tipoa);
|
|
dati_per.put("CODANAGR", codanagr);
|
|
|
|
const bool preesistente = (dati_per.read() == NOERR);
|
|
|
|
if (!preesistente)
|
|
{
|
|
dati_per.zero();
|
|
dati_per.put("CODDITTA", codditta);
|
|
dati_per.put("TIPOA", tipoa);
|
|
dati_per.put("CODANAGR", codanagr);
|
|
|
|
dati_per.write();
|
|
}
|
|
|
|
return preesistente;
|
|
}
|
|
|
|
int TSchedaPercipienti::rewrite(const TMask& m)
|
|
{
|
|
mask2rel(m);
|
|
const int err = _rel->rewrite();
|
|
scrivi_dati_per(_rel->curr());
|
|
// update_lasts(); // aggiorna lastvers e lastpag
|
|
return err;
|
|
}
|
|
|
|
int TSchedaPercipienti::write(const TMask& m)
|
|
{
|
|
mask2rel(m);
|
|
const int err = _rel->write();
|
|
scrivi_dati_per(_rel->curr());
|
|
// update_lasts(); // aggiorna lastvers e lastpag
|
|
return err;
|
|
}
|
|
|
|
bool TSchedaPercipienti::check_compensi(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
const bool forzatura = f.mask().get_bool(F_FORCED);
|
|
real doc_compenso(f.get());
|
|
|
|
if (app()._tot_compenso > doc_compenso)
|
|
{
|
|
warning_box ("Il totale dei compensi non puo' superare\n"
|
|
"il compenso indicato nel documento");
|
|
|
|
return forzatura;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TSchedaPercipienti::check_spese(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
const bool forzatura = f.mask().get_bool(F_FORCED);
|
|
real doc_spese(f.get());
|
|
|
|
if (app()._tot_spese > doc_spese)
|
|
{
|
|
warning_box ("Il totale delle spese non puo' superare\n"
|
|
"la spesa indicata nel documento");
|
|
return forzatura;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Calcola:
|
|
//
|
|
// totale compenzi
|
|
// totale spese
|
|
// totale netti pagati
|
|
//
|
|
// - NB -
|
|
// FUNZIONA SOLO SE PASSA PRIMA DI QUA!
|
|
//
|
|
bool TSchedaPercipienti::check_handler(TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
const bool forzatura = f.mask().get_bool(F_FORCED);
|
|
int i;
|
|
TArray& rpag = app().pags().rows_array();
|
|
|
|
app()._tot_compenso = ZERO;
|
|
app()._tot_spese = ZERO;
|
|
app()._tot_netto = ZERO;
|
|
app()._tot_rit = ZERO;
|
|
|
|
// Calcolo totale compensi e totale spese e totale netti
|
|
for (i = 0; i < rpag.items(); i++)
|
|
{
|
|
TToken_string& row = (TToken_string&)rpag[i];
|
|
|
|
if (app().my_empty_items(row, FALSE)) continue;
|
|
|
|
real compenso (row.get(1));
|
|
real spese (row.get(2));
|
|
real ritenuta (row.get(5));
|
|
real netto (row.get(8));
|
|
|
|
app()._tot_compenso += compenso;
|
|
app()._tot_spese += spese;
|
|
app()._tot_netto += netto;
|
|
app()._tot_rit += ritenuta;
|
|
}
|
|
|
|
/**const real somma = doc_compenso + doc_spese;
|
|
if (tot_netto > somma)
|
|
{
|
|
warning_box ("Il totale dei netti pagati non puo' superare\n"
|
|
"la somma del compenso e della spesa indicate nel documento");
|
|
return forzatura;
|
|
}**/
|
|
|
|
TArray& rver = app().vers().rows_array();
|
|
app()._tot_vers = ZERO;
|
|
|
|
// Calcola totale versato
|
|
for (i = 0; i < rver.items(); i++)
|
|
{
|
|
TToken_string& row = (TToken_string&)rver[i];
|
|
if (app().my_empty_items(row, TRUE)) continue;
|
|
real versato (row.get(7));
|
|
app()._tot_vers += versato;
|
|
}
|
|
|
|
app()._tot_rit.round(0);
|
|
app()._tot_vers.round(0);
|
|
|
|
const real THRESOLD = 500.00;
|
|
const real diff = app()._tot_vers - app()._tot_rit;
|
|
|
|
if (diff > ZERO)
|
|
if (diff > THRESOLD)
|
|
{
|
|
warning_box ("La differenza tra il totale dei versamenti "
|
|
"e il totale delle ritenute non puo' superare "
|
|
"le %s lire", THRESOLD.string());
|
|
return forzatura;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Trasferisce i dati dalla maschera alla relazione
|
|
void TSchedaPercipienti::mask2rel(const TMask& m)
|
|
{
|
|
_rel->lfile().zero();
|
|
m.autosave(_rel);
|
|
|
|
const long codditta = m.get_long(F_CODDITTA);
|
|
const char tipoa = m.get(F_TIPOA)[0];
|
|
const long codanagr = m.get_long(F_CODANAGR);
|
|
const int nprogr = m.get_int(F_NPROG);
|
|
|
|
_rel->destroy_rows(); // Destroy all records
|
|
pag_pack(); // Destroy all null rows
|
|
|
|
TArray& rows = pags().rows_array();
|
|
|
|
for (int i = 0; i < rows.items(); i++)
|
|
{
|
|
TToken_string& row = (TToken_string&)rows[i];
|
|
TRectype &r = _rel->pag(i);
|
|
|
|
long nriga = i + 1;
|
|
|
|
r.zero();
|
|
r.put("CODDITTA", codditta);
|
|
r.put("TIPOA", tipoa);
|
|
r.put("CODANAGR", codanagr);
|
|
r.put("NPROG", nprogr);
|
|
r.put("NRIGA", nriga);
|
|
|
|
// LEGGO SPREADSHEET PAGAMENTI
|
|
TString16 datap = row.get(0);
|
|
const TDate datapag(datap);
|
|
real compenso (row.get(1));
|
|
real spese (row.get(2));
|
|
real imponibile(row.get(3));
|
|
const real aliquota(row.get(4));
|
|
real ritenuta (row.get(5));
|
|
real SsnPerc (row.get(6));
|
|
real SsnCompl (row.get(7));
|
|
real compnetto (row.get(8));
|
|
const int numvers (row.get_int(9));
|
|
// const int numpag (row.get_int(8));
|
|
|
|
r.put("DATAPAG", datapag);
|
|
r.put("COMPENSO", compenso);
|
|
r.put("IMPONIBILE", imponibile);
|
|
r.put("PERC", aliquota);
|
|
r.put("RITENUTA", ritenuta);
|
|
r.put("SPESA", spese);
|
|
r.put("NETTO", compnetto);
|
|
r.put("NUMVERS", (long)numvers);
|
|
r.put("CTSSNPERC", SsnPerc);
|
|
r.put("CTSSNCOMP", SsnCompl);
|
|
// r.put("NUMPAG", (long)nriga);
|
|
// r.put("NUMPAG", (long)numpag);
|
|
}
|
|
|
|
// ver_pack(); // Destroy all null rows
|
|
|
|
rows = vers().rows_array();
|
|
|
|
for (i = 0; i < rows.items(); i++)
|
|
{
|
|
TToken_string& row = (TToken_string&)rows[i];
|
|
TRectype &r = _rel->ver(i);
|
|
|
|
if (my_empty_items(row, TRUE))
|
|
continue; // non salvare righe vuote
|
|
|
|
long nriga = i+1;
|
|
|
|
r.zero();
|
|
r.put("CODDITTA", codditta);
|
|
r.put("TIPOA", tipoa);
|
|
r.put("CODANAGR", codanagr);
|
|
r.put("NPROG", nprogr);
|
|
r.put("NRIGA", nriga);
|
|
|
|
// LEGGO SPREADSHEET VERSAMENTI
|
|
const bool vers1015 = (row.get_char(0) == 'X');
|
|
TString16 datav = row.get(1);
|
|
const TDate dataver(datav);
|
|
|
|
const char luogo = row.get_char(2);
|
|
const char tipo = row.get_char(3);
|
|
|
|
TString16 serie(row.get(4));
|
|
TString numero(row.get(5));
|
|
const long ProgBanca = row.get_long(6);
|
|
real ritenuta (row.get(7));
|
|
const int numvers (row.get_int(8));
|
|
|
|
r.put("VERS1015", vers1015);
|
|
r.put("DATAVERS", dataver);
|
|
r.put("LUOVERS", luogo);
|
|
r.put("TIPOVERS", tipo);
|
|
|
|
r.put("SERIE", serie);
|
|
r.put("NUMERO", numero);
|
|
r.put("PROGBANC", (long)ProgBanca);
|
|
r.put("RITENUTA", ritenuta);
|
|
// r.put("NUMVERS", (long)nriga);
|
|
// r.put("NUMVERS", (long)numvers);
|
|
}
|
|
}
|
|
|
|
int SchedaPerc (int argc, char* argv[])
|
|
{
|
|
TSchedaPercipienti a;
|
|
a.run(argc, argv, "Scheda Percipienti");
|
|
return 0;
|
|
}
|