6ac7b50cda
Files correlati : agalib Ricompilazione Demo : [ ] Commento : Aggiunto supporto per chiavi software SSA Aggiunto supporto per ricerche alternative con prefisso % git-svn-id: svn://10.65.10.50/branches/R_10_00@22582 c028cbd2-c16b-5b4b-a496-9718f37d4682
1157 lines
27 KiB
C++
Executable File
1157 lines
27 KiB
C++
Executable File
#include <diction.h>
|
||
#include <expr.h>
|
||
#include <mask.h>
|
||
#include <recarray.h>
|
||
#include <validate.h>
|
||
#include <defmask.h>
|
||
|
||
#include <comuni.h>
|
||
#include <nditte.h>
|
||
|
||
typedef bool (*VAL_FUNC)(TMask_field&, KEY k);
|
||
HIDDEN const TString_array* _parms;
|
||
|
||
HIDDEN int get_val_param_count()
|
||
{ return _parms->items(); }
|
||
|
||
HIDDEN const TString& get_val_param(int i)
|
||
{
|
||
const TString* str = (const TString*)_parms->objptr(i);
|
||
return str ? *str : EMPTY_STRING;
|
||
}
|
||
|
||
HIDDEN int get_int_val_param(int i)
|
||
{ return atoi(get_val_param(i)); }
|
||
|
||
HIDDEN const TString& get_fld_val_param(const TMask_field& f, int i)
|
||
{
|
||
const TString & id = get_val_param(i);
|
||
return f.evaluate_field(id);
|
||
}
|
||
|
||
HIDDEN bool _expr_val(TMask_field& f, KEY)
|
||
{
|
||
const TMask& m = f.mask();
|
||
const TTypeexp type = get_int_val_param(0) == 0 ? _numexpr : _strexpr;
|
||
TExpression e(get_val_param(1), type);
|
||
|
||
for (int i = 0; i < e.numvar(); i++)
|
||
{
|
||
const char* s = e.varname(i);
|
||
|
||
if (s[0] != '#')
|
||
{
|
||
TString err; err << TR("Le variabili devono cominciare con #") << ": " << s << '\n' << e;
|
||
return f.error_box((const char*)err);
|
||
}
|
||
if (type == _numexpr)
|
||
{
|
||
const real r = f.evaluate_field(s);
|
||
e.setvar(i, r);
|
||
}
|
||
else
|
||
e.setvar(i, f.evaluate_field(s));
|
||
}
|
||
return bool(e);
|
||
}
|
||
|
||
HIDDEN bool _emptycopy_val(TMask_field& f, KEY)
|
||
{
|
||
if (f.empty())
|
||
{
|
||
const TString& val = get_fld_val_param(f, 0);
|
||
if (val.not_empty())
|
||
{
|
||
f.set(val);
|
||
f.on_hit();
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
HIDDEN bool check_pi_estera(const TString& st, const TString& paiva)
|
||
{
|
||
const int len = paiva.len();
|
||
const char* p = paiva;
|
||
const bool nat = real::is_natural(p);
|
||
|
||
if (st == "AT")
|
||
return len == 9 && p[0] =='U' && real::is_natural(p+1);
|
||
if (st == "BE")
|
||
return len == 10 && p[0] =='0' && nat;
|
||
if (st == "DE")
|
||
return len == 9 && nat;
|
||
if (st == "DK")
|
||
return len == 8 && nat;
|
||
if (st == "EL")
|
||
return len == 9 && nat;
|
||
if (st == "ES")
|
||
return len == 9 && !(isdigit(p[0] && isdigit(p[8])) && real::is_natural(paiva.mid(1,7)));
|
||
if (st == "IT")
|
||
return len == 11 && nat; // Ridondante ma documentante
|
||
if (st == "HU")
|
||
return len == 8 && nat;
|
||
if (st == "FI")
|
||
return len == 8 && nat;
|
||
if (st == "FR")
|
||
return len == 11 && real::is_natural(p+2);
|
||
if (st == "GB")
|
||
return (len == 5 && real::is_natural(p+2)) || ((len == 9 || len == 12) && nat);
|
||
if (st == "IE")
|
||
return len == 8;
|
||
if (st == "LU")
|
||
return len == 8 && nat;
|
||
if (st == "NL")
|
||
return len == 12 && paiva[9] == 'B' && real::is_natural(paiva.left(9));
|
||
if (st == "PL")
|
||
return len == 10 && nat;
|
||
if (st == "PT")
|
||
return len == 9 && nat;
|
||
if (st == "RO")
|
||
return len >= 2 && len <= 10 && nat;
|
||
if (st == "SE")
|
||
return len == 12 && nat;
|
||
if (st == "SM")
|
||
return len == 5;
|
||
return paiva.full(); // Gli stati ignoti hanno sempre lunghezza corretta!
|
||
}
|
||
|
||
// @doc EXTERNAL
|
||
|
||
// @func Controlla se la Partita IVA assume un valore valido
|
||
//
|
||
// @rdesc Ritorna i seguenti valori:
|
||
//
|
||
// @flag true | Se il valore della Partita IVA assume un valore corretto
|
||
// @flag false | Se il valore della Partita IVA non puo' essere valido
|
||
bool pi_check(
|
||
const char* st, // @parm Stato di assegnazione della Partita IVA
|
||
const char* paiva) // @parm Codice della Partita IVA da controllare
|
||
{
|
||
const TFixed_string stato(st);
|
||
const TFixed_string pi(paiva);
|
||
|
||
if (pi.blank())
|
||
return true;
|
||
|
||
bool ok = true; // Assumiamo ottimisticamente che tutto va be'
|
||
|
||
if (stato.blank() || stato == "IT")
|
||
{
|
||
// Testa partita iva italiana
|
||
ok = pi.len() == 11 && real::is_natural(pi);
|
||
if (ok)
|
||
{
|
||
int tot = 0, y;
|
||
for (int i = 0; i <= 9; i++)
|
||
{
|
||
if ((i + 1) & 0x0001)
|
||
tot += (pi[i] - '0');
|
||
else
|
||
{
|
||
y = (pi[i] - '0') * 2;
|
||
if (y >= 10)
|
||
{
|
||
tot += (y / 10);
|
||
y = y % 10;
|
||
}
|
||
tot += y;
|
||
}
|
||
}
|
||
y = 10 - (tot % 10);
|
||
if (y == 10) y = 0;
|
||
ok = (pi[10] == (y + '0'));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ok = check_pi_estera(stato, pi);
|
||
}
|
||
|
||
return ok;
|
||
}
|
||
|
||
|
||
// Controlla la partita iva se e' non vuota ed italiana
|
||
HIDDEN bool _pi_val(TMask_field& f, KEY)
|
||
{
|
||
const TMask& m = f.mask();
|
||
if (m.query_mode())
|
||
return true;
|
||
|
||
const TString& stato = m.get(get_int_val_param(0));
|
||
const TString& pi = f.get();
|
||
bool ok = pi_check (stato, pi);
|
||
if (!ok)
|
||
{
|
||
if (f.dirty())
|
||
{
|
||
bool len_error = true;
|
||
if (stato.blank() || stato == "IT")
|
||
len_error = pi.len() != 11;
|
||
TString msg = len_error ? TR("Lunghezza partita IVA errata") : TR("Partita IVA errata");
|
||
msg << ": " << TR("proseguire ugualmente?");
|
||
ok = f.yesno_box(msg);
|
||
if (ok) f.set_dirty(false);
|
||
}
|
||
else ok = true; // Era gia' errata e la ho accettata
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
|
||
HIDDEN bool __cf_check (const char* codcf)
|
||
{
|
||
const TFixed_string cf(codcf);
|
||
if (cf.len() != 16)
|
||
return false;
|
||
const TFixed_string tab("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
|
||
|
||
int tot = 0, y;
|
||
|
||
byte val[36][2];
|
||
|
||
val[0][0] = 0; val[0][1] = 1;
|
||
val[1][0] = 1; val[1][1] = 0;
|
||
val[2][0] = 2; val[2][1] = 5;
|
||
val[3][0] = 3; val[3][1] = 7;
|
||
val[4][0] = 4; val[4][1] = 9;
|
||
val[5][0] = 5; val[5][1] = 13;
|
||
val[6][0] = 6; val[6][1] = 15;
|
||
val[7][0] = 7; val[7][1] = 17;
|
||
val[8][0] = 8; val[8][1] = 19;
|
||
val[9][0] = 9; val[9][1] = 21;
|
||
val[10][0] = 10; val[10][1] = 2;
|
||
val[11][0] = 11; val[11][1] = 4;
|
||
val[12][0] = 12; val[12][1] = 18;
|
||
val[13][0] = 13; val[13][1] = 20;
|
||
val[14][0] = 14; val[14][1] = 11;
|
||
val[15][0] = 15; val[15][1] = 3;
|
||
val[16][0] = 16; val[16][1] = 6;
|
||
val[17][0] = 17; val[17][1] = 8;
|
||
val[18][0] = 18; val[18][1] = 12;
|
||
val[19][0] = 19; val[19][1] = 14;
|
||
val[20][0] = 20; val[20][1] = 16;
|
||
val[21][0] = 21; val[21][1] = 10;
|
||
val[22][0] = 22; val[22][1] = 22;
|
||
val[23][0] = 23; val[23][1] = 25;
|
||
val[24][0] = 24; val[24][1] = 24;
|
||
val[25][0] = 25; val[25][1] = 23;
|
||
val[26][0] = 0; val[26][1] = 1;
|
||
val[27][0] = 1; val[27][1] = 0;
|
||
val[28][0] = 2; val[28][1] = 5;
|
||
val[29][0] = 3; val[29][1] = 7;
|
||
val[30][0] = 4; val[30][1] = 9;
|
||
val[31][0] = 5; val[31][1] = 13;
|
||
val[32][0] = 6; val[32][1] = 15;
|
||
val[33][0] = 7; val[33][1] = 17;
|
||
val[34][0] = 8; val[34][1] = 19;
|
||
val[35][0] = 9; val[35][1] = 21;
|
||
|
||
for (int i = 0; i <= 14; i++)
|
||
{
|
||
y = tab.find(cf[i]);
|
||
if (y >= 0) tot += val[y][(i + 1) & 0x1];
|
||
}
|
||
const bool ok = (cf[15] == (tot % 26) + 'A');
|
||
|
||
return ok;
|
||
}
|
||
|
||
// @doc EXTERNAL
|
||
|
||
// @func Controlla se il Codice Fiscale assume un valore valido
|
||
//
|
||
// @rdesc Ritorna i seguenti valori:
|
||
//
|
||
// @flag true | Se il valore del Codice Fiscale assume un valore corretto
|
||
// @flag false | Se il valore del Codice Fiscale non puo' essere valido
|
||
|
||
bool cf_check (
|
||
const char* stato, // @parm Stato di assegnazione del Codice Fiscale
|
||
const char* codcf) // @parm Codice Fiscale da controllare
|
||
{
|
||
bool ok = true;
|
||
if (codcf && *codcf)
|
||
{
|
||
const TFixed_string cf = codcf;
|
||
ok = (cf.len() == 11 && isdigit(cf[0])) ? pi_check(stato, cf) : __cf_check(cf);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
HIDDEN bool _cf_val(TMask_field& f, KEY key)
|
||
{
|
||
if (f.mask().query_mode())
|
||
return true;
|
||
|
||
const TString& cf = f.get();
|
||
bool ok = true;
|
||
|
||
if (cf.empty()) return true;
|
||
if (cf.len() == 11 && isdigit(cf[0]))
|
||
{
|
||
const TString& stato = f.mask().get(atoi(get_val_param(0)));
|
||
if (stato.full() && stato != "IT")
|
||
return true;
|
||
ok = pi_check (stato, cf);
|
||
}
|
||
else
|
||
ok = __cf_check(cf);
|
||
if (!ok)
|
||
{
|
||
if(f.dirty())
|
||
{
|
||
ok = f.yesno_box(TR("Codice fiscale errato: lo accetto ugualmente?"));
|
||
if (ok) f.set_dirty(false);
|
||
}
|
||
else
|
||
ok = true; // Era gia' errato al caricamento quindi lo accetto
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
|
||
HIDDEN bool _xt_pi_val(TMask_field& f, KEY key)
|
||
{
|
||
TMask& m = f.mask();
|
||
if (m.query_mode())
|
||
return true;
|
||
|
||
TString16 value = f.get();
|
||
if (value.empty())
|
||
return f.error_box(TR("Partita IVA obbligatoria"));
|
||
|
||
if (!_pi_val(f, key))
|
||
return true;
|
||
|
||
const TString& stato = get_fld_val_param(f, 0);
|
||
if (stato.blank() || stato == "IT")
|
||
{
|
||
TLocalisamfile c(LF_COMUNI);
|
||
const int pi = atoi(value.mid(7,3));
|
||
for (int i = 1 ; i < 3; i++)
|
||
{
|
||
const TString& com = get_fld_val_param(f, i); // Comune residenza fiscale e residenza
|
||
if (com.full())
|
||
{
|
||
c.zero();
|
||
c.put("COM", com);
|
||
if (c.read() == NOERR)
|
||
{
|
||
const int s1 = c.get_int(COM_UFFIVA1);
|
||
const int s2 = c.get_int(COM_UFFIVA2);
|
||
const int s3 = c.get_int(COM_UFFIVA3);
|
||
if (pi != s1 && pi != s2 && pi != s3)
|
||
{
|
||
TString16 ui; ui.format("%03d", s1);
|
||
if (f.yesno_box(FR("Ufficio IVA della partita IVA non congruente: correggere in %s?"),
|
||
(const char*)ui))
|
||
{
|
||
value.overwrite(ui, 7);
|
||
f.set(value);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
HIDDEN bool _xtz_pi_val(TMask_field& f, KEY key)
|
||
{
|
||
return f.empty() || _xt_pi_val(f, key);
|
||
}
|
||
|
||
HIDDEN bool _xt_cf_val(TMask_field& f, KEY key)
|
||
{
|
||
if (f.mask().query_mode())
|
||
return true;
|
||
|
||
TString16 cf = f.get();
|
||
if (cf.blank())
|
||
return true;
|
||
|
||
if (!_cf_val(f, key))
|
||
return false;
|
||
|
||
if (cf.len() == 11 && real::is_natural(cf))
|
||
{
|
||
// if (!_xt_pi_val(f, key)) return false;
|
||
// TString16 stato(f.mask().get(atoi(get_val_param(0))));
|
||
// if ((stato.not_empty()) && (stato != "IT")) return true;
|
||
return true;
|
||
}
|
||
|
||
bool passed = __cf_check(cf);
|
||
if (!passed) return true;
|
||
|
||
TMask& m = f.mask();
|
||
|
||
TMask_field& fld_sex = m.field(get_int_val_param(1));
|
||
TMask_field& fld_dat = m.field(get_int_val_param(2));
|
||
TMask_field& fld_com = m.field(get_int_val_param(3));
|
||
|
||
const char sesso = fld_sex.get()[0];
|
||
TString16 data = fld_dat.get();
|
||
TString4 com = fld_com.get();
|
||
|
||
TString16 wm("LMNPQRSTUV");
|
||
int p;
|
||
if ((p = wm.find(cf[ 6])) >= 0) cf[ 6] = '0' + p;
|
||
if ((p = wm.find(cf[ 7])) >= 0) cf[ 7] = '0' + p;
|
||
if ((p = wm.find(cf[ 9])) >= 0) cf[ 9] = '0' + p;
|
||
if ((p = wm.find(cf[10])) >= 0) cf[10] = '0' + p;
|
||
if ((p = wm.find(cf[12])) >= 0) cf[12] = '0' + p;
|
||
if ((p = wm.find(cf[13])) >= 0) cf[13] = '0' + p;
|
||
if ((p = wm.find(cf[14])) >= 0) cf[14] = '0' + p;
|
||
int gn = atoi(cf.mid(9,2));
|
||
|
||
if ((sesso == 'F' && gn < 40) || (sesso == 'M' && gn > 40))
|
||
{
|
||
if (data.full()) // Non dare segnalazioni inutili sul sesso se manca la data di nascita
|
||
passed = fld_sex.yesno_box(TR("Sesso incongruente col codice fiscale:\ncorrezione automatica?"));
|
||
if (passed) fld_sex.set(sesso == 'M' ? "F" : "M");
|
||
else return true;
|
||
}
|
||
|
||
if (gn > 40) gn -= 40; // Aggiusta giorno di nascita delle donne
|
||
|
||
// Controllo data di nascita
|
||
wm = "ABCDEHLMPRST";
|
||
if (data.full())
|
||
{
|
||
const TDate d(data);
|
||
int err = 0;
|
||
if ((d.year() % 100) != atoi(cf.mid(6, 2)))
|
||
err = 1;
|
||
if (wm[d.month() - 1] != cf[8])
|
||
err = 2;
|
||
if (d.day() != gn)
|
||
err = 3;
|
||
if (err != 0)
|
||
{
|
||
const char* const what = err==1 ? TR("Anno") : (err==2 ? TR("Mese") : TR("Giorno"));
|
||
passed = fld_dat.yesno_box(FR("%s di nascita incongruente col codice fiscale:\ncorrezione automatica?"), what);
|
||
if (passed)
|
||
data.cut(0);
|
||
else return true;
|
||
}
|
||
}
|
||
|
||
if (data.blank())
|
||
{
|
||
const int mn = wm.find(cf[8]) + 1;
|
||
if (mn > 0)
|
||
{
|
||
int anno = atoi(cf.mid(6, 2));
|
||
anno += anno < 10 ? 2000 : 1900;
|
||
const TDate d(gn, mn, anno);
|
||
fld_dat.set(d.string());
|
||
}
|
||
}
|
||
|
||
// Controllo del comune di nascita
|
||
const char* const codcom = cf.mid(11, 4);
|
||
if (com.full() && com != codcom)
|
||
{
|
||
passed = fld_com.yesno_box(TR("Comune incongruente col codice fiscale:\ncorrezione automatica?"));
|
||
if (passed) com.cut(0);
|
||
else return true;
|
||
}
|
||
if (com.empty())
|
||
{
|
||
fld_com.set(codcom);
|
||
fld_com.on_key(K_TAB);
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
HIDDEN bool _xtz_cf_val(TMask_field& f, KEY key)
|
||
{
|
||
return f.empty() || _xt_cf_val(f, key);
|
||
}
|
||
|
||
HIDDEN bool _notempty_val(TMask_field& f, KEY)
|
||
{
|
||
return f.mask().query_mode() || !f.empty();
|
||
}
|
||
|
||
HIDDEN bool _date_cmp(TMask_field& f, KEY)
|
||
{
|
||
const TString& s = f.get();
|
||
if (s.empty())
|
||
return true;
|
||
|
||
const TDate d0(s), d1(get_fld_val_param(f, 1));
|
||
const TFixed_string op(get_val_param(0));
|
||
|
||
if (op == "==") return d0 == d1;
|
||
if (op == "!=") return d0 != d1;
|
||
if (op == ">") return d0 > d1;
|
||
if (op == "<") return d0 < d1;
|
||
if (op == ">=") return d0 >= d1;
|
||
if (op == "<=") return d0 <= d1;
|
||
|
||
#ifdef DBG
|
||
f.error_box("Bad date operator '%s' in field %d", (const char*) op, f.dlg());
|
||
#endif
|
||
|
||
return false;
|
||
}
|
||
|
||
HIDDEN bool _fixlen_val(TMask_field& f, KEY)
|
||
{
|
||
if (f.empty())
|
||
return true;
|
||
|
||
const TString& s = f.get();
|
||
const int length = get_int_val_param(0);
|
||
const bool ok = s.len() == length;
|
||
if (!ok)
|
||
f.error_box(FR("La lunghezza del campo deve essere %d caratteri"), length);
|
||
return ok;
|
||
}
|
||
|
||
HIDDEN bool _mtcheck_val(TMask_field& f, KEY)
|
||
{
|
||
const int month = atoi(f.get());
|
||
if (month < 1 || month > 13)
|
||
return false;
|
||
/*
|
||
TLocalisamfile d(LF_NDITTE);
|
||
d.put(NDT_CODDITTA, prefix().get_codditta());
|
||
if (d.read() != NOERR)
|
||
return true;
|
||
if (d.get_char(NDT_FREQVIVA) == 'M')
|
||
return true;
|
||
return month == 13 || (month % 3) == 0;
|
||
*/
|
||
if (month == 13 || (month % 3) == 0)
|
||
return true;
|
||
const TRectype& ndt = cache().get(LF_NDITTE, prefix().get_codditta());
|
||
return ndt.get_char(NDT_FREQVIVA) == 'M';
|
||
}
|
||
|
||
|
||
HIDDEN bool _reqif_val(TMask_field& f, KEY k)
|
||
{
|
||
if (k == K_ENTER && f.empty())
|
||
{
|
||
const int nparms = get_val_param_count();
|
||
|
||
for (int i = 0; i < nparms; i++)
|
||
{
|
||
const TString& fld = get_fld_val_param(f, i);
|
||
if (fld.full())
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
HIDDEN bool _autoexit_val(TMask_field& f, KEY key)
|
||
{
|
||
TMask& m = f.mask();
|
||
|
||
if (!m.query_mode() || key == K_ENTER)
|
||
return true;
|
||
|
||
const int nparms = get_val_param_count();
|
||
bool one_not_empty = false;
|
||
for (int i = nparms-1; i >= 0; i--)
|
||
{
|
||
const short id = get_int_val_param(i);
|
||
const int pos = m.id2pos(id);
|
||
if (pos >= 0)
|
||
{
|
||
const TMask_field& c = m.fld(pos);
|
||
if (c.empty())
|
||
{
|
||
if (c.check_type() != CHECK_NONE || one_not_empty)
|
||
return true;
|
||
}
|
||
else
|
||
one_not_empty = true;
|
||
}
|
||
}
|
||
|
||
if (one_not_empty)
|
||
m.stop_run(K_AUTO_ENTER);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
HIDDEN bool _numcalc_val(TMask_field& f, KEY k)
|
||
{
|
||
if (k != K_TAB) return true;
|
||
TExpression e(get_val_param(0), _numexpr);
|
||
|
||
for (int i = 0; i < e.numvar(); i++)
|
||
{
|
||
const char* s = e.varname(i);
|
||
|
||
if (s[0] != '#')
|
||
{
|
||
TString err; err << "Can't load variable " << s << " in " << e;
|
||
return f.error_box((const char*)err);
|
||
}
|
||
e.setvar(i, f.evaluate_field(s));
|
||
}
|
||
const TString& s = e.as_string();
|
||
f.set(s);
|
||
return true;
|
||
}
|
||
|
||
|
||
HIDDEN bool _strcalc_val(TMask_field& f, KEY k)
|
||
{
|
||
if (k != K_TAB) return true;
|
||
TExpression e(get_val_param(0), _strexpr);
|
||
|
||
for (int i = 0 ; i < e.numvar(); i++)
|
||
{
|
||
const char* s = e.varname(i);
|
||
if (s[0] != '#')
|
||
{
|
||
TString err; err << "Can't load variable " << s << " in " << e;
|
||
return f.error_box((const char*)err);
|
||
}
|
||
e.setvar(i, f.evaluate_field(s));
|
||
}
|
||
const TString& s = e.as_string();
|
||
f.set(s);
|
||
return true;
|
||
}
|
||
|
||
|
||
HIDDEN bool _onereq_val(TMask_field& f, KEY k)
|
||
{
|
||
if (k != K_ENTER || f.mask().mode() == MODE_QUERY)
|
||
return true;
|
||
|
||
const int nparms = get_val_param_count();
|
||
|
||
for (int i = 0; i < nparms ; i++)
|
||
{
|
||
const TString& s = get_fld_val_param(f, i);
|
||
if (s.full())
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
HIDDEN bool _chkfld_val(TMask_field& f, KEY k)
|
||
{
|
||
if (f.to_check(k))
|
||
{
|
||
const int fldid = get_int_val_param(0);
|
||
|
||
if (fldid == THIS_FIELD)
|
||
{
|
||
if (!f.required() && f.get().empty())
|
||
return true;
|
||
else
|
||
return f.check();
|
||
}
|
||
|
||
TMask_field & chkfld = f.mask().field(fldid);
|
||
|
||
chkfld.set(f.get());
|
||
return chkfld.check();
|
||
}
|
||
return true;
|
||
}
|
||
|
||
HIDDEN bool _filename_val(TMask_field& f, KEY)
|
||
{
|
||
const TFilename fn(f.get());
|
||
return fn.blank() || fn.ok();
|
||
}
|
||
|
||
HIDDEN bool _zerofill_val(TMask_field& f, KEY k)
|
||
{
|
||
if (f.to_check(k))
|
||
{
|
||
const int columns = get_int_val_param(0);
|
||
const TString& val = f.get();
|
||
if (val.len() < columns && real::is_natural(val))
|
||
{
|
||
TString z(val);
|
||
z.right_just(columns, '0');
|
||
f.set(z);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
HIDDEN bool _alpha_val(TMask_field& f, KEY k)
|
||
{
|
||
if (f.to_check(k))
|
||
{
|
||
const TString& s = f.get();
|
||
for (int i = 0; s[i]; i++)
|
||
if (!isalpha(s[i]))
|
||
return f.error_box(TR("Sono ammessi solo caratteri alfabetici"));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
HIDDEN bool _not_empty_chkfld_val(TMask_field& f, KEY k)
|
||
{
|
||
bool ok = true;
|
||
if (f.to_check(k,true) && f.get().not_empty())
|
||
{
|
||
TBrowse * b = ((TEdit_field&)f).browse();
|
||
if (b != NULL) ok = b->check(k == K_TAB ? RUNNING_CHECK : FINAL_CHECK);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
HIDDEN bool _sconto_val(TMask_field& f, KEY key)
|
||
{
|
||
bool ok = true;
|
||
|
||
if ( f.to_check( key ) )
|
||
{
|
||
const TString80 work(f.get());
|
||
TString80 goodexp;
|
||
// Elimina gli spazi molesti
|
||
// work.strip_spaces( );
|
||
if (work.not_empty())
|
||
{
|
||
TString80 num;
|
||
bool dec = false; // Flag che indica se si attende l'inizio di un numero
|
||
bool startnum = true; // Flag che indica se siamo all'inizio di un numero
|
||
int errorchar = ' ';
|
||
|
||
// Flag che indica se sono nella parte decimale di un numero
|
||
for (const char * s = (const char *)work; *s && errorchar == ' '; s++)
|
||
{
|
||
const char c = *s;
|
||
switch(c)
|
||
{
|
||
case '+':
|
||
case '-':
|
||
// Se ero in in numero ...
|
||
if( !startnum )
|
||
goodexp << num;
|
||
// Inizia il nuovo numero
|
||
num = (c == '-') ? "-" : "+";
|
||
startnum = true;
|
||
dec = false;
|
||
break;
|
||
case '0':
|
||
case '1':
|
||
case '2':
|
||
case '3':
|
||
case '4':
|
||
case '5':
|
||
case '6':
|
||
case '7':
|
||
case '8':
|
||
case '9':
|
||
num << c;
|
||
startnum = false;
|
||
break;
|
||
case '.':
|
||
case ',':
|
||
if(!dec)
|
||
{
|
||
if( startnum )
|
||
num << '0'; // Se occorreva un numero ci metto lo 0
|
||
num << '.'; // Interpreto la virgola come punto
|
||
dec = true;
|
||
startnum = true;
|
||
}
|
||
else
|
||
errorchar = c; // Se siamo gi` nella parte decimale segnala un errore
|
||
break;
|
||
case ' ':
|
||
break;
|
||
default:
|
||
errorchar = c;
|
||
break;
|
||
}
|
||
}
|
||
// Controlla la validit<69>
|
||
ok = errorchar == ' ';
|
||
|
||
if (ok)
|
||
{
|
||
goodexp << num; // Assegna la nuova espressione formattata bene
|
||
f.set(goodexp);
|
||
}
|
||
else
|
||
f.error_box(FR("Espressione di sconto non valida. Errore sul carattere %c"), errorchar);
|
||
}
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
HIDDEN bool _ora_val(TMask_field& f, KEY key)
|
||
{
|
||
if ( f.to_check( key ) )
|
||
{
|
||
TString8 ora = f.get();
|
||
if ( ora.full( ) || f.required( ) )
|
||
{
|
||
if ( isdigit( ora[ 0 ] ) )
|
||
{
|
||
if ( ora[ 2 ] != ':' )
|
||
{
|
||
if ( ora.len( ) > 4 )
|
||
ora.overwrite( ":", 2 );
|
||
else
|
||
ora.insert( ":", 2 );
|
||
}
|
||
}
|
||
bool ok = ((isdigit(ora[0]))&&(isdigit(ora[1]))&&(isdigit(ora[3]))&&(isdigit(ora[4])));
|
||
ok &= ((atoi(&(ora[0]))<24)&&(atoi(&(ora[3]))<60));
|
||
if ( ok )
|
||
f.set( ora );
|
||
else
|
||
return f.error_box(TR("Ora errata o formato non valido"));
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
int iban_check(const TString& b, TString& msg)
|
||
{
|
||
if (b.len() < 5)
|
||
{
|
||
msg = TR("Lunghezza inferiore a 5 caratteri");
|
||
return 2;
|
||
}
|
||
if (!isalpha(b[0]) || !isalpha(b[1]))
|
||
{
|
||
msg.format(FR("I primi due caratteri (%s) devono essere alfabetici"), (const char*)b.left(2));
|
||
return 3;
|
||
}
|
||
if (!isdigit(b[2]) || !isdigit(b[3]))
|
||
{
|
||
msg.format(FR("I caratteri 3 e 4 (%s) devono essere numerici"), (const char*)b.mid(2,2));
|
||
return 4;
|
||
}
|
||
|
||
TString80 s;
|
||
s << b.mid(4) << b.left(4);
|
||
|
||
int r = 0;
|
||
for (int i = 0; s[i]; i++)
|
||
{
|
||
const char c = s[i];
|
||
if (c >= '0' && c <= '9')
|
||
{
|
||
const int k = c - '0';
|
||
r = (10 * r + k) % 97;
|
||
} else
|
||
if (c >= 'A' && c <= 'Z')
|
||
{
|
||
const int k = c - 'A' + 10;
|
||
r = (100 * r + k) % 97;
|
||
}
|
||
else
|
||
{
|
||
msg.format(FR("Carattere non ammesso: '%c'"), c);
|
||
return 5;
|
||
}
|
||
}
|
||
|
||
if (r != 1)
|
||
{
|
||
msg = TR("Codice di controllo errato");
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int bban_check(const TString& b, TString& msg)
|
||
{
|
||
const unsigned char dispari[26] = { 1, 0, 5, 7, 9, 13, 15, 17, 19, 21, 2, 4, 18,
|
||
20, 11, 3, 6, 8, 12, 14, 16, 10, 22, 25, 24, 23 };
|
||
if (b.len() != 23)
|
||
{
|
||
msg = TR("Lunghezza diversa da 23 caratteri");
|
||
return 2;
|
||
}
|
||
if (b[0] < 'A' || b[0] > 'Z')
|
||
{
|
||
msg.format(FR("Il CIN deve essere una lettera maiuscola: '%c'"), b[0]);
|
||
return 2;
|
||
}
|
||
for (int a = 1; a <= 10; a++)
|
||
{
|
||
if (!isdigit(b[a]))
|
||
{
|
||
msg = TR("ABI e CAB devono essere numerici");
|
||
return 3;
|
||
}
|
||
}
|
||
|
||
int s = 0, kcin = 0;
|
||
for (int i = 0; b[i]; i++)
|
||
{
|
||
const char c = b[i];
|
||
int k = 0;
|
||
if (isdigit(c))
|
||
{
|
||
k = c - '0';
|
||
} else
|
||
if (c >= 'A' && c <= 'Z')
|
||
{
|
||
k = c - 'A';
|
||
}
|
||
else
|
||
{
|
||
msg.format(FR("Carattere non ammesso: '%c'"), c);
|
||
return 4;
|
||
}
|
||
if (i == 0)
|
||
kcin = k;
|
||
else
|
||
{
|
||
if (i & 1) // dispari
|
||
s += dispari[k];
|
||
else
|
||
s += k;
|
||
}
|
||
}
|
||
|
||
if (s % 26 != kcin)
|
||
{
|
||
msg.format(TR("Codice di controlo (CIN) errato"));
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
HIDDEN bool _iban_val(TMask_field& f, KEY key)
|
||
{
|
||
bool ok = true;
|
||
|
||
if (key == K_TAB || key == K_ENTER)
|
||
{
|
||
TMask& m = f.mask();
|
||
const int nparms = get_val_param_count();
|
||
CHECKD(nparms == 8, "IBAN_CHECK deve avere 8 parametri: ", nparms);
|
||
int id[8];
|
||
for (int i = 0; i < 8; i++)
|
||
id[i] = get_int_val_param(i);
|
||
|
||
|
||
if (f.dlg() == id[1]) // Campo Stato IBAN
|
||
{
|
||
if (key == K_TAB && !f.focusdirty())
|
||
{
|
||
const TString& iban = m.get(id[0]);
|
||
m.set(id[1], iban.left(2));
|
||
m.set(id[2], iban.mid(2,2));
|
||
m.set(id[3], iban.mid(4));
|
||
m.set(id[4], iban.mid(4,1));
|
||
m.set(id[5], iban.mid(5,5));
|
||
m.set(id[6], iban.mid(10,5));
|
||
m.set(id[7], iban.mid(15));
|
||
}
|
||
const bool italy = f.empty() || f.get() == "IT";
|
||
m.show(id[3], !italy);
|
||
m.show(id[4], italy);
|
||
m.show(id[5], italy);
|
||
m.show(id[6], italy);
|
||
m.show(id[7], italy);
|
||
}
|
||
if (f.dlg() == id[2])
|
||
{
|
||
TString4 stato = m.get(id[1]);
|
||
if (stato.empty())
|
||
stato = "IT";
|
||
const bool italy = stato=="IT";
|
||
const bool do_test = !m.field(id[italy ? 7 : 3]).empty(); // Faccio il test solo in presenza di conto corrente
|
||
TString80 iban;
|
||
if (do_test)
|
||
{
|
||
if (f.empty()) // Cifra di controllo vuota
|
||
{
|
||
TString msg;
|
||
TString80 iban;
|
||
iban << stato << "@@";
|
||
if (italy)
|
||
{
|
||
TEdit_field& cin = m.efield(id[4]);
|
||
TEdit_field& cc = m.efield(id[7]);
|
||
if (cin.empty() && !cc.empty())
|
||
{
|
||
cc.set_focusdirty();
|
||
cc.validate(K_TAB);
|
||
}
|
||
iban << m.get(id[4]) << m.get(id[5]) << m.get(id[6]) << m.get(id[7]);
|
||
}
|
||
else
|
||
iban << m.get(id[3]);
|
||
|
||
int err = 1;
|
||
for (int pp = 0; pp <= 99 && err == 1; pp++)
|
||
{
|
||
msg.format("%02d", pp);
|
||
iban.overwrite(msg, 2);
|
||
err = iban_check(iban, msg);
|
||
if (err == 0)
|
||
{
|
||
m.set(id[1], stato);
|
||
m.set(id[2], pp);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
iban << m.get(id[1]) << m.get(id[2]);
|
||
if (italy)
|
||
iban << m.get(id[4]) << m.get(id[5]) << m.get(id[6]) << m.get(id[7]);
|
||
else
|
||
iban << m.get(id[3]);
|
||
|
||
TString msg;
|
||
const int err = iban_check(iban, msg);
|
||
if (err != 0)
|
||
{
|
||
msg.insert(TR("Codice IBAN errato:\n"));
|
||
if (err > 1) // Errore grave
|
||
ok = error_box(msg);
|
||
else
|
||
{
|
||
msg << '\n' << TR("Si desidera continuare ugualmente?");
|
||
ok = yesno_box(msg);
|
||
}
|
||
}
|
||
}
|
||
if (key == K_ENTER)
|
||
{
|
||
if (!ok) iban.cut(0);
|
||
m.set(id[0], iban);
|
||
}
|
||
}
|
||
}
|
||
|
||
return ok;
|
||
}
|
||
|
||
HIDDEN bool _bban_val(TMask_field& f, KEY key)
|
||
{
|
||
bool ok = true;
|
||
|
||
if (!f.empty() && f.to_check(key))
|
||
{
|
||
TMask& m = f.mask();
|
||
const int nparms = get_val_param_count();
|
||
CHECKD(nparms == 5, "BBAN_CHECK deve avere 5 parametri: ", nparms);
|
||
int id[5];
|
||
for (int i = 0; i < 5; i++)
|
||
id[i] = get_int_val_param(i);
|
||
|
||
if (m.field(id[1]).empty()) // CIN vuoto
|
||
{
|
||
TString msg;
|
||
TString80 bban;
|
||
bban << "#" << m.get(id[2]) << m.get(id[3]) << m.get(id[4]);
|
||
int err = 1;
|
||
for (char cin = 'A'; cin <= 'Z' && err == 1; cin++)
|
||
{
|
||
bban[0] = cin;
|
||
err = bban_check(bban, msg);
|
||
if (err == 0)
|
||
{
|
||
m.set(id[1], bban.left(1));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if (f.dlg() == id[1] && key == K_ENTER)
|
||
{
|
||
TString80 bban;
|
||
for (int i = 1; i < 5; i++)
|
||
bban << m.get(id[i]);
|
||
if (bban.len() > 11)
|
||
{
|
||
TString msg;
|
||
const int err = bban_check(bban, msg);
|
||
if (err != 0)
|
||
{
|
||
msg.insert(TR("Codice BBAN errato:\n"));
|
||
if (err > 1) // Errore grave
|
||
ok = error_box(msg);
|
||
else
|
||
{
|
||
msg << '\n' << TR("Si desidera continuare ugualmente?");
|
||
ok = yesno_box(msg);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return ok;
|
||
}
|
||
|
||
#define MAX_FUNC 26
|
||
|
||
HIDDEN VAL_FUNC _global_val_func[MAX_FUNC] =
|
||
{
|
||
_expr_val, // 0
|
||
_emptycopy_val,
|
||
_pi_val,
|
||
_cf_val,
|
||
_notempty_val,
|
||
_date_cmp, // 5
|
||
_xt_pi_val,
|
||
_xt_cf_val,
|
||
_xtz_pi_val,
|
||
_xtz_cf_val,
|
||
_fixlen_val, // 10
|
||
_mtcheck_val,
|
||
_reqif_val,
|
||
_autoexit_val,
|
||
_numcalc_val,
|
||
_strcalc_val, // 15
|
||
_onereq_val,
|
||
_chkfld_val,
|
||
_filename_val,
|
||
_zerofill_val,
|
||
_alpha_val, // 20
|
||
_not_empty_chkfld_val,
|
||
_ora_val,
|
||
_sconto_val,
|
||
_iban_val,
|
||
_bban_val, // 25
|
||
};
|
||
|
||
// @doc INTERNAL
|
||
|
||
// @func Effettua i controlli sui campi di una maschera
|
||
//
|
||
// @rdesc Ritorna se il controllo ha avuto successo:
|
||
//
|
||
// @flag true | Il campo e' positivo al controllo
|
||
// @flag false | Il campo non ha i requisiti necessari per passare il controllo
|
||
bool validate(
|
||
int fn, // @parm Numero della funzione da effettuare
|
||
TMask_field& f, // @parm Identificatore del campo da controllare
|
||
KEY k, // @parm Codice del tasto premuto sul campo
|
||
const TString_array& parms) // @parm Array di parametri per effettuare il controllo
|
||
{
|
||
_parms = &parms;
|
||
return (fn >= 0 && fn < MAX_FUNC) ? _global_val_func[fn](f, k) : true;
|
||
}
|
||
|
||
|