934 lines
24 KiB
C++
Executable File
934 lines
24 KiB
C++
Executable File
#include "velib.h"
|
||
#include "vepriv.h"
|
||
|
||
#include <clifo.h>
|
||
|
||
#ifndef __EXPR_H
|
||
#include <expr.h>
|
||
#endif
|
||
|
||
#ifndef __VERIG_H
|
||
#include "verig.h"
|
||
#endif
|
||
|
||
#ifndef __VEUML_H
|
||
#include "veuml.h"
|
||
#endif
|
||
|
||
#ifndef __VEUML1_H
|
||
#include "veuml1.h"
|
||
#endif
|
||
|
||
#ifndef __DEFMASK_H
|
||
#include <defmask.h>
|
||
#endif
|
||
|
||
#ifndef __SCONTI_H
|
||
#include "sconti.h"
|
||
#endif
|
||
|
||
TSpesa_prest::TSpesa_prest(const char* codice, char tipo)
|
||
: TRectype(LF_TAB)
|
||
{
|
||
settab(tipo == RIGA_SPESEDOC ? "SPP" : "PRS");
|
||
if (codice && *codice)
|
||
read(codice);
|
||
}
|
||
|
||
TSpesa_prest::TSpesa_prest(const TRectype& rec)
|
||
: TRectype(rec)
|
||
{
|
||
}
|
||
|
||
int TSpesa_prest::read(const char* codice)
|
||
{
|
||
TTable t(get("COD"));
|
||
put("CODTAB", codice);
|
||
int err = TRectype::read(t);
|
||
if (err != NOERR)
|
||
yesnofatal_box("Tipo spesa assente : %s", codice);
|
||
return err;
|
||
}
|
||
|
||
TIVA::TIVA(const char* codice)
|
||
: TRectype(LF_TABCOM)
|
||
{
|
||
settab("IVA");
|
||
if (codice && *codice)
|
||
read(codice);
|
||
}
|
||
|
||
TIVA::TIVA(const TRectype& rec)
|
||
: TRectype(rec)
|
||
{
|
||
}
|
||
|
||
int TIVA::read(const char* codice)
|
||
{
|
||
TTable t("%IVA");
|
||
put("CODTAB", codice);
|
||
int err = TRectype::read(t);
|
||
if (err != NOERR)
|
||
yesnofatal_box("Codice IVA assente : %s", codice);
|
||
return err;
|
||
}
|
||
|
||
bool ora_hndl( TMask_field& field, KEY key )
|
||
|
||
{
|
||
if (field.to_check(key))
|
||
{
|
||
TFixed_string ora( field.get( ), 6 );
|
||
|
||
ora.trim( );
|
||
if (ora.not_empty() || field.required() )
|
||
{
|
||
if ( isdigit( ora[ 0 ] ) )
|
||
{
|
||
if ( ora[ 2 ] != ':')
|
||
{
|
||
if ( ora.len( ) > 4 )
|
||
ora.overwrite( ":", 2 );
|
||
else
|
||
ora.insert( ":", 2 );
|
||
}
|
||
}
|
||
const bool ok = ((isdigit(ora[0]))&&(isdigit(ora[1]))&&(isdigit(ora[3]))&&(isdigit(ora[4]))) &&
|
||
((atoi(&(ora[0]))<24)&&(atoi(&(ora[3]))<60));
|
||
if (ok )
|
||
field.set((ora));
|
||
else
|
||
return error_box("Ora errata o formato non valido");
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool dummy_hndl(TMask_field& field, KEY key)
|
||
{
|
||
warning_box( "Al campo %d <20> arrivato un KEY %d", field.dlg( ), key );
|
||
return TRUE;
|
||
}
|
||
|
||
// Handler per il calcolo delle date di pagamento
|
||
bool condpag_hndl( TMask_field& field, KEY key )
|
||
{
|
||
TDocumento_mask& m = (TDocumento_mask &) field.mask( );
|
||
|
||
if ( field.to_check(key) || (key == K_TAB && !m.is_running()))
|
||
{
|
||
const TString16 condpag(m.get(F_CODPAG));
|
||
TString16 data(m.get(F_DATAINSC));
|
||
|
||
if (data.empty())
|
||
data = m.get(F_DATADOC);
|
||
if ( condpag.not_empty())
|
||
{
|
||
TPagamento pag(condpag, data);
|
||
|
||
pag.set_total( 100, 10, 10 );
|
||
pag.set_rate_auto( );
|
||
int numrate = pag.n_rate( );
|
||
if (numrate > 5)
|
||
numrate = 5;
|
||
for( int i = 0; i < numrate; i ++ )
|
||
{
|
||
m.show( F_DATASCAD1 + i );
|
||
m.set( F_DATASCAD1 + i, pag.data_rata(i).string());
|
||
}
|
||
for( ; i < 5; i ++ )
|
||
m.hide( F_DATASCAD1 + i );
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool note_hndl( TMask_field& f, KEY key )
|
||
{
|
||
TDocumento_mask & m = (TDocumento_mask &) f.mask();
|
||
|
||
if (key == K_TAB && (f.focusdirty() || !m.is_running()))
|
||
{
|
||
TTable & note = (TTable &) ((TEdit_field &) f).browse()->cursor()->file();
|
||
note.setkey(1);
|
||
const TString16 cod(f.get());
|
||
|
||
if (cod != note.get("CODTAB"))
|
||
{
|
||
note.zero();
|
||
note.put("CODTAB", cod);
|
||
if (note.read() != NOERR)
|
||
note.zero();
|
||
}
|
||
const bool reg_disabled = note.get_bool("B0");
|
||
|
||
if (reg_disabled)
|
||
message_box("Registrazione disbilitata : %s", (const char *) note.get("S0"));
|
||
m.enable(DLG_SAVEREC, !reg_disabled);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// Handler per il calcolo delle date di pagamento
|
||
bool data_hndl( TMask_field& field, KEY key )
|
||
{
|
||
TDocumento_mask& m = (TDocumento_mask &) field.mask( );
|
||
if (key == K_ENTER && field.dirty())
|
||
{
|
||
TLocalisamfile doc(LF_DOC);
|
||
const TDate datadoc(m.get(F_DATADOC));
|
||
|
||
doc.curr() = m.doc().head();
|
||
const TString16 codnum(doc.get("CODNUM"));
|
||
const int anno = doc.get_int("ANNO");
|
||
const char tipo_num = doc.get_char("PROVV");
|
||
|
||
if (doc.read(_isgreat) == NOERR &&
|
||
codnum == doc.get("CODNUM") &&
|
||
anno == doc.get_int("ANNO") &&
|
||
tipo_num == doc.get_char("PROVV") &&
|
||
datadoc > doc.get_date("DATADOC"))
|
||
return field.error_box("Data documento superiore alla data del documento successivo");
|
||
|
||
doc.curr() = m.doc().head();
|
||
doc.read();
|
||
if (doc.prev() == NOERR &&
|
||
codnum == doc.get("CODNUM") &&
|
||
anno == doc.get_int("ANNO") &&
|
||
tipo_num == doc.get_char("PROVV") &&
|
||
datadoc < doc.get_date("DATADOC"))
|
||
return field.error_box("Data documento inferiore alla data del documento precedente");
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// handler delle righe
|
||
|
||
void row_set_handler( TMask& m, const int field, const int index )
|
||
{
|
||
switch ( index )
|
||
{
|
||
case 1:
|
||
m.set_handler( field, dummy_hndl );
|
||
break;
|
||
default:
|
||
yesnofatal_box( FALSE, "Funzione di handler sulla riga non definita( %d ).", index );
|
||
}
|
||
}
|
||
|
||
HIDDEN TString16 curr_um;
|
||
HIDDEN real curr_fc(1.0);
|
||
|
||
bool iva_handler( TMask_field& f, KEY key )
|
||
{
|
||
if (key == 0 || (key == K_ENTER && f.get().empty()))
|
||
{
|
||
TDocumento_mask & mask = (TDocumento_mask &) f.mask().get_sheet()->mask();
|
||
const TString16 codiva = mask.condv().clifo().get(LF_CFVEN, "ASSFIS");
|
||
|
||
if (codiva.not_empty())
|
||
f.set(codiva);
|
||
f.check();
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool codart_handler( TMask_field& f, KEY key )
|
||
{
|
||
TMask& row_mask = f.mask();
|
||
|
||
if (f.to_check(key, TRUE))
|
||
{
|
||
if (f.get().not_empty())
|
||
row_mask.enable(FR_LIV1);
|
||
else
|
||
{
|
||
row_mask.reset(FR_LIV1);
|
||
row_mask.disable(FR_LIV1);
|
||
}
|
||
row_mask.field(FR_LIV1).on_hit();
|
||
}
|
||
if (key == K_TAB && (f.focusdirty() || row_mask.get(FR_DESCR).empty()))
|
||
{
|
||
TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
|
||
TCond_vendita & condv = mask.condv();
|
||
|
||
condv.set_testa(&mask);
|
||
condv.set_riga(&row_mask);
|
||
|
||
TLocalisamfile & anamag = ((TEdit_field &) f).browse()->cursor()->file();
|
||
TLocalisamfile & umart = ((TEdit_field &) row_mask.field(FR_UMQTA)).browse()->cursor()->file();
|
||
|
||
condv.set_anamag(anamag);
|
||
condv.set_umart(umart);
|
||
TString80 codart(f.get());
|
||
anamag.setkey(1);
|
||
anamag.put("CODART", codart);
|
||
if (anamag.read() != NOERR)
|
||
{
|
||
TLocalisamfile codalt(LF_CODCORR);
|
||
|
||
codalt.setkey(2);
|
||
codalt.put("CODARTALT", codart);
|
||
if (codalt.read() == NOERR)
|
||
{
|
||
codart = codalt.get("CODART");
|
||
anamag.zero();
|
||
anamag.put("CODART", codart);
|
||
if (anamag.read() == NOERR)
|
||
f.set(codart);
|
||
}
|
||
}
|
||
|
||
if (anamag.good())
|
||
{
|
||
const TString16 lingua = mask.get(F_CODLIN);
|
||
const TString codart(row_mask.get(FR_CODART));
|
||
TString desc(anamag.get("DESCR"));
|
||
|
||
if (lingua.not_empty())
|
||
{
|
||
TLocalisamfile deslin(LF_DESLIN);
|
||
|
||
deslin.setkey(2);
|
||
deslin.put("CODART", codart);
|
||
deslin.put("CODLIN", lingua);
|
||
if (deslin.read() == NOERR)
|
||
desc = deslin.get("DESCR");
|
||
}
|
||
row_mask.set(FR_DESCR, desc);
|
||
|
||
umart.setkey(1);
|
||
umart.zero();
|
||
umart.put("CODART", codart);
|
||
if (umart.read(_isgteq) == NOERR && codart == umart.get("CODART"))
|
||
{
|
||
curr_um = umart.get("UM");
|
||
curr_fc = umart.get_real("FC");
|
||
}
|
||
else
|
||
{
|
||
curr_um.cut(0);
|
||
curr_fc = 1.0;
|
||
}
|
||
row_mask.set(FR_UMQTA, curr_um);
|
||
}
|
||
|
||
condv.ricerca();
|
||
const int pos = row_mask.id2pos(FR_CODIVA);
|
||
|
||
if (pos >= 0)
|
||
iva_handler(row_mask.fld(pos), 0);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool liv_handler( TMask_field& f, KEY key )
|
||
{
|
||
if (f.to_check(key, TRUE))
|
||
{
|
||
TMask& row_mask = f.mask();
|
||
TMask_field & next = row_mask.field(f.dlg() + 1);
|
||
if (f.get().not_empty())
|
||
next.enable();
|
||
else
|
||
{
|
||
next.reset();
|
||
next.disable();
|
||
}
|
||
next.on_hit();
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool umart_handler( TMask_field& f, KEY key )
|
||
{
|
||
// Se qualcuno cerca di modificare la maschera
|
||
if ( key == K_TAB && f.focusdirty())
|
||
{
|
||
TMask& row_mask = f.mask( );
|
||
TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
|
||
TLocalisamfile & anamag = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file();
|
||
TLocalisamfile & umart = ((TEdit_field &) f).browse()->cursor()->file();
|
||
TCond_vendita & condv = mask.condv();
|
||
|
||
condv.set_testa(&mask);
|
||
condv.set_riga(&row_mask);
|
||
condv.set_anamag(anamag);
|
||
condv.set_umart(umart);
|
||
condv.ricerca(TRUE);
|
||
|
||
const TString16 um(f.get());
|
||
real fc(1.0);
|
||
|
||
if (um.not_empty() && curr_um.not_empty() && um != curr_um)
|
||
{
|
||
umart.setkey(2);
|
||
umart.put("CODART", row_mask.get(FR_CODART));
|
||
umart.put("UM", um);
|
||
if (umart.read() == NOERR)
|
||
{
|
||
real qta(row_mask.get_real(FR_QTA));
|
||
qta *= curr_fc;
|
||
fc = umart.get_real("FC");
|
||
qta /= fc;
|
||
row_mask.set(FR_QTA, qta);
|
||
}
|
||
|
||
}
|
||
curr_um = um;
|
||
curr_fc = fc;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool descr_handler( TMask_field& f, KEY key )
|
||
{
|
||
if (key == K_TAB && f.focusdirty())
|
||
{
|
||
const TString s(f.get());
|
||
if (s.find('\n') < 0)
|
||
{
|
||
TLocalisamfile & anamag = ((TEdit_field &) f).browse()->cursor()->file();
|
||
|
||
anamag.zero();
|
||
anamag.setkey(2);
|
||
anamag.put("DESCR", ((TZoom_field &) f).get_first_line());
|
||
if (anamag.read() == NOERR)
|
||
{
|
||
f.mask().set(FR_CODART, anamag.get("CODART"));
|
||
f.mask().field(FR_CODART).set_dirty();
|
||
f.mask().check_field(FR_CODART);
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool qta_handler( TMask_field& f, KEY key )
|
||
{
|
||
// Se qualcuno cerca di modificare la maschera
|
||
if ( key == K_TAB && f.focusdirty())
|
||
{
|
||
TMask& row_mask = f.mask( );
|
||
TDocumento_mask & mask = (TDocumento_mask &) row_mask.get_sheet()->mask();
|
||
TLocalisamfile & anamag = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file();
|
||
TLocalisamfile & umart = ((TEdit_field &) row_mask.field(FR_UMQTA)).browse()->cursor()->file();
|
||
TCond_vendita & condv = mask.condv();
|
||
|
||
condv.set_testa(&mask);
|
||
condv.set_riga(&row_mask);
|
||
condv.set_anamag(anamag);
|
||
condv.set_umart(umart);
|
||
condv.ricerca(FALSE, TRUE);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void sppr_calc(TRectype & rec, const TString & valuta_doc, const real & cambio, real & prezzo)
|
||
{
|
||
const TString16 sppr_valuta(rec.get("S4"));
|
||
|
||
if (sppr_valuta != valuta_doc && cambio != 0.0)
|
||
{
|
||
TTable val("%VAL");
|
||
|
||
val.put("CODTAB", sppr_valuta);
|
||
if (val.read() == NOERR)
|
||
{
|
||
const real sppr_cambio = val.get_real("R10");
|
||
if (sppr_cambio != ZERO)
|
||
prezzo *= sppr_cambio;
|
||
}
|
||
prezzo /= cambio;
|
||
}
|
||
}
|
||
|
||
bool sppr_handler( TMask_field& f, KEY key )
|
||
{
|
||
TMask& row_mask = f.mask();
|
||
|
||
if (key == K_TAB && (f.focusdirty() || row_mask.get(FR_DESCR).empty()))
|
||
{
|
||
const int pos = row_mask.id2pos(FR_PREZZO);
|
||
|
||
if (pos >= 0)
|
||
{
|
||
TMask & mask = row_mask.get_sheet()->mask();
|
||
TRectype & spprrec = ((TEdit_field &) row_mask.field(FR_CODART)).browse()->cursor()->file().curr();
|
||
|
||
if (spprrec.get("CODTAB") == row_mask.get(FR_CODART) && spprrec.get_char("S6") != 'P')
|
||
{
|
||
const real cambio = mask.get(F_CAMBIO);
|
||
real prezzo = row_mask.get(FR_PREZZO);
|
||
const TString16 doc_valuta(mask.get(F_CODVAL));
|
||
sppr_calc(spprrec, doc_valuta, cambio, prezzo);
|
||
row_mask.set(FR_PREZZO, prezzo);
|
||
const int posiva = row_mask.id2pos(FR_CODIVA);
|
||
if (posiva >= 0)
|
||
iva_handler(row_mask.fld(posiva), 0);
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// Funzioni per il calcolo dei prezzi netti/lordi
|
||
///////////////////////////////////////////////////////////
|
||
|
||
real lordo2netto(real& lordo, const TString& codiva, int ndec)
|
||
{
|
||
TTable tabiva("%IVA");
|
||
real aliquota = 0.0;
|
||
|
||
tabiva.put("CODTAB", codiva);
|
||
if (tabiva.read() == NOERR) aliquota = tabiva.get_real("R0");
|
||
|
||
return lordo2netto(lordo,aliquota, ndec);
|
||
}
|
||
|
||
real netto2lordo(const real& netto, const TString& codiva, int ndec)
|
||
{
|
||
TTable tabiva("%IVA");
|
||
real aliquota = 0.0;
|
||
|
||
tabiva.put("CODTAB", codiva);
|
||
if (tabiva.read() == NOERR) aliquota = tabiva.get_real("R0");
|
||
|
||
return netto2lordo(netto,aliquota, ndec);
|
||
}
|
||
|
||
real lordo2netto(real& lordo, const real& iva, int ndec)
|
||
{
|
||
real netto;
|
||
real imposta = 0.0;
|
||
real imposta_rec = 0.0;
|
||
if (!iva.is_zero())
|
||
{
|
||
imposta = (lordo * iva) / (iva + 100.0); // Calcola l'imposta...
|
||
if (imposta < ZERO)
|
||
imposta.floor(ndec);
|
||
else
|
||
imposta.ceil(ndec);
|
||
}
|
||
netto = lordo - imposta; // Questo e' l'importo netto
|
||
imposta_rec = (netto * iva) / 100.0; // Ricalcola l'imposta con il nuovo imponibile
|
||
if (imposta_rec < ZERO)
|
||
imposta_rec.floor(ndec);
|
||
else
|
||
imposta_rec.ceil(ndec);
|
||
if (imposta != imposta_rec) // In questo caso corregge l'importo lordo
|
||
lordo = netto + imposta_rec;
|
||
return netto;
|
||
}
|
||
|
||
real netto2lordo(const real& netto, const real& iva, int ndec)
|
||
{
|
||
real lordo;
|
||
real imposta = 0.0;
|
||
if (!iva.is_zero())
|
||
{
|
||
imposta = (netto * iva) / 100.0; // Calcola l'imposta
|
||
if(imposta < ZERO)
|
||
imposta.floor(ndec);
|
||
else
|
||
imposta.ceil(ndec);
|
||
}
|
||
lordo = imposta + netto; // prezzo lordo
|
||
return lordo;
|
||
}
|
||
|
||
real prezzo_scontato(const real& prezzo, const char * sconto)
|
||
{
|
||
real scontato = prezzo;
|
||
|
||
if (sconto && *sconto)
|
||
{
|
||
TCond_vendita cv;
|
||
|
||
cv.set_sconto(sconto);
|
||
scontato = cv.sconto_val() * prezzo;
|
||
}
|
||
return scontato;
|
||
}
|
||
|
||
real iva(real imponibile, const TIVA & iva,int ndec)
|
||
{
|
||
real val = imponibile * iva.aliquota() / 100.0;
|
||
|
||
if (ndec < 20)
|
||
{
|
||
if (val < ZERO)
|
||
val.floor(ndec);
|
||
else
|
||
val.ceil(ndec);
|
||
}
|
||
return val;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// Formula generica
|
||
///////////////////////////////////////////////////////////
|
||
|
||
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;
|
||
else
|
||
if (strcmp(name, "BOLLI") == 0)
|
||
return nparms > 0 || nparms < 4 ? _bolli : -1;
|
||
else
|
||
if (strcmp(name, "_BOLLI") == 0)
|
||
return nparms > 0 || nparms < 3 ? _bolli_int : -1;
|
||
else
|
||
if (strcmp(name, "SPESEINC") == 0)
|
||
return nparms > 0 || nparms < 4 ? _spinc : -1;
|
||
else
|
||
if (strcmp(name, "PREZZO") == 0)
|
||
return nparms < 4 ? _prezzo : -1;
|
||
else
|
||
if (strcmp(name, "IMPORTO") == 0)
|
||
return nparms < 4 ? _importo : -1;
|
||
else
|
||
if (strcmp(name, "SCONTO") == 0)
|
||
return nparms < 2 ? _sconto : -1;
|
||
else
|
||
if (strcmp(name, "IVA") == 0)
|
||
return nparms < 2 ? _iva : -1;
|
||
else
|
||
if (strcmp(name, "PROVV") == 0)
|
||
return nparms < 2 ? _provv : -1;
|
||
else
|
||
if (strcmp(name, "TIPO") == 0)
|
||
return nparms == 0 ? _tipo : -1;
|
||
else
|
||
if (strcmp(name, "IMPONIBILI") == 0)
|
||
return nparms < 3 ? _imponibili : -1;
|
||
else
|
||
if (strcmp(name, "IMPOSTE") == 0)
|
||
return nparms < 3 ? _imposte : -1;
|
||
else
|
||
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 & fieldname = stack.pop_string();
|
||
real somma;
|
||
|
||
if (_doc != NULL)
|
||
{
|
||
TExpr_documento cond_expr(cond, _strexpr, _doc);
|
||
const int nrows = _doc->rows();
|
||
const int nvars = cond_expr.numvar();
|
||
|
||
for (int i = nrows; i > 0 ; i--)
|
||
{
|
||
TRiga_documento & riga = (TRiga_documento &) (*_doc)[i];
|
||
|
||
for (int j = 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)
|
||
somma += riga.get_real(fieldname);
|
||
}
|
||
}
|
||
stack.push(somma);
|
||
}
|
||
break;
|
||
case _spinc:
|
||
{
|
||
int ndec = _doc && _doc->in_valuta() ? 3 : 0;
|
||
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 = _doc && _doc->in_valuta() ? 3 : 0;
|
||
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 = _doc && _doc->in_valuta() ? 3 : 0;
|
||
|
||
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 = _doc && _doc->in_valuta() ? 3 : 0;
|
||
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 = _doc && _doc->in_valuta() ? 3 : 0;
|
||
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 _sconto:
|
||
{
|
||
int ndec = _doc && _doc->in_valuta() ? 3 : 0;
|
||
|
||
if (nparms > 0)
|
||
ndec = (int) stack.peek_real().integer();
|
||
else
|
||
stack.push(ZERO);
|
||
|
||
real & val = stack.peek_real();
|
||
if (_row)
|
||
{
|
||
if (_row->tipo().tipo() == RIGA_SCONTI)
|
||
val = -_row->importo(FALSE, FALSE, ndec);
|
||
else
|
||
val = _row->importo(FALSE, FALSE, ndec) - _row->importo(TRUE, FALSE, ndec);
|
||
}
|
||
else
|
||
val = ZERO;
|
||
}
|
||
break;
|
||
case _iva:
|
||
{
|
||
int ndec = _doc && _doc->in_valuta() ? 3 : 0;
|
||
|
||
if (nparms > 0)
|
||
ndec = (int) stack.peek_real().integer();
|
||
else
|
||
stack.push(ZERO);
|
||
|
||
real & val = stack.peek_real();
|
||
|
||
if (_row)
|
||
val = _row->imposta();
|
||
else
|
||
val = ZERO;
|
||
}
|
||
break;
|
||
case _provv:
|
||
{
|
||
int ndec = _doc && _doc->in_valuta() ? 3 : 0;
|
||
|
||
if (nparms > 0)
|
||
ndec = (int) stack.peek_real().integer();
|
||
else
|
||
stack.push(ZERO);
|
||
|
||
real & val = stack.peek_real();
|
||
|
||
if (_row)
|
||
{
|
||
val = _row->importo(TRUE, FALSE, ndec) * _row->get_real("PERCPROV") / 100.0;
|
||
val.round(ndec);
|
||
}
|
||
else
|
||
val = ZERO;
|
||
}
|
||
break;
|
||
case _tipo:
|
||
{
|
||
TString s;
|
||
if (_row)
|
||
s << _row->tipo().tipo();
|
||
stack.push(s);
|
||
}
|
||
break;
|
||
case _imponibili:
|
||
{
|
||
int ndec = _doc && _doc->in_valuta() ? 3 : 0;
|
||
bool spese = FALSE;
|
||
|
||
if (nparms > 1)
|
||
ndec = (int) stack.pop_real().integer();
|
||
if (nparms > 0)
|
||
spese = !stack.pop_real().is_zero();
|
||
else
|
||
stack.push(ZERO);
|
||
real & val = stack.peek_real();
|
||
val = _doc->imponibile(spese, ndec);
|
||
}
|
||
break;
|
||
case _imposte:
|
||
{
|
||
int ndec = _doc && _doc->in_valuta() ? 3 : 0;
|
||
bool spese = FALSE;
|
||
|
||
if (nparms > 1)
|
||
ndec = (int) stack.pop_real().integer();
|
||
if (nparms > 0)
|
||
spese = !stack.pop_real().is_zero();
|
||
else
|
||
stack.push(ZERO);
|
||
real & val = stack.peek_real();
|
||
val = _doc->imposta(spese, ndec);
|
||
}
|
||
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 generica
|
||
///////////////////////////////////////////////////////////
|
||
|
||
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");
|
||
_expr = new TExpr_documento(expr_string(), expr_type());
|
||
}
|
||
|
||
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 TString e(expr_string());
|
||
|
||
_expr = new TExpr_documento(e, expr_type());
|
||
}
|
||
else
|
||
{
|
||
zero();
|
||
put("CODTAB", codice);
|
||
}
|
||
return err;
|
||
}
|
||
|
||
|