root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/src/ve/velib03a.cpp
Alessandro Bonazzi afdef4db9a Patch level : 12.0 1030 
Files correlati     : ve0.exe ve1.exe ve6.exe ve5.exe f34.trr f34.dir

Commento :

MIgliorato il meccanismo di autoevasione degli ordini nel caso di cambio di un codice e di cancellazione di una riga.
Modificata la contabilizzazione del reverse charge per getire il reverse charge parziale
Aggiunto il campo reverse charge sulle rige documento

Interno

La lettura di un documento controlla se il documento ha una causale di reverse charge e non ha il flag su nessuna riga in questo caso lo imposta su tutte le righe. Questo dovrebbe evitare conversioni sui documenti vecchi.
2021-01-31 13:53:51 +01:00

1405 lines
35 KiB
C++
Executable File
Raw Blame History

#include "velib.h"
#include "vepriv.h"
#include "verig.h"
#include <tabutil.h>
#include <utility.h>
#include "../db/dblib.h"
#include "../mg/mglib.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 TString& TTipo_documento::mask_name() const
{
TString& name = get_tmp_string();
name = get("S4");
name.cut(8);
name.trim();
return name;
}
const TFilename& TTipo_documento::profile_name(TFilename& profile) const
{
profile = get("S4");
profile.cut(8);
profile.trim();
profile.ext("ini");
return profile;
}
bool TTipo_documento::main_print_profile(TFilename& report, int filter) const
{
TString8 base = get("S5").left(8);
base.trim();
bool ok = base.full();
if (ok)
{
ok = false;
if (filter != 1)
{
report = base;
report.ext("rep");
ok = report.custom_path();
}
if (!ok && filter != 2)
{
report = base;
report.ext("frm");
ok = report.custom_path();
}
}
return ok;
}
bool TTipo_documento::additional_print_profile(TFilename& report, int filter) const
{
TString8 base = get("S5").mid(8, 8);
base.trim();
bool ok = base.full();
if (ok)
{
ok = false;
if (filter != 1) // Non voglio i soli frm
{
report = base;
report.ext("rep");
ok = report.custom_path();
}
if (!ok && filter != 2) // Non voglio i soli rep
{
report = base;
report.ext("frm");
ok = report.custom_path();
}
}
return ok;
}
bool TTipo_documento::mail_print_profile(TFilename& report) const
{
report = get("S5").mid(16, 8);
bool ok = report.full();
if (ok)
{
report.trim();
report.ext("rep");
ok = report.custom_path();
}
if (!ok)
ok = main_print_profile(report, 2); // Solo rep
return ok;
}
bool TTipo_documento::is_costo() const
{ return _tipocr == 'C' || tipocf() == 'F'; }
bool TTipo_documento::is_ricavo() const
{ return _tipocr == 'R' || tipocf() == 'C'; }
const char TTipo_documento::tipocf() const
{
if (_tipocf < ' ')
{
TFilename pn; profile_name(pn);
//(char&)_tipocf = ini_get_string(pn, "MAIN", "TIPOCF", "C")[0]; // NON FUNZIONA: ritorna sempre 'C'
TConfig ini(pn, "MAIN");
(char&)_tipocf = ini.get("TIPOCF", NULL, -1, "C")[0];
}
return _tipocf;
}
const TString& TTipo_documento::riferimento(const TDocumento & doc, TString& rif) const
{
rif = esc(get("S1"));
int p = rif.find('{');
bool ok = true;
while (p >= 0)
{
char conn = ' ';
int q = p + 1;
if (rif[q] == '\\' || rif[q] == '&' || rif[q] == '|')
conn = rif[q++];
const int last = rif.find('}');
const TString16 field_name(rif.sub(q, 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];
}
TString val;
switch (field.file())
{
case LF_DOC:
val = field.read(doc);
break;
case LF_CLIFO:
case LF_CFVEN:
if (doc.get_long(DOC_CODCF) > 0)
{
TString8 key; key << doc.get(DOC_TIPOCF) << '|' << doc.get(DOC_CODCF);
const TRectype& rec = cache().get(field.file(), key);
val = field.read(rec);
}
break;
case LF_OCCAS:
if (doc.get_char(DOC_TIPOCF) == 'C' && doc.get(DOC_OCFPI).full())
{
const TRectype& rec = cache().get(LF_OCCAS, doc.get(DOC_OCFPI));
val = field.read(rec);
}
break;
default:
val = field.read(doc);
break;
}
rif.insert(val, p);
switch (conn)
{
case '\\' :
ok = val.full();
break;
case '&' :
ok &= val.full();
break;
case '|' :
ok |= val.full();
break;
default :
break;
}
p = rif.find('{');
}
if (!ok)
rif.cut(0);
return rif;
}
const TString_array& TTipo_documento::keys_descrs() const
{
if (_keys_descrs.empty())
{
TFilename name; profile_name(name);
TConfig prof(name, "RIGHE");
TTipo_riga_documento tr;
TToken_string k, d;
for (int i = 0; ; i++)
{
const TString& tiporiga = prof.get("Tipo", NULL, i);
if (tiporiga.full())
{
if (tr.read(tiporiga) == NOERR)
{
k.add(tr.codice());
d.add(tr.descrizione());
}
}
else
break; //esce da un eventuale ciclo infinito
}
if (k.blank())
{
TISAM_recordset tri("USE %TRI");
for (bool ok = tri.move_first(); ok; ok = tri.move_next())
{
name.format("verig%s.msk", (const char*)tri.get("CODTAB").as_string());
if (name.custom_path())
{
k.add(tri.get("CODTAB").as_string());
d.add(tri.get("S0").as_string());
}
}
}
// Fool const
((TString_array&)_keys_descrs).add(k);
((TString_array&)_keys_descrs).add(d);
}
return _keys_descrs;
}
const TString_array& TTipo_documento::sheet_columns() const
{
if (_sheet_columns.empty())
{
TFilename pn; profile_name(pn);
TConfig prof(pn);//, "SHEET");
TString_array para;
prof.list_paragraphs(para);
if (para.find("SHEET", 0) >= 0)
prof.set_paragraph("SHEET");
else
if (para.find("SH", 0) >= 0)
prof.set_paragraph("SH");
for (int i = 0; i < MAX_COLUMNS; i++)
{
const TString& id = prof.get("Col", NULL, i);
if (atoi(id) <= 0)
break;
((TString_array&)_sheet_columns).add(id);
}
}
return _sheet_columns;
}
const TPointer_array& TTipo_documento::handlers() const
{
if (_handlers.empty())
{
TFilename pn; profile_name(pn);
TConfig prof(pn, "HANDLERS");
TAssoc_array& v = prof.list_variables();
TToken_string pair;
FOR_EACH_ASSOC_STRING(v, h, k, s)
{
int id = 0, hnd = 0;
pair = s;
switch (pair.items())
{
case 1:
{
const TFixed_string key(k);
id = atoi(key.after('('));
hnd = atoi(pair);
}
break;
case 2:
id = pair.get_int(0);
hnd = pair.get_int();
break;
default: break;
}
if (id > 10 && id < 1000 && hnd > 0)
((TPointer_array&)_handlers).add_long(hnd, id);
}
}
return _handlers;
}
const TString_array& TTipo_documento::get_defaults() const
{
if (_defaults.empty()) // Carica lo string_array con i defaults
{
TFilename pn; profile_name(pn);
TConfig prof(pn, "DEFAULT");
TToken_string s;
for(int i = 0; ; i++)
{
s = prof.get("Default", NULL, i);
if (s.empty())
break;
const int field = s.get_int();
((TTipo_documento*)this)->_defaults.add(s.get(), field);
}
}
return _defaults;
}
void TTipo_documento::set_defaults(TMask& m) const
{
const TString_array& def = get_defaults();
// Setta i campi della maschera
FOR_EACH_ARRAY_ROW(def, i, tt)
m.set(i, *tt, true);
}
void TTipo_documento::add_formula_if_needed(TConfig& profile, TString& variable,
const char* varname, const char* formula)
{
variable = profile.get(varname, "MAIN");
if (variable.blank())
variable = varname;
const TRectype& trr = cache().get("%FRD", variable);
if (trr.empty() || trr.get("S1").empty())
_formule_documento.add(variable, new TFormula_documento(_documento, variable, formula), TRUE);
if (_formule.find(variable) < 0)
_formule.add(variable);
}
void TTipo_documento::read_formule()
{
TFilename profile; profile_name(profile);
TFilename p(profile); p.custom_path();
if (p.exist()) // evita la creazione di profili vuoti
{
TConfig prof(profile, "MAIN");
prof.write_protect(); // Altrimenti non si distrugge!!!
_tipocr = prof.get_char("TIPOCR", NULL, -1, ' ');
_formule = prof.get("CAMPICALC");
const TString& calcoli = prof.get("CALCOLI");
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);
add_formula_if_needed(prof, _totale, "TOTALE", "IMPONIBILI()+IMPOSTE()");
if (_totale == "TOTALE")
_totale = "TOTDOC";
_totale_netto = "_"; _totale_netto << _totale;
add_formula_if_needed(prof, _basesconto, "BASESCONTO", "SOMMA(\"IMPONIBILE()\", \"(TIPO()!='S') && (TIPO()!='C')\")");
add_formula_if_needed(prof, _spese, "SPESE", "SOMMA(\"IMPONIBILE()\", \"TIPO() == 'S'\")");
add_formula_if_needed(prof, _totvalres, "TOTVALRES", "VALDOC(0)");
add_formula_if_needed(prof, _totvalore, "TOTVALORE", "VALDOC(1)");
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);
campo = prof.get("TOTPROVV1");
if (campo.empty())
campo = "TOTPROVV1";
const TRectype& frd1 = cache().get("%FRD", campo);
_totprovv1 = "_";
_totprovv1 << campo;
expr = frd1.get("S1");
if (expr.empty())
expr = "SOMMA(\"PROVV(-883,0)\")";
_formule_documento.add(_totprovv1, new TFormula_documento(_documento, _totprovv1, expr));
if (_formule.find(campo) < 0)
_formule.add(campo);
_formule.add(_totprovv1);
_formule_documento.add(campo, new TFormula_documento(_documento, campo, "TOTPROVV(-883,0)"));
}
_totale_cont = prof.get("TOTALECONT");
_cnt_prezzi = prof.get_bool("CONTROLLO_PREZZI");
_field_prezzo = prof.get(RDOC_PREZZO);
_field_qta = prof.get(RDOC_QTA, NULL, -1, RDOC_QTA);
_field_qtaevasa = prof.get(RDOC_QTAEVASA, NULL, -1, RDOC_QTAEVASA);
_field_qta_mag = prof.get("QTA_MAG");
if (_field_qta_mag.blank())
_field_qta_mag = _field_qta;
_field_qtaevasa_mag = prof.get("QTAEVASA_MAG");
if (_field_qtaevasa_mag.blank())
_field_qtaevasa_mag = _field_qtaevasa;
_check_qta = prof.get_char("CHECK_QTA", "MAIN");
_load_cont = prof.get_bool("LOAD_CONT", "MAIN");
_raee_cod = prof.get("RAEE_COD", "MAIN");
_raee_fld = prof.get("RAEE_FLD", "MAIN");
_max_days = prof.get_int("MAXDAYSBEFORE", "MAIN", -1, -1);
TToken_string str = prof.get("ART_TO_SHOW", "MAIN");
_liv = str.get_int();
_row = str.get_int();
if (_liv > 0 && _row == 0)
_row = 1;
_str_desc_doc = prof.get("DESCRIZIONE_DOC");
_str_desc_rdoc = prof.get("DESCRIZIONE_RDOC");
_show_evaded_lines = !prof.get_bool("NASCONDI_RIGHE_EVASE"); // Normalmente mostra anche evase
_non_evadere = prof.get_bool("NON_EVADERE"); // Normalmente mostra anche evase
_module = prof.get("MODULE", NULL, -1, "ve").left(2);
_hca_req = !prof.get_bool("HEAD_CA_OPT");
_check_double_art = prof.get_bool("CHECK_DOUBLE_ART");
_ignora_anticipi_fatturazione = prof.get_bool("IGNORA_ANTICIPI_FATTURAZIONE");
}
}
bool TTipo_documento::movimento_interno() const
{
const TString& elab = elaborazione();
if (elab.full())
{
const TString& app = cache().get("%ELD", elab, "S3");
return app.starts_with("ci1 -4", true);
}
return false;
}
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");
}
const TDate & TTipo_documento::first_ok_date()
{
if (!_first_ok_date.ok())
{
_first_ok_date = TDate(TODAY);
if (_max_days < 0)
{
_first_ok_date.set_day(1);
_first_ok_date.set_month(1);
_first_ok_date.set_year(1900);
}
else
_first_ok_date -= _max_days;
}
return _first_ok_date;
}
///////////////////////////////////////////////////////////
// Espressione rdocumento
///////////////////////////////////////////////////////////
TExpr_documento::TExpr_documento(const char* expression, TTypeexp type,
const TDocumento* doc, const 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 < 3 ? _provv : -1;
if (strcmp(name, "QUANT") == 0)
return nparms < 2 ? _quant : -1;
if (strcmp(name, "QUANTEVASA") == 0)
return nparms < 2 ? _quantevasa : -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;
if (strcmp(name, "COMP") == 0)
return nparms == 2 ? _componente : -1;
if (strcmp(name, "COMPQTA") == 0)
return nparms == 2 ? _comp_qta : -1;
if (strcmp(name, "NRATE") == 0)
return nparms == 0 ? _nrate : -1;
if (strcmp(name, "QTACONAI") == 0)
return nparms >= 0 && nparms < 4 ? _qtaconai : -1;
if (strcmp(name, "PESOCONAI") == 0)
return nparms >= 0 && nparms < 4 ? _pesoconai : -1;
if (strcmp(name, "VALCONAI") == 0)
return nparms >= 0 && nparms < 4 ? _valconai : -1;
return -1;
}
void TExpr_documento::evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const
{
if (index >= _componente)
int i = 0;
switch (index)
{
case _somma:
{
const TString cond = nparms == 2 ? stack.pop_string() : "STR(1)";
const TString& field = stack.pop_string();
real sum;
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();
for (int i = _doc->rows(); i > 0; i--)
{
const TRiga_documento& riga = (const TRiga_documento&)(*_doc)[i];
for (int j = cond_nvars - 1; j >= 0; j--)
{
const char* s = cond_expr.varname(j);
const TFieldref f(s,0);
cond_expr.setvar(j, f.read(riga));
}
cond_expr.set_row(&riga);
if (cond_expr.as_bool())
{
for (int j = nvars - 1; j >= 0; j--)
{
const char* s = expr.varname(j);
const TFieldref f(s,0);
expr.setvar(j, f.read(riga));
}
expr.set_row(&riga);
sum += expr.as_real();
}
}
}
stack.push(sum);
}
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(real(r - (const real)_doc->ritenute()), 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(real(r - _doc->ritenute()), ndec);
r = _doc->bolli(real(r - _doc->ritenute()), 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(real(r - _doc->ritenute()), ndec);
r += r1;
r1 += _doc->bolli(real(r - _doc->ritenute()), 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)
{
val = _row->importo(false, false, ndec);
if (_row->is_sconto())
val = -val;
else
val -= _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;
bool first = true;
if (nparms > 1)
first = !stack.peek_real().is_zero();
if (nparms > 0)
ndec = (int) stack.peek_real().integer();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (_row)
val = _row->provvigione(first, ndec);
else
val = ZERO;
}
break;
case _quant:
{
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->quantita();
else
val = ZERO;
}
break;
case _quantevasa:
{
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->qtaevasa();
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, false, 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;
bool first = true;
bool all = nparms == 0;
if (nparms > 1)
first = !stack.peek_real().is_zero();
if (nparms > 0)
ndec = (int) stack.peek_real().integer();
else
stack.push(ZERO);
real & val = stack.peek_real();
if (all)
val = _doc->provvigione(true, ndec) + _doc->provvigione(false, ndec);
else
val = _doc->provvigione(first, ndec);
}
break;
case _pscontot:
{
real val;
TString80 s;
if (_doc && scontoexpr2perc(_doc->get(DOC_SCONTOPERC), FALSE, s, val) && val != ZERO)
val = UNO - 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();
if (_row && _row->tipo().tipo() == 'S')
{
const char tipo = _row->spesa().tipo_ritenuta();
val = _row->ritenuta(tipo, lordo, ndec);
}
else
val = ZERO;
}
break;
case _tipo_ritenuta:
{
TString s;
if (_row && _row->tipo().tipo() == 'S')
s << _row->spesa().tipo_ritenuta();
stack.push(s);
}
break;
case _componente:
case _comp_qta:
{
static TAssoc_array comps;
static TAssoc_array qtas;
const TString substr = stack.pop_string();
const int pos = atoi(stack.pop_real().string());
const TString codart = _row->get(RDOC_CODARTMAG);
TString * val = (TString *) comps.objptr(codart);
if (val != NULL)
{
if (index == _componente)
stack.push(*val);
else
{
const real &val = *(real *) qtas.objptr(codart);
stack.push(val);
}
}
else
{
TDistinta_tree db;
TArray comp;
bool found = false;
db.set_root(codart);
const int items = db.explode(comp, true, RAGGR_EXP_UMBASE, 0, "A", false);
if (items > 0)
{
for (int i = comp.first(); !found && i < items; i = comp.succ(i))
{
TRiga_esplosione& r = (TRiga_esplosione &) comp[i];
const TCodice_articolo c = r.articolo();
if (c.find(substr, pos) > 0)
{
if (index == _componente)
stack.push(c);
else
stack.push(r.val());
comps.add(codart, c);
qtas.add(codart, r.val());
found = true;
}
}
}
if (!found)
{
if (index == _componente)
stack.push(EMPTY_STRING);
else
stack.push(ZERO);
comps.add(codart, EMPTY_STRING);
qtas.add(codart, ZERO);
}
}
}
break;
case _nrate:
{
const TPagamento& p = ((TDocumento*)_doc)->pagamento();
const real r = p.n_rate();
stack.push(r);
}
break;
default:
TExpression::evaluate_user_func(index, nparms, stack, type);
break;
case _pesoconai:
case _qtaconai:
{
const int ndec = (nparms > 2) ? (int)stack.pop_real().integer() : 5;
const int tipo_calcolo = (nparms > 1) ? (int)stack.pop_real().integer() : 0;
const TString cat = (nparms > 0) ? stack.pop_string() : EMPTY_STRING;
stack.push(ZERO);
real & val = stack.peek_real();
if (_row && (_row->tipo().tipo() == RIGA_MERCE || _row->tipo().tipo() == RIGA_OMAGGI))
{
for (int i = 1; i <= FR_CMAX; i++)
{
const TString8 sottocat = _row->get(conai_sottocat_name(i));
if (sottocat.full() && sottocat.starts_with(cat))
{
const real peso = _row->get_real(conai_peso_name(i));
val += (((index == _qtaconai) ? _row->get_real(RDOC_QTA) : UNO) * peso);
}
}
if (tipo_calcolo < 2 && cat.full())
{
real perc_esenz;
const TDate datadoc = _doc->get(DOC_DATADOC);
const TRectype& cfven = _doc->clifor().vendite();
const TDate dataies = cfven.get(CFV_DATAICONAI);
const TDate dataees = cfven.get(CFV_DATAECONAI);
if ((datadoc >= dataies) && ((!dataees.ok()) || (datadoc <= dataees)))
perc_esenz = cfven.get_real(get_cf_esenz(cat.left(2)));
if (tipo_calcolo == 0)
val *= ((CENTO - perc_esenz) / CENTO);
else
val *= (perc_esenz / CENTO);
}
val.round(ndec);
}
else
val = ZERO;
}
break;
case _valconai:
{
const int ndec = (nparms > 2) ? (int)stack.pop_real().integer() : 5;
const int tipo_calcolo = (nparms > 1) ? (int)stack.pop_real().integer() : 0;
const TString cat = (nparms > 0) ? stack.pop_string() : EMPTY_STRING;
TString_array sottocat_found;
stack.push(ZERO);
real & val = stack.peek_real();
if (_row && (_row->tipo().tipo() == RIGA_MERCE || _row->tipo().tipo() == RIGA_OMAGGI))
{
for (int i = 1; i <= FR_CMAX; i++)
{
const TString8 sottocat = _row->get(conai_sottocat_name(i));
if (sottocat.full() && sottocat.starts_with(cat))
{
if (sottocat.full() && sottocat_found.find(sottocat) < 0)
{
sottocat_found.add(sottocat);
stack.push(sottocat);
stack.push(tipo_calcolo);
evaluate_user_func(_qtaconai, 2, stack, type);
real valqta = stack.pop_real();
if (_doc)
{
int rows = _doc->physical_rows();
const TRectype & scc = cache().get("&VESCC", sottocat);
TString conai_codart(scc.get("S1"));
for (int i = rows; i >= 1; i--)
{
const TRiga_documento& rdoc = (*_doc)[i];
//c'<27> la riga generata con codart di tipo conai (sia automatica che manuale)?
if (rdoc.get(RDOC_CODART) == conai_codart && (rdoc.is_spese() || rdoc.is_generata()))
{
const real prezzo = rdoc.get_real(RDOC_PREZZO);
val = valqta * prezzo;
val.round(ndec);
break;
}
}
}
else
val = ZERO;
}
}
}
}
}
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)
{
settab(tipo == _documento ? "FRD" : "FRR");
if (codice && *codice)
read(codice, expr, numexpr);
}
TFormula_documento::TFormula_documento(const TRectype& rec)
: TRectype(rec), _expr(NULL)
{
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
{
TString4 cod; cod << '%' << get("COD");
TTable t(cod);
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;
}
//roba usata in CI ed LV (per ora, 21/01/2011)
////////////////////////
//// TDOC_KEY ////
////////////////////////
//CODNUM: metodo che restituisce il provv dalla TToken_string chiave dei documenti
const char TDoc_key::provv() const
{
return (*this)[0];
}
//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti
const int TDoc_key::anno() const
{
int anno = 0; get(1, anno);
return anno;
}
//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
const char* TDoc_key::codnum() const
{
TString& codnum = get_tmp_string();
get(2, codnum);
return codnum;
}
//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti
const long TDoc_key::ndoc() const
{
long n = 0; get(3, n);
return n;
}
//SET_PROVV: metodo che setta il campo provv
void TDoc_key::set_provv(const char provv)
{
add(provv, 0);
}
//SET_ANNO: metodo che setta il campo anno
void TDoc_key::set_anno(const int anno)
{
add(anno, 1);
}
//SET_CODNUM: metodo che setta il campo codnum
void TDoc_key::set_codnum(const char* codnum)
{
add(codnum, 2);
}
//SET_NDOC: metodo che setta il campo ndoc
void TDoc_key::set_ndoc(const long ndoc)
{
add(ndoc, 3);
}
//metodi costruttori
TDoc_key::TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv)
{
add(provv);
add(anno);
add(codnum);
add(ndoc);
}
TDoc_key::TDoc_key(const TRectype& rec)
{
switch (rec.num())
{
case LF_MOVMAG:
add(rec.get_char(MOVMAG_DOCPROVV));
add(rec.get_int(MOVMAG_ANNODOC));
add(rec.get(MOVMAG_CODNUM));
add(rec.get_long(MOVMAG_NUMDOC));
break;
default:
add(rec.get_char(DOC_PROVV));
add(rec.get_int(DOC_ANNO));
add(rec.get(DOC_CODNUM));
add(rec.get_long(DOC_NDOC));
break;
}
}
/////////////////////////
//// TRDOC_KEY ////
/////////////////////////
const int TRdoc_key::nriga() const
{
int riga = 0; get(4, riga);
return riga;
}
//metodi costruttori
TRdoc_key::TRdoc_key(const int anno, const TString& codnum, const long ndoc, const int nriga, const char provv)
: TDoc_key(anno, codnum, ndoc, provv)
{
add(nriga, 4);
}
TRdoc_key::TRdoc_key(const TRectype& rec)
{
switch (rec.num())
{
case LF_RIGHEDOC:
default:
add(rec.get(RDOC_PROVV));
add(rec.get(RDOC_ANNO));
add(rec.get(RDOC_CODNUM));
add(rec.get(RDOC_NDOC));
add(rec.get(RDOC_NRIGA));
break;
}
}
const TString & TTipo_documento::get_property_str(const char * paragraph, const char * property_name, const char* defval, int idx) const
{
TFilename prof; profile_name(prof); prof.custom_path();
return ini_get_string(prof, paragraph, property_name, defval, idx);
}
const bool TTipo_documento::get_property_bool(const char * paragraph, const char * property_name, bool defval, int idx) const
{
TFilename prof; profile_name(prof); prof.custom_path();
return ini_get_bool(prof, paragraph, property_name, defval, idx);
}
const int TTipo_documento::get_property_int(const char * paragraph, const char * property_name, int defval, int idx) const
{
TFilename prof; profile_name(prof); prof.custom_path();
return ini_get_int(prof, paragraph, property_name, defval, idx);
}
const long TTipo_documento::get_property_long(const char * paragraph, const char * property_name, long defval, int idx) const
{
TFilename prof; profile_name(prof); prof.custom_path();
return ini_get_long(prof, paragraph, property_name, defval, idx);
}
const TDate TTipo_documento::get_property_date(const char * paragraph, const char * property_name, const char * defval, int idx) const
{
TFilename prof; profile_name(prof); prof.custom_path();
return ini_get_date(prof, paragraph, property_name, defval, idx);
}
const real TTipo_documento::get_property_real(const char * paragraph, const char * property_name, const char * defval, int idx) const
{
TFilename prof; profile_name(prof); prof.custom_path();
return ini_get_real(prof, "MAIN", property_name, defval, idx);
}
Reference in New Issue View Git Blame Copy Permalink