root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib03a.cpp
alex ac4d0ed9e4 Patch level : XX 272 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Riportata la versione AGA 1.7 patch 272 sul main trunk


git-svn-id: svn://10.65.10.50/trunk@10283 c028cbd2-c16b-5b4b-a496-9718f37d4682
2002-05-31 10:35:40 +00:00

832 lines
21 KiB
C++
Executable File
Raw Blame History

#include <tabutil.h>
#include "velib.h"
#include "vepriv.h"
///////////////////////////////////////////////////////////
// Tipo documento
///////////////////////////////////////////////////////////
TAssoc_array TTipo_documento::_formule_documento;
TTipo_documento::TTipo_documento(const char* tipodoc)
: TRectype(LF_TABCOM), _tipocf('\0')
{
settab("TIP");
if (tipodoc && *tipodoc)
read(tipodoc);
}
TTipo_documento::TTipo_documento(const TRectype& rec)
: TRectype(rec), _tipocf('\0')
{
read_formule();
}
TTipo_documento::~TTipo_documento()
{
}
int TTipo_documento::read(const char* tipodoc)
{
*this = cache().get("%TIP", tipodoc);
int err = empty() ? _iskeynotfound : NOERR;
_formule.cut(0);
if (err == NOERR)
read_formule();
else
yesnofatal_box("Tipo documento errato: %s", tipodoc);
return err;
}
const char TTipo_documento::tipocf()
{
if (_tipocf == '\0')
{
TFilename pn = profile_name();
pn.ext("ini");
TConfig prof(pn);
_tipocf = prof.get_char("TIPOCF", "MAIN");
}
return _tipocf;
}
const TString & TTipo_documento::riferimento(const TDocumento & doc) const
{
static TString __rif;
__rif = get("S1");
int p = __rif.find('[');
while (p >= 0)
{
const int last = __rif.find(']');
const TString16 field_name(__rif.sub(p + 1, last));
const TFieldref field(field_name, LF_DOC);
if (last < 0)
__rif.cut(p);
else
{
const int len = __rif.len() - last;
for (int i = 0; i <= len; i++)
__rif[p + i] = __rif[last + i + 1];
}
if (field.file() == LF_DOC)
__rif.insert(field.read(doc), p);
else
{
TString16 key(doc.get(DOC_TIPOCF));
key << "|" << doc.get(DOC_CODCF);
const TRectype rec = cache().get(field.file(), key);
__rif.insert(field.read(rec), p);
}
p = __rif.find('[');
}
return __rif;
}
const TString_array& TTipo_documento::keys_descrs()
{
if (_keys_descrs.items() == 0)
{
TString16 var, tiporiga;
TFilename pn(profile_name());
pn.ext("ini");
TConfig prof(pn);
const int numtr = prof.get_int( "NTIPIRIGA", "RIGHE" );
TTipo_riga_documento tr;
_keys_descrs.add("");
_keys_descrs.add("");
TToken_string& k = (TToken_string&)_keys_descrs[0];
TToken_string& d = (TToken_string&)_keys_descrs[1];
if (numtr > 0)
{
for ( int i = 1; i <= numtr; i ++ )
{
var.format("%d", i);
tiporiga = prof.get(var, "RIGHE");
tr.read(tiporiga);
k.add(tr.codice());
d.add(tr.descrizione());
}
}
else
{
TTable tri("%TRI");
for (int err = tri.first(); err == NOERR; err = tri.next())
{
k.add(tri.get("CODTAB"));
d.add(tri.get("S0"));
}
}
}
return _keys_descrs;
}
const TString_array& TTipo_documento::sheet_columns()
{
if (_sheet_columns.items() == 0)
{
TString16 col;
TFilename pn(profile_name());
pn.ext("ini");
TConfig prof(pn, "SHEET");
int ncols = prof.get_int( "NCOLS", "SHEET" );
for (int i = 1; i <= ncols; i++)
{
col.format( "%d", i );
_sheet_columns.add(prof.get(col, "SHEET"));
}
}
return _sheet_columns;
}
const TString_array& TTipo_documento::handlers()
{
if (_handlers.items() == 0)
{
TString16 chiave;
TFilename pn = profile_name();
pn.ext("ini");
TConfig prof(pn);
int numhandler = prof.get_int( "NHANDLER", "HANDLERS" ); // prof
for (int i = 1; i <= numhandler; i ++ )
{
chiave.format("%d", i);
_handlers.add(prof.get(chiave, "HANDLERS"));
}
}
return _handlers;
}
void TTipo_documento::set_defaults(TMask& m)
{
const int items = _defaults.items();
if (items == 0) // Carica lo string_array con i defaults
{
TString16 chiave;
TFilename pn(profile_name());
pn.ext("ini");
TConfig prof(pn, "DEFAULT");
const int ndefaults = prof.get_int("NDEFAULTS");
for(int i = 1; i <= ndefaults; i++)
{
chiave.format("%d", i);
_defaults.add(prof.get(chiave));
}
}
for (int i = 0; i < items; i++) // Setta i campi della maschera
{
TToken_string& tt = (TToken_string&)_defaults[i];
const int ncampo = tt.get_int(0);
m.set(ncampo, tt.get(1), TRUE );
}
}
void TTipo_documento::read_formule()
{
TFilename profile(profile_name());
profile.ext("ini");
TConfig prof(profile, "MAIN");
prof.write_protect(); // Altrimenti non si distrugge!!!
_formule = prof.get("CAMPICALC", "MAIN");
const TString & calcoli = prof.get("CALCOLI", "MAIN");
if (calcoli == "*")
{
TTable frd("%FRD");
for (int err = frd.first(); err == NOERR; err = frd.next())
{
const TString & formula = frd.get("CODTAB");
if (_formule.find(formula) < 0)
_formule.add(formula);
}
}
else
_formule.add(calcoli);
_totale = prof.get("TOTALE", "MAIN");
if (_totale.empty())
_totale = "TOTDOC";
const TRectype& for_tot = cache().get("%FRD", _totale);
if (for_tot.empty())
_formule_documento.add(_totale, new TFormula_documento(_documento, _totale, "IMPONIBILI()+IMPOSTE()"), TRUE);
if (_formule.find(_totale) < 0)
_formule.add(_totale);
_totale_netto = "_";
_totale_netto << _totale;
_basesconto = prof.get("BASESCONTO");
if (_basesconto.empty())
_basesconto = "BASESCONTO";
const TRectype& for_bas = cache().get("%FRD", _basesconto);
if (for_bas.empty())
_formule_documento.add(_basesconto, new TFormula_documento(_documento, _basesconto, "SOMMA(\"IMPONIBILE()\", \"(TIPO() != 'S') && (TIPO() != 'C')\")"), TRUE);
if (_formule.find(_basesconto) < 0)
_formule.add(_basesconto);
_spese = prof.get("SPESE");
if (_spese.empty())
_spese = "SPESE";
const TRectype& for_spe = cache().get("%FRD", _spese);
if (for_spe.empty())
_formule_documento.add(_spese, new TFormula_documento(_documento, _spese, "SOMMA(\"IMPONIBILE()\", \"TIPO() == 'S'\")"), TRUE);
if (_formule.find(_spese) < 0)
_formule.add(_spese);
_totvalres = prof.get("TOTVALRES");
if (_totvalres.empty())
_totvalres = "TOTVALRES";
_totvalore = prof.get("TOTVALORE");
if (_totvalore.empty())
_totvalore = "TOTVALORE";
const TRectype& for_tvr = cache().get("%FRD", _totvalres);
if (for_tvr.empty())
_formule_documento.add(_totvalres, new TFormula_documento(_documento, _totvalres, "VALDOC(0)"), TRUE);
if (_formule.find(_totvalres) < 0)
_formule.add(_totvalres);
const TRectype& for_tva = cache().get("%FRD", _totvalore);
if (for_tva.empty())
_formule_documento.add(_totvalore, new TFormula_documento(_documento, _totvalore, "VALDOC(1)"), TRUE);
if (_formule.find(_totvalore) < 0)
_formule.add(_totvalore);
if (provvigioni())
{
TString80 campo(prof.get("TOTPROVV"));
if (campo.empty())
campo = "TOTPROVV";
const TRectype& frd = cache().get("%FRD", campo);
_totprovv = "_";
_totprovv << campo;
TString80 expr(frd.get("S1"));
if (expr.empty())
expr = "SOMMA(\"PROVV()\")";
_formule_documento.add(_totprovv, new TFormula_documento(_documento, _totprovv, expr, TRUE));
if (_formule.find(campo) < 0)
_formule.add(campo);
_formule.add(_totprovv);
_formule_documento.add(campo, new TFormula_documento(_documento, campo, "TOTPROVV()"), TRUE);
}
_totale_cont = prof.get("TOTALECONT", "MAIN");
_cnt_prezzi = prof.get_bool("CONTROLLO_PREZZI", "MAIN");
_field_prezzo = prof.get("PREZZO", "MAIN");
}
bool TTipo_documento::stato_with_mov_mag(const char stato) const
{
if (!mov_mag())
return FALSE;
const char stato_finale(stato_mov_finale());
if (stato_finale > ' ' && stato > stato_finale)
return FALSE;
const char stato_iniziale(stato_mov_iniziale());
return stato >= stato_iniziale;
}
TFormula_documento * TTipo_documento::succ_formula(bool restart)
{
if (restart)
_formule.restart();
TString formula = _formule.get();
while (formula.not_empty())
{
if (formula.blank())
formula = _formule.get();
else
break;
}
if (formula.not_empty())
{
char *expr = NULL;
const int p = formula.find('=');
if (p > 0)
{
expr = (char *) (const char *) formula + p;
*expr = '\0'; expr++;
}
TFormula_documento * o = (TFormula_documento*)_formule_documento.objptr(formula);
if (o == NULL)
{
o = new TFormula_documento(_documento, formula, expr);
_formule_documento.add(formula, o);
}
return o;
}
return NULL;
}
bool TTipo_documento::scarica_residuo() const
{
if (is_ordine() && !riporta_ordinato())
return TRUE;
return get_bool("B4");
}
///////////////////////////////////////////////////////////
// Espressione documento
///////////////////////////////////////////////////////////
TExpr_documento::TExpr_documento(const char* expression, TTypeexp type,
TDocumento * doc, TRiga_documento * row)
: TExpression(type), _doc(doc), _row(row)
{
if (!set(expression, type))
error_box("Wrong expression : '%s'", expression);
}
int TExpr_documento::parse_user_func(const char * name, int nparms) const
{
if (strcmp(name, "SOMMA") == 0)
return nparms > 0 || nparms < 3 ? _somma : -1;
if (strcmp(name, "BOLLI") == 0)
return nparms > 0 || nparms < 4 ? _bolli : -1;
if (strcmp(name, "_BOLLI") == 0)
return nparms > 0 || nparms < 3 ? _bolli_int : -1;
if (strcmp(name, "SPESEINC") == 0)
return nparms > 0 || nparms < 4 ? _spinc : -1;
if (strcmp(name, "PREZZO") == 0)
return nparms < 4 ? _prezzo : -1;
if (strcmp(name, "IMPORTO") == 0)
return nparms < 4 ? _importo : -1;
if (strcmp(name, "SCONTO") == 0)
return nparms < 2 ? _sconto : -1;
if (strcmp(name, "IMPONIBILE") == 0)
return nparms == 0 ? _imponibile : -1;
if (strcmp(name, "IVA") == 0)
return nparms == 0 ? _iva : -1;
if (strcmp(name, "PROVV") == 0)
return nparms < 2 ? _provv : -1;
if (strcmp(name, "QTARES") == 0)
return nparms < 2 ? _qtares : -1;
if (strcmp(name, "VALDOC") == 0)
return nparms < 3 ? _valdoc : -1;
if (strcmp(name, "TIPO") == 0)
return nparms == 0 ? _tipo : -1;
if (strcmp(name, "IMPONIBILI") == 0)
return nparms < 3 ? _imponibili : -1;
if (strcmp(name, "IMPOSTE") == 0)
return nparms < 3 ? _imposte : -1;
if (strcmp(name, "TOTPROVV") == 0)
return nparms < 3 ? _totprovv : -1;
if (strcmp(name, "PSCONTOT") == 0)
return nparms < 1 ? _pscontot : -1;
if (strcmp(name, "RITENUTA") == 0)
return nparms < 3 ? _ritenuta : -1;
if (strcmp(name, "TIPORIT") == 0)
return nparms < 1 ? _tipo_ritenuta : -1;
return -1;
}
void TExpr_documento::evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const
{
switch (index)
{
case _somma:
{
const TString cond(nparms == 2 ? stack.pop_string() : "STR(1)");
const TString & field = stack.pop_string();
real somma;
if (_doc != NULL)
{
TExpr_documento cond_expr(cond, _strexpr, _doc);
const int cond_nvars = cond_expr.numvar();
TExpr_documento expr(field, _numexpr, _doc);
const int nvars = expr.numvar();
const int nrows = _doc->rows();
for (int i = nrows; i > 0; i--)
{
TRiga_documento & riga = (TRiga_documento &) (*_doc)[i];
for (int j = cond_nvars - 1; j >= 0; j--)
{
const char* s = cond_expr.varname(j);
TFieldref f(s,0);
cond_expr.setvar(j, f.read(riga));
}
cond_expr.set_row(&riga);
if ((bool)cond_expr)
{
for (j = nvars - 1; j >= 0; j--)
{
const char* s = expr.varname(j);
TFieldref f(s,0);
expr.setvar(j, f.read(riga));
}
expr.set_row(&riga);
somma += expr.as_real();
}
}
}
stack.push(somma);
}
break;
case _spinc:
{
int ndec = AUTO_DECIMALS;
bool netto = FALSE;
if (nparms > 2)
ndec = (int) stack.pop_real().integer();
if (nparms > 1)
netto = !stack.pop_real().is_zero();
real & r = stack.peek_real();
if (_doc)
r = _doc->spese_incasso(r, ndec, netto ? _netto : _lordo);
else
r = ZERO;
}
break;
case _bolli:
{
int ndec = AUTO_DECIMALS;
bool netto = FALSE;
if (nparms > 2)
ndec = (int) stack.pop_real().integer();
if (nparms > 1)
netto = !stack.pop_real().is_zero();
real & r = stack.peek_real();
if (_doc)
{
r += _doc->spese_incasso(r, ndec);
r = _doc->bolli(r, ndec, netto ? _netto : _lordo);
}
else
r = ZERO;
}
break;
case _bolli_int:
{
int ndec = AUTO_DECIMALS;
if (nparms > 2)
ndec = (int) stack.pop_real().integer();
real & r = stack.peek_real();
if (_doc)
{
real r1 = _doc->spese_incasso(r, ndec);
r += r1;
r1 += _doc->bolli(r, ndec);
r = r1;
}
else
r = ZERO;
}
break;
case _prezzo:
{
int ndec = AUTO_DECIMALS;
bool lordo = FALSE;
bool scontato = FALSE;
if (nparms > 2)
ndec = (int) stack.pop_real().integer();
if (nparms > 1)
lordo = !stack.pop_real().is_zero();
if (nparms > 0)
scontato = !stack.peek_real().is_zero();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (_row)
val = _row->prezzo(scontato, lordo, ndec);
else
val = ZERO;
}
break;
case _importo:
{
int ndec = AUTO_DECIMALS;
bool lordo = FALSE;
bool scontato = FALSE;
if (nparms > 2)
ndec = (int) stack.pop_real().integer();
if (nparms > 1)
lordo = !stack.pop_real().is_zero();
if (nparms > 0)
scontato = !stack.peek_real().is_zero();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (_row)
val = _row->importo(scontato, lordo, ndec);
else
val = ZERO;
}
break;
case _imponibile:
{
real r;
if (_row)
r = _row->imponibile();
stack.push(r);
}
break;
case _sconto:
{
int ndec = AUTO_DECIMALS;
if (nparms > 0)
ndec = (int) stack.peek_real().integer();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (_row)
{
if (_row->is_sconto())
val = -_row->importo(FALSE, FALSE, ndec);
else
val = _row->importo(FALSE, FALSE, ndec) - _row->importo(TRUE, FALSE, ndec);
}
else
val = ZERO;
}
break;
case _iva:
{
real r;
if (_row)
r = _row->imposta();
stack.push(r);
}
break;
case _provv:
{
int ndec = AUTO_DECIMALS;
if (nparms > 0)
ndec = (int) stack.peek_real().integer();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (_row)
val = _row->provvigione(ndec);
else
val = ZERO;
}
break;
case _qtares:
{
int ndec = AUTO_DECIMALS;
if (nparms > 0)
ndec = (int) stack.peek_real().integer();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (_row)
val = _row->qtaresidua();
else
val = ZERO;
}
break;
case _valdoc:
{
int ndec = AUTO_DECIMALS;
bool totale = TRUE; // Totale o residuo per documento
if (nparms > 1)
ndec = (int)stack.pop_real().integer();
if (nparms > 0)
totale = !stack.peek_real().is_zero();
else
stack.push(ZERO);
real & r = stack.peek_real();
if (_doc)
r = _doc->valore(totale, ndec);
else
r = ZERO;
}
break;
case _tipo:
{
TString s;
if (_row)
s << _row->tipo().tipo();
stack.push(s);
}
break;
case _imponibili:
{
int ndec = AUTO_DECIMALS;
bool spese = FALSE;
if (nparms > 1)
ndec = (int) stack.pop_real().integer();
if (nparms > 0)
spese = !stack.peek_real().is_zero();
else
stack.push(ZERO);
real & val = stack.peek_real();
val = _doc->imponibile(spese, ndec);
}
break;
case _imposte:
{
int ndec = AUTO_DECIMALS;
bool spese = FALSE;
if (nparms > 1)
ndec = (int) stack.pop_real().integer();
if (nparms > 0)
spese = !stack.peek_real().is_zero();
else
stack.push(ZERO);
real & val = stack.peek_real();
val = _doc->imposta(spese, ndec);
}
break;
case _totprovv:
{
int ndec = AUTO_DECIMALS;
if (nparms > 0)
ndec = (int) stack.peek_real().integer();
else
stack.push(ZERO);
real & val = stack.peek_real();
val = _doc->provvigione(ndec);
}
break;
case _pscontot:
{
real val;
TString80 s;
if (_doc && scontoexpr2perc(_doc->get(DOC_SCONTOPERC), FALSE, s, val) && val != ZERO)
val = 1 - val;
stack.push(val);
}
break;
case _ritenuta:
{
int ndec = AUTO_DECIMALS;
bool lordo = FALSE;
if (nparms > 1)
ndec = (int) stack.pop_real().integer();
if (nparms > 0)
lordo = !stack.peek_real().is_zero();
else
stack.push(ZERO);
real & val = stack.peek_real();
const bool spesa = _row->tipo().tipo() == 'S';
if (spesa)
{
const bool tipo_rit = _row->spesa().tipo_ritenuta();
if (tipo_rit != '\0')
{
((TSpesa_prest &)_row->spesa()).zero("S9");
_row->dirty_fields();
val = _row->importo(TRUE, lordo, ndec);
_row->dirty_fields();
((TSpesa_prest &)_row->spesa()).put("S9", (char)tipo_rit);
}
else
val = ZERO;
}
else
val = ZERO;
}
break;
case _tipo_ritenuta:
{
TString s;
if (_row && _row->tipo().tipo() == 'S')
s << _row->spesa().tipo_ritenuta();
stack.push(s);
}
break;
default:
TExpression::evaluate_user_func(index, nparms, stack, type);
break;
}
}
TObject* TExpr_documento::dup() const
{
TExpr_documento* o = new TExpr_documento(*this);
return o;
}
///////////////////////////////////////////////////////////
// Formula documento
///////////////////////////////////////////////////////////
TFormula_documento::TFormula_documento(TTipo_formula tipo, const char* codice, const char * expr, bool numexpr)
: TRectype(LF_TABCOM), _expr(NULL)
{
_tab = tipo == _documento ? "FRD" : "FRR";
settab(_tab);
_tab.insert("%");
if (codice && *codice)
read(codice, expr, numexpr);
}
TFormula_documento::TFormula_documento(const TRectype& rec)
: TRectype(rec), _expr(NULL)
{
_tab = "%";
_tab << rec.get("COD");
const TTypeexp et = expr_type();
_expr = new TExpr_documento(expr_string(), et);
}
TFormula_documento::~TFormula_documento()
{
if (_expr) delete _expr;
}
int TFormula_documento::read(const char* codice, const char * expr, bool numexpr)
{
if (_expr != NULL)
{
delete _expr;
_expr = NULL;
}
put("CODTAB", codice);
int err = NOERR;
if (expr && *expr)
{
put("S1", expr);
put("B0", numexpr ? "X" : "");
}
else
{
TTable t(_tab);
err = TRectype::read(t);
}
if (err == NOERR)
{
const TTypeexp et = expr_type();
const TString e = expr_string(); // Copio espressione proveniente da record
_expr = new TExpr_documento(e, et);
}
else
{
zero();
put("CODTAB", codice);
}
return err;
}
Reference in New Issue View Git Blame Copy Permalink