root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 12.0 1044

Browse Source 
Files correlati     : ef0.exe ef0100a.msk eftbman.msk
Commento            :

Supporto per gli IBAN esteri negli effetti
This commit is contained in:
Alessandro Bonazzi 2021-03-25 11:55:50 +01:00
parent f171ee3170
commit e01757f2d0
7 changed files with 376 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

538
src/ef/ef0100.cpp
View File

@ -12,6 +12,18 @@
#include "tabutil.h" #include "tabutil.h"
#include "utility.h" #include "utility.h"
class TEffetti_mask : public TIBAN_mask
{
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
bool on_sheet_event(TOperable_field& o, TField_event e, long jolly);
void calcola_totali();
public:
TEffetti_mask() : TIBAN_mask("ef0100a", F_IBAN_STATO, F_IBAN_CHECK, F_BBAN_CIN, F_CODABI, F_CODCAB, F_BBAN_CONTO, F_IBAN, F_BBAN) {}
};
/////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////
// Classe per la gestione di effetti con metodi standard di: // // Classe per la gestione di effetti con metodi standard di: //
// inserimento, modifica, cancellazione. // // inserimento, modifica, cancellazione. //
@ -29,20 +41,9 @@ protected:
virtual bool get_next_key(TToken_string& key); virtual bool get_next_key(TToken_string& key);
virtual void init_modify_mode(TMask&); virtual void init_modify_mode(TMask&);
static bool clifo_handler(TMask_field& f, KEY k);
static bool datascad_handler(TMask_field& f, KEY k);
static bool mandato_handler(TMask_field& f, KEY k);
static bool handle_sheet(TMask_field& f, KEY);
static bool cambio_handler(TMask_field& f, KEY k);
static bool codval_handler(TMask_field& f, KEY k);
static bool contab_handler(TMask_field& f, KEY k);
static bool fatt_handler(TMask_field& f, KEY k);
static bool impeff_notify(TSheet_field& s, int r, KEY key);
TSheet_field& cess_sheet() const; TSheet_field& cess_sheet() const;
TSheet_field& righe_sheet() const; TSheet_field& righe_sheet() const;
void common_f(const TMask& m); void common_f(const TMask& m);
static void calcola_totali();
virtual int read(TMask& m); virtual int read(TMask& m);
virtual int rewrite(const TMask& m); virtual int rewrite(const TMask& m);
virtual int write(const TMask& m); virtual int write(const TMask& m);
@ -52,20 +53,16 @@ protected:
virtual TMask* get_mask(int mode) {return _msk;} virtual TMask* get_mask(int mode) {return _msk;}
virtual bool changing_mask(int mode) {return false;} virtual bool changing_mask(int mode) {return false;}
virtual void ini2mask(TConfig& ini, TMask& m, bool query); virtual void ini2mask(TConfig& ini, TMask& m, bool query);
public: public:
virtual bool protected_record(TRectype&); virtual bool protected_record(TRectype&);
virtual TRelation* get_relation() const {return _rel;} virtual TRelation* get_relation() const {return _rel;}
TVariazione_effetti(): _msk(nullptr), _effetto(nullptr), _rel(nullptr) TVariazione_effetti(): _msk(nullptr), _effetto(nullptr), _rel(nullptr) {}
{
}
virtual ~TVariazione_effetti() = default; virtual ~TVariazione_effetti() = default;
}; };
// restituisce un riferimento all' applicazione // restituisce un riferimento all' applicazione
inline TVariazione_effetti& app() {return (TVariazione_effetti&)main_app();} inline TVariazione_effetti& app() { return (TVariazione_effetti&)main_app(); }
// quando si va in query mode resetta i due campi della maschera // quando si va in query mode resetta i due campi della maschera
// relativi ai totali // relativi ai totali
@ -213,18 +210,21 @@ int TVariazione_effetti::read(TMask& m)
TLocalisamfile& f = _rel->lfile(LF_EFFETTI); TLocalisamfile& f = _rel->lfile(LF_EFFETTI);
// legge l'effetto dal record corrente della relazione // legge l'effetto dal record corrente della relazione
err = _effetto->read(f, _rel->curr()); err = _effetto->read(f, _rel->curr());
if (err == NOERR) if (err == NOERR)
{ {
TString16 codcom(3); TString16 codcom(3);
TToken_string riga(80); TToken_string riga(80);
TSheet_field& shcess = cess_sheet(); TSheet_field& shcess = cess_sheet();
shcess.reset(); shcess.reset();
TSheet_field& shrighe = righe_sheet(); TSheet_field& shrighe = righe_sheet();
shrighe.reset(); shrighe.reset();
int items = _effetto->rows_c(); int items = _effetto->rows_c();
int i;
// m.set(F_IBAN, _rel->curr().get(EFF_IBAN), 0x3);
// carica tutti i cessionari nello sheet dal file // carica tutti i cessionari nello sheet dal file
for (i = 1; i <= items; i++) for (int i = 1; i <= items; i++)
{ {
const TRectype& rec = _effetto->row_c(i); const TRectype& rec = _effetto->row_c(i);
riga.cut(0); riga.cut(0);
@ -242,12 +242,7 @@ int TVariazione_effetti::read(TMask& m)
shcess.row(i-1)=riga; shcess.row(i-1)=riga;
} }
items = _effetto->rows_r(); items = _effetto->rows_r();
// carica tutte le righe dell'effetto nello sheet dal file for (int i = 1; i <= items; i++)
// TEdit_field & e = (TEdit_field &) shrighe.sheet_mask().field(F_NUMFATT);
// CheckType c = e.check_type();
// e.check_type(CHECK_REQUIRED);
for (i = 1; i <= items; i++)
{ {
const TRectype& rec = _effetto->row_r(i); const TRectype& rec = _effetto->row_r(i);
riga.cut(0); riga.cut(0);
@ -268,7 +263,6 @@ int TVariazione_effetti::read(TMask& m)
shrighe.row(i - 1) = riga; shrighe.row(i - 1) = riga;
shrighe.check_row(i - 1); shrighe.check_row(i - 1);
} }
// e.check_type(c);
} }
} }
return err; return err;
@ -309,19 +303,8 @@ bool TVariazione_effetti::user_create()
LF_CLIFO, LF_CFVEN, LF_OCCAS, 0); LF_CLIFO, LF_CFVEN, LF_OCCAS, 0);
_rel = new TRelation(LF_EFFETTI); _rel = new TRelation(LF_EFFETTI);
_effetto = new TEffetto; _effetto = new TEffetto;
_msk = new TMask("ef0100a") ; _msk = new TEffetti_mask ;
_msk->set_handler(F_CODCF, clifo_handler);
_msk->set_handler(F_DATASCAD, datascad_handler);
_msk->set_handler(F_MANDATO, mandato_handler);
_msk->set_handler(F_CODVAL, codval_handler);
_msk->set_handler(F_CAMBIO, cambio_handler);
_msk->set_handler(F_EFFCONT, contab_handler);
_msk->set_handler(F_SHEET_RIGHE, handle_sheet);
righe_sheet().set_append(true); righe_sheet().set_append(true);
righe_sheet().set_notify(impeff_notify);
_msk->sfield(F_SHEET_RIGHE).sheet_mask().set_handler(F_NUMFATT, fatt_handler);
return true; return true;
} }
@ -334,252 +317,269 @@ bool TVariazione_effetti::user_destroy()
return true; return true;
} }
// handler che permette di effettuare il controllo sul fatto void TEffetti_mask::calcola_totali()
// che venga inserita almeno una riga per un effetto
bool TVariazione_effetti::handle_sheet(TMask_field &f, KEY k)
{ {
TMask& m = f.mask(); TSheet_field& sf = sfield(F_SHEET_RIGHE);
const int mode = m.mode();
// se si vuole salvare e si è in uno dei due modi di funzionamento
if ( k == K_ENTER && (mode == MODE_INS || mode == MODE_MOD) )
{ // si controllano le righe del effetto nello sheet
TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
int items = sf.items();
bool found = false;
for (int i = 0; i < items && !found; i++)// scandisco tutte le righe dello sheet
{
TToken_string& row = sf.row(i);
real imp_eff(row.get(sf.cid2index(F_IMPEFF)));
// controlla che le righe abbiano un importo
if (imp_eff != ZERO) found = true;
}
// se non ha trovato righe nello sheet oppure se quelle che ci sono non
// hanno importo
if (!found)
{ // non permetto di salvare l'effetto
error_box(TR("L'effetto non può contenere righe con importo nullo!"));
return false;
}
}
return true;
}
bool TVariazione_effetti::clifo_handler(TMask_field& f, KEY k)
{
if (k == K_TAB && f.to_check(k))
{
TMask& m = f.mask();
const char tipocf = m.get(F_TIPOCF)[0];
const long codcf = m.get_long(F_CODCF);
TCli_for & cf = (TCli_for &)cached_clifor(tipocf, codcf);
const TString & iban = cf.get_iban();
if (iban.full())
{
m.set(F_IBAN, iban);
m.set(F_IBAN_STATO, iban.left(2));
m.set(F_IBAN_CHECK, iban.mid(2,2));
m.set(F_BBAN, iban.mid(4));
m.set(F_BBAN_CIN, iban.mid(4,1));
m.set(F_BBAN_ABI, iban.mid(5,5));
m.set(F_BBAN_CAB, iban.mid(10,5));
m.set(F_BBAN_CONTO, iban.mid(15));
m.efield(F_IBAN_STATO).validate(K_TAB);
}
TToken_string& banp = cf.get_ban_pres();
if (banp.full())
{
m.set(F_CODABIP, banp.get());
m.set(F_CODCABP, banp.get());
m.set(F_PROG, banp.get());
m.efield(F_PROG).validate(K_TAB);
}
}
return true;
}
bool TVariazione_effetti::datascad_handler(TMask_field& f, KEY k)
{
if (k == K_ENTER)
{
const TDate datascad = f.get();
TSheet_field& sf = f.mask().sfield(F_SHEET_RIGHE);
FOR_EACH_SHEET_ROW(sf, r, row)
{
TDate datafat = row->get(F_DATAFATT-FIRST_FIELD);
if (datascad < datafat)
return f.error_box(FR("La data fattura della riga %d è successiva alla data di scadenza"), r+1);
}
}
return true;
}
bool TVariazione_effetti::mandato_handler(TMask_field& f, KEY k)
{
if (k == K_TAB && !f.empty())
{
TMask& m = f.mask();
TEdit_field& i = m.efield(F_IBAN_STATO);
i.validate(K_TAB);
m.set(F_CODABI, m.get(F_BBAN_ABI));
m.set(F_CODCAB, m.get(F_BBAN_CAB));
}
return true;
}
// handler che permette il controllo sulla abilitazione dei campi collegati
// al codice valuta
bool TVariazione_effetti::codval_handler(TMask_field& f, KEY k)
{
if (f.to_check(k, true))
{
TMask& m = f.mask();
const TString& val = f.get();
// se non c'e valuta o se è lire disabilitato i campi collegati
const bool valuta = (val.not_empty() && val != TCurrency::get_firm_val());
m.enable(-1,valuta);
TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
if (!valuta)
{
m.reset(-1);
m.reset(F_TOTIMPVAL);
for (int i = sf.items() - 1; i >= 0; i--)
{
TToken_string& row = sf.row(i);
row.add(" ", sf.cid2index(F_IMPEFFVAL));
row.add(" ", sf.cid2index(F_IMPFATTVAL));
}
}
sf.enable_column(F_IMPEFFVAL, valuta);
if (f.focusdirty())
sf.force_update();
}
return true;
}
// handler che gestisce la modifica del cambio
bool TVariazione_effetti::cambio_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
//if (k == K_TAB && f.to_check(k, true))
if (k == K_TAB && f.focusdirty())
{
const real cambio = f.get();
const TString& valuta = m.get(F_CODVAL);
TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
int items = sf.items();
real imp, impval;
// scandisco tutte le righe dello sheet e modifico gli importi in lire
for (int i = 0; i < items; i++)
{
TToken_string& row = sf.row(i);
impval = row.get(sf.cid2index(F_IMPEFFVAL));
TCurrency val(impval, valuta, cambio);
val.change_to_firm_val();
imp = val.get_num();
row.add(imp.string(), sf.cid2index(F_IMPEFF));
}
if (f.focusdirty())
sf.force_update();
}
return true;
}
// handler che permette il controllo sulla abilitazione dei campi collegati
// al codice valuta
bool TVariazione_effetti::fatt_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB && f.focusdirty() || !app().get_mask(MODE_MOD)->is_running())
{
TEdit_field & e = (TEdit_field &) f;
CheckType c = e.check_type();
e.check_type(CHECK_REQUIRED);
const bool ok = e.check();
e.check_type(c);
m.enable(F_DATAFATT, !ok);
m.enable(F_IMPFATT, !ok);
m.enable(F_IMPFATTVAL, !ok && app().get_mask(MODE_MOD)->get(F_CODVAL).not_empty());
if (app().get_mask(MODE_MOD)->is_running() && ok && k == K_TAB && f.focusdirty())
{
const TDocumento d(e.browse()->cursor()->curr());
m.set(F_DATAFATT, d.get("DATADOC"));
const real imp = d.totale_doc();
if (d.in_valuta())
{
const TString16 codval = d.get(DOC_CODVAL);
TCurrency val(imp, codval, d.get_real(DOC_CAMBIO));
val.change_to_firm_val();
const real& lit = val.get_num();
m.set(F_IMPFATT, lit);
m.set(F_IMPFATTVAL, imp);
}
else
{
m.set(F_IMPFATT, imp);
m.reset(F_IMPFATTVAL);
}
}
}
return true;
}
bool TVariazione_effetti::contab_handler(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask &m = f.mask();
const bool da_contab = f.get().empty();
TSheet_field& sf = m.sfield(F_SHEET_RIGHE);
sf.enable_column(F_ANNO, da_contab);
sf.enable_column(F_NUMPART, da_contab);
sf.force_update();
}
return true;
}
// funzione chiamata dal notify dello sheet per effettuare il calcolo degli
// importi totali (in lire ed in valuta) dell'effetto
void TVariazione_effetti::calcola_totali()
{
TMask* m = app()._msk;
TSheet_field& sf = m->sfield(F_SHEET_RIGHE);
int items = sf.items(); int items = sf.items();
real imp, impval, impeff, impeffval; real impeff, impeffval;
// scandisco tutte le righe dello sheet e ne prendo gli importi // scandisco tutte le righe dello sheet e ne prendo gli importi
// (in lire ed in valuta) e li sommo al totale // (in lire ed in valuta) e li sommo al totale
for (int i = 0; i < items; i++) for (int i = 0; i < items; i++)
{ {
TToken_string& row = sf.row(i); impeff += sf.get_real_row_cell(i, F_IMPEFF);
imp = row.get(sf.cid2index(F_IMPEFF)); impeffval += sf.get_real_row_cell(i, F_IMPEFFVAL);
impeff += imp;
impval = row.get(sf.cid2index(F_IMPEFFVAL));
impeffval += impval;
} }
m->set(F_TOTIMP, impeff); set(F_TOTIMP, impeff);
m->set(F_TOTIMPVAL, impeffval); set(F_TOTIMPVAL, impeffval);
} }
// notify per il calcolo dei totali dell'effetto e per il controllo che non bool TEffetti_mask::on_sheet_event(TOperable_field& o, TField_event e, long jolly)
// vengano eliminate tutte le righe dell'effetto, almeno una deve rimanere
bool TVariazione_effetti::impeff_notify(TSheet_field& s, int r, KEY key)
{ {
if (s.to_check(key, true)) TMask& m = o.mask();
short id = o.dlg();
switch (id)
{ {
calcola_totali(); case F_NUMFATT:
if (e == fe_modify || !is_running())
{
TEdit_field & ef = (TEdit_field &)o;
CheckType c = ef.check_type();
ef.check_type(CHECK_REQUIRED);
const bool ok = ef.check();
ef.check_type(c);
m.enable(F_DATAFATT, !ok);
m.enable(F_IMPFATT, !ok);
m.enable(F_IMPFATTVAL, !ok && is_true_value(get(F_CODVAL)));
if (is_running() && ok && e == fe_modify)
{
const TDocumento d(ef.browse()->cursor()->curr());
const real imp = d.totale_doc();
m.set(F_DATAFATT, d.get(DOC_DATADOC));
if (d.in_valuta())
{
const TString16 codval = d.get(DOC_CODVAL);
TCurrency val(imp, codval, d.get_real(DOC_CAMBIO));
val.change_to_firm_val();
const real& lit = val.get_num();
m.set(F_IMPFATT, lit);
m.set(F_IMPFATTVAL, imp);
}
else
{
m.set(F_IMPFATT, imp);
m.reset(F_IMPFATTVAL);
}
}
}
break;
case F_SHEET_RIGHE:
switch (e)
{
case se_leave:
if (sfield(F_SHEET_RIGHE).focusdirty())
calcola_totali();
return true;
case se_query_del:
if (sfield(F_SHEET_RIGHE).items() == 1)
return error_box(TR("IMPOSSIBILE CANCELLARE: L'effetto deve contenere almeno una riga!"));
return true;
break;
default:
break;
}
default:
break;
} }
//se rimane una sola riga nello sheet non la si può cancellare
if (key == K_DEL && s.items() == 1)
return s.error_box(TR("IMPOSSIBILE CANCELLARE: L'effetto deve contenere almeno una riga!"));
return true; return true;
} }
bool TEffetti_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
const short id = o.dlg();
switch (id)
{
case F_CODCF:
if (e == fe_modify)
{
const char tipocf = get(F_TIPOCF)[0];
const long codcf = get_long(F_CODCF);
TCli_for & cf = (TCli_for &)cached_clifor(tipocf, codcf);
const TString & iban = cf.get_iban();
if (iban.full())
set(F_IBAN, iban, 0x3);
TToken_string& banp = cf.get_ban_pres();
if (banp.full())
{
set(F_CODABIP, banp.get());
set(F_CODCABP, banp.get());
set(F_PROG, banp.get());
efield(F_PROG).validate(K_TAB);
}
}
return true;
break;
case F_CODVAL:
if (e == fe_init || e == fe_modify)
{
// se non c'e valuta o se è lire disabilitato i campi collegati
const bool valuta = is_true_value(o.get());
TSheet_field& sf = sfield(F_SHEET_RIGHE);
enable(-1, valuta);
if (!valuta)
{
reset(-1);
reset(F_TOTIMPVAL);
for (int i = sf.items() - 1; i >= 0; i--)
{
TToken_string& row = sf.row(i);
sf.set_row_cell(F_IMPEFFVAL, ZERO, i);
sf.set_row_cell(F_IMPFATTVAL, ZERO, i);
}
}
sf.enable_column(F_IMPEFFVAL, valuta);
sf.enable_column(F_IMPFATTVAL, valuta);
if (o.focusdirty())
sf.force_update();
}
return true;
break;
case F_DATASCAD:
if (e == fe_close)
{
const TDate datascad = get_date(F_DATASCAD);
TSheet_field& sf = sfield(F_SHEET_RIGHE);
FOR_EACH_SHEET_ROW(sf, r, row)
{
TDate datafat = row->get(F_DATAFATT - FIRST_FIELD);
if (datascad < datafat)
return error_box(FR("La data fattura della riga %d è successiva alla data di scadenza"), r + 1);
}
}
return true;
break;
case F_MANDATO:
if (e == fe_modify && !o.empty())
efield(F_IBAN).on_hit();
return true;
break;
case F_CAMBIO:
if (e == fe_modify)
{
const TString& valuta = get(F_CODVAL);
if (is_true_value(valuta))
{
const real cambio = get_real(F_CAMBIO);
TSheet_field& sf = sfield(F_SHEET_RIGHE);
int items = sf.items();
// scandisco tutte le righe dello sheet e modifico gli importi in lire
for (int i = 0; i < items; i++)
{
TCurrency val(sf.get_real_row_cell(i, F_IMPEFFVAL), valuta, cambio);
val.change_to_firm_val();
sf.set_row_cell(F_IMPEFF, val.get_num(), i);
}
if (o.focusdirty())
sf.force_update();
}
}
return true;
break;
case F_EFFCONT:
if (e == fe_init || e == fe_modify)
{
const bool da_contab = !get_bool(F_EFFCONT);
TSheet_field& sf = sfield(F_SHEET_RIGHE);
sf.enable_column(F_ANNO, da_contab);
sf.enable_column(F_NUMPART, da_contab);
sf.enable_column(F_NUMRIGA, da_contab);
sf.enable_column(F_NUMRATA, da_contab);
sf.enable_column(F_ACCSAL, da_contab);
sf.force_update();
}
return true;
break;
case F_IMPEFFVAL:
case F_IMPEFF:
if (e == fe_modify)
sfield(F_SHEET_RIGHE).set_focusdirty();
break;
case F_SHEET_RIGHE:
return on_sheet_event(o, e, jolly);
default:
if (jolly > 0)
return on_sheet_event(o, e, jolly);
break;
}
return TIBAN_mask::on_field_event(o, e, jolly);
}
/*
bool TVariazione_effetti::iban_handler(TMask_field& f, KEY k)
{
if (f.to_check(k, true))
{
TMask& m = f.mask();
const TString & iban = f.get();
m.set(F_IBAN_STATO, iban.left(2), 0x3);
set_iban_fields(iban, m, F_BBAN, F_IBAN_STATO, F_IBAN_CHECK, F_BBAN_CIN, F_CODABI, F_CODCAB, F_BBAN_CONTO, -1, 0);
}
return true;
}
bool TVariazione_effetti::iso_handler(TMask_field& f, KEY k)
{
if (f.initial_check(k) || f.running_check(k))
{
static TString __last_iso;
TMask &m = f.mask();
const TString & iso = f.get();
const bool italy = iso.blank() || iso == "IT";
m.show(F_BBAN, !italy);
m.show(F_BBAN_CONTO, italy);
if (f.running_check(k))
{
if (iso != __last_iso)
{
const TString iban = m.get(F_IBAN);
set_iban_fields(iban.blank() || iban.left(2) != iso ? iso : iban, m, F_BBAN, F_IBAN_STATO, F_IBAN_CHECK, F_BBAN_CIN, F_CODABI, F_CODCAB, F_BBAN_CONTO, -1, 0);
}
__last_iso = iso;
}
else
{
enable_iban_fields(m, F_BBAN, F_BBAN_CIN, F_CODABI, F_CODCAB, F_BBAN_CONTO, -1, italy, 0);
__last_iso = "INV";
}
}
return true;
}
per documenti
*/
int ef0100(int argc, char* argv[]) int ef0100(int argc, char* argv[])
{ {
TVariazione_effetti a ; TVariazione_effetti a ;

2
src/ef/ef0100.h
View File

@ -49,8 +49,6 @@
#define F_IBAN_CHECK 252 #define F_IBAN_CHECK 252
#define F_BBAN 253 #define F_BBAN 253
#define F_BBAN_CIN 254 #define F_BBAN_CIN 254
#define F_BBAN_ABI 255
#define F_BBAN_CAB 256
#define F_BBAN_CONTO 257 #define F_BBAN_CONTO 257

68
src/ef/ef0100a.uml
View File

@ -294,9 +294,29 @@ BEGIN
PROMPT 0 4 "@bBanca d'appoggio" PROMPT 0 4 "@bBanca d'appoggio"
END END
STRING F_IBAN_STATO 2
BEGIN
PROMPT 1 5 "Stato "
FLAGS "U"
END
NUMBER F_IBAN_CHECK 2
BEGIN
PROMPT 11 5 ""
FLAGS "UZ"
VALIDATE CHECK_IBAN_FUNC F_IBAN F_IBAN_STATO F_IBAN_CHECK F_BBAN F_BBAN_CIN F_CODABI F_CODCAB F_BBAN_CONTO -1 0
END
STRINGA F_BBAN_CIN 1
BEGIN
PROMPT 17 5 ""
FLAGS "U"
VALIDATE CHECK_BBAN_FUNC F_BBAN F_BBAN_CIN F_CODABI F_CODCAB F_BBAN_CONTO
END
NUMBER F_CODABI 5 NUMBER F_CODABI 5
BEGIN BEGIN
PROMPT 1 5 "Codice ABI " PROMPT 20 5 "ABI "
FIELD CODABI FIELD CODABI
FLAGS "Z" FLAGS "Z"
USE %BAN SELECT CODTAB ?= "?????" USE %BAN SELECT CODTAB ?= "?????"
@ -306,12 +326,11 @@ BEGIN
OUTPUT F_CODABI CODTAB[1,5] OUTPUT F_CODABI CODTAB[1,5]
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
WARNING "Codice ABI assente" WARNING "Codice ABI assente"
MESSAGE COPY,F_BBAN_ABI
END END
NUMBER F_CODCAB 5 NUMBER F_CODCAB 5
BEGIN BEGIN
PROMPT 41 5 "Codice CAB " PROMPT 35 5 "CAB "
FIELD CODCAB FIELD CODCAB
FLAGS "Z" FLAGS "Z"
USE %BAN KEY 1 SELECT CODTAB ?= "??????????" USE %BAN KEY 1 SELECT CODTAB ?= "??????????"
@ -323,62 +342,27 @@ BEGIN
OUTPUT F_CODABI CODTAB[1,5] OUTPUT F_CODABI CODTAB[1,5]
OUTPUT F_CODCAB CODTAB[6,10] OUTPUT F_CODCAB CODTAB[6,10]
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
VALIDATE REQIF_FUNC 1 F_CODCABP
WARNING "Banca assente" WARNING "Banca assente"
MESSAGE COPY,F_BBAN_CAB
END END
STRING F_IBAN 34 STRING F_IBAN 34
BEGIN BEGIN
PROMPT 2 60 "" PROMPT 2 60 ""
FLAGS "D" FLAGS "DG"
FIELD IBAN FIELD IBAN
END END
STRING F_IBAN_STATO 2
BEGIN
PROMPT 1 6 "Codice IBAN "
FLAGS "U"
VALIDATE CHECK_IBAN_FUNC F_IBAN F_IBAN_STATO F_IBAN_CHECK F_BBAN F_BBAN_CIN F_BBAN_ABI F_BBAN_CAB F_BBAN_CONTO
END
NUMBER F_IBAN_CHECK 2
BEGIN
PROMPT 19 6 ""
FLAGS "UZ"
VALIDATE CHECK_IBAN_FUNC F_IBAN F_IBAN_STATO F_IBAN_CHECK F_BBAN F_BBAN_CIN F_BBAN_ABI F_BBAN_CAB F_BBAN_CONTO
END
STRINGA F_BBAN 30 STRINGA F_BBAN 30
BEGIN BEGIN
PROMPT 30 6 "BBAN " PROMPT 1 6 "BBAN "
FLAGS "UH" FLAGS "UH"
END END
STRINGA F_BBAN_CIN 1
BEGIN
PROMPT 30 6 "BBAN "
FLAGS "U"
VALIDATE CHECK_BBAN_FUNC F_BBAN F_BBAN_CIN F_BBAN_ABI F_BBAN_CAB F_BBAN_CONTO
END
NUMBER F_BBAN_ABI 5
BEGIN
PROMPT 38 6 ""
FLAGS "DGZ"
END
NUMBER F_BBAN_CAB 5
BEGIN
PROMPT 45 6 ""
FLAGS "DGZ"
END
STRING F_BBAN_CONTO 12 STRING F_BBAN_CONTO 12
BEGIN BEGIN
PROMPT 52 6 "" PROMPT 1 6 "Conto "
FLAGS "UZ" FLAGS "UZ"
VALIDATE CHECK_BBAN_FUNC F_BBAN F_BBAN_CIN F_BBAN_ABI F_BBAN_CAB F_BBAN_CONTO VALIDATE CHECK_BBAN_FUNC F_BBAN F_BBAN_CIN F_CODABI F_CODCAB F_BBAN_CONTO
END END

10
src/ef/ef0200.cpp
View File

@ -1,8 +1,18 @@
#include <modtbapp.h> #include <modtbapp.h>
#include "eftbman.h"
class TMandati_mask : public TIBAN_mask
{
public:
TMandati_mask() : TIBAN_mask("eftbman", F_STATO, F_CHECK, F_CIN, F_ABI, F_CAB, F_CONTO, F_IBAN, F_BBAN) {}
};
class TMandati_app : public TTable_module_application class TMandati_app : public TTable_module_application
{ {
TMask* user_create_mask() { return new TMandati_mask(); }
public: public:
}; };
int ef0200(int argc, char* argv[]) int ef0200(int argc, char* argv[])

2
src/ef/ef1100a.uml
View File

@ -62,7 +62,7 @@ BEGIN
OUTPUT F_CAB CODTAB[6,10] OUTPUT F_CAB CODTAB[6,10]
OUTPUT F_PRO CODTAB[11,12] OUTPUT F_PRO CODTAB[11,12]
OUTPUT F_BANCA 4->S0 OUTPUT F_BANCA 4->S0
CHECTYPE NORMAL CHECTYPE SEARCH
END END
STRING F_BANCA 50 47 STRING F_BANCA 50 47

11
src/ef/eftbman.h
View File

@ -12,8 +12,13 @@
#define F_DESCR 111 #define F_DESCR 111
#define F_DATA 112 #define F_DATA 112
#define F_SEQUENZA 113 #define F_SEQUENZA 113
#define F_ABI 114 #define F_STATO 114
#define F_CAB 115 #define F_CHECK 115
#define F_IBAN 116 #define F_CIN 116
#define F_ABI 117
#define F_CAB 118
#define F_IBAN 119
#define F_BBAN 120
#define F_CONTO 121
#endif // __EF0200_H #endif // __EF0200_H

81
src/ef/eftbman.uml
View File

@ -115,39 +115,82 @@ BEGIN
FIELD S6 FIELD S6
END END
GROUPBOX DLG_NULL 78 4
BEGIN
PROMPT 1 12 "@bBanca d'appoggio"
END
STRING F_STATO 2
BEGIN
PROMPT 2 13 "Stato "
FLAGS "U"
END
NUMBER F_CHECK 2
BEGIN
PROMPT 12 13 ""
FLAGS "UZ"
VALIDATE CHECK_IBAN_FUNC F_IBAN F_STATO F_CHECK F_BBAN F_CIN F_ABI F_CAB F_CONTO -1 0
END
STRINGA F_CIN 1
BEGIN
PROMPT 18 13 ""
FLAGS "U"
VALIDATE CHECK_BBAN_FUNC F_BBAN F_CIN F_ABI F_CAB F_CONTO
END
NUMBER F_ABI 5 NUMBER F_ABI 5
BEGIN BEGIN
PROMPT 2 10 "Banca d'appoggio " PROMPT 21 13 "ABI "
FIELD CODABI
FLAGS "Z" FLAGS "Z"
FIELD S4[1,5] USE %BAN SELECT CODTAB ?= "?????"
INPUT CODTAB F_ABI
DISPLAY "Codice ABI" CODTAB[1,5]
DISPLAY "Denominazione@50" S0
OUTPUT F_ABI CODTAB[1,5]
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END WARNING "Codice ABI assente"
FIELD S4[1,5]
END
NUMBER F_CAB 5 NUMBER F_CAB 5
BEGIN BEGIN
PROMPT 28 10 "" PROMPT 36 13 "CAB "
FLAGS "Z" FLAGS "Z"
USE LF_CFBAN USE %BAN KEY 1 SELECT CODTAB ?= "??????????"
INPUT TIPOCF "C" INPUT CODTAB[1,5] F_ABI
INPUT CODCF F_CODCF SELECT INPUT CODTAB[6,10] F_CAB
INPUT TIPOBAN "V" DISPLAY "Codice ABI" CODTAB[1,5]
DISPLAY "ABI@5" ABI DISPLAY "Codice CAB" CODTAB[6,10]
DISPLAY "CAB@5" CAB DISPLAY "Denominazione@50" S0
DISPLAY "IBAN@50" IBAN OUTPUT F_ABI CODTAB[1,5]
OUTPUT F_ABI ABI OUTPUT F_CAB CODTAB[6,10]
OUTPUT F_CAB CAB CHECKTYPE REQUIRED
OUTPUT F_IBAN IBAN WARNING "Banca assente"
CHECKTYPE SEARCH
FIELD S4[6,10] FIELD S4[6,10]
END END
STRING F_IBAN 34 STRING F_IBAN 34
BEGIN BEGIN
PROMPT 38 10 "IBAN " PROMPT 2 60 ""
FLAGS "D" FLAGS "DG"
FIELD S1 FIELD S1
END END
STRINGA F_BBAN 30
BEGIN
PROMPT 2 14 "BBAN "
FLAGS "UH"
END
STRING F_CONTO 12
BEGIN
PROMPT 2 14 "Conto "
VALIDATE CHECK_BBAN_FUNC F_BBAN F_CIN F_ABI F_CAB F_CONTO
FLAGS "UZ"
END
ENDPAGE ENDPAGE