root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib01a.cpp
alex 2cc5c59b38 Sostituito il file vefields.wri con il file vefields.txt 
Sostituite le tabelle Agenti e Provvigioni con i rispettivi archivi.
!!! Devono essere sostituite sui menu e si devono controllare di conseguenza
    i moduli statistiche di vendita e magazzino !!!
Modificato il meccanismo di ricerca delle percentuali di provvigione.
Bisogna testare tutte le combinazioni basandosi sulle possibilita' offerte
dal nuovo archivio agenti. Per quanto riguarda il valore della provvigione
alla percentuale di base viene aggiunta la percentuale reperita con la
sequenza alternativa definita sull'archivio agenti.
Aggiunto il metodo agente sui documenti.
Aggiunto sui tipi documento il flag attivo per le provvigioni di ovvio
significato e lo stato a partire dal quale si debbono memorizzare le
provvigioni.
Aggiunta la funzione TOTPROVV(ndec = AUTO_DECIMALS) per i documenti.
Restituisce il valore totale delle provvigioni tenedo conto anche del campo
provvigioni definito per l'agente. !!! Deve essere utilizzato solo per avere
il valore della provvigione da utilizzare in un calcolo e non per visualizzare
o calcolare la provvigione stessa.
Aggiunta definizione del campo provvigione della riga (PROVV=....) nei
profili riga dei documenti per definire la provvigione della riga quando
non e' il default (importo scontato * percentuale di provvigione della
riga). Aggiunto il metodo provvigioni alle righe.
Aggiunta definizione del campo provvigione del documento (TOTPROVV=....)
nei profili documento per definire la provvigione totale quando non e' il
default (somma delle provvigioni della riga). Il campo che viene definito
come totale delle provvigioni non puo' contenere la funzione TOTPROVV.
Aggiunto il metodo provvigione del documento.


git-svn-id: svn://10.65.10.50/trunk@5478 c028cbd2-c16b-5b4b-a496-9718f37d4682
1997-10-29 11:08:40 +00:00

910 lines
24 KiB
C++
Executable File
Raw Blame History

#include "velib.h"
#include "vepriv.h"
#ifndef __TABUTIL_H
#include <tabutil.h>
#endif
#ifndef __VERIG_H
#include "verig.h"
#endif
#ifndef __VEUML1_H
#include "veuml1.h"
#endif
#ifndef __VEINI_H
#include "veini.h"
#endif
#ifndef __URLDEFID_H
#include <urldefid.h>
#endif
#ifndef __SCONTI_H
#include "sconti.h"
#endif
#include "../mg/anamag.h"
#include "../mg/codcorr.h"
#include "../mg/deslin.h"
#include "../mg/umart.h"
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 è 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 (field.to_check(key))
{
TEdit_field & e = m.efield(F_DATAINSC);
e.set_dirty();
e.on_hit();
}
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(DOC_CODNUM));
const int anno = doc.get_int(DOC_ANNO);
const char tipo_num = doc.get_char(DOC_PROVV);
if (doc.read(_isgreat) == NOERR &&
codnum == doc.get(DOC_CODNUM) &&
anno == doc.get_int(DOC_ANNO) &&
tipo_num == doc.get_char(DOC_PROVV) &&
datadoc > doc.get_date(DOC_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(DOC_CODNUM) &&
anno == doc.get_int(DOC_ANNO) &&
tipo_num == doc.get_char(DOC_PROVV) &&
datadoc < doc.get_date(DOC_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().vendite().get(CFV_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_CHECKED).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(ANAMAG_CODART, codart);
bool found = anamag.read() == NOERR;
if (found)
row_mask.set(FR_CODARTMAG, codart, TRUE);
else
{
TLocalisamfile codalt(LF_CODCORR);
codalt.setkey(2);
codalt.put(CODCORR_CODARTALT, codart);
if (codalt.read() == NOERR)
{
codart = codalt.get(CODCORR_CODART);
anamag.zero();
anamag.put(ANAMAG_CODART, codart);
found = anamag.read() == NOERR;
if (found)
row_mask.set(FR_CODARTMAG, codart, TRUE);
}
}
row_mask.set(FR_CHECKED, "X");
if (!found)
row_mask.set(FR_CODARTMAG, "", TRUE);
else
{
const TString16 lingua = mask.get(F_CODLIN);
const TString codart(row_mask.get(FR_CODARTMAG));
TString desc(anamag.get("DESCR"));
if (lingua.not_empty())
{
if (mask.doc()[((TSheet_field &)mask.field(F_SHEET)).selected() + 1].is_omaggio())
desc << " (OMAGGIO)";
TLocalisamfile deslin(LF_DESLIN);
deslin.setkey(2);
deslin.put(DESLIN_CODART, codart);
deslin.put(DESLIN_CODLIN, lingua);
if (deslin.read() == NOERR)
desc << '\n' << deslin.get(DESLIN_DESCR);
}
row_mask.set(FR_DESCR, desc);
umart.setkey(1);
umart.zero();
umart.put(UMART_CODART, codart);
if (umart.read(_isgteq) == NOERR && codart == umart.get(UMART_CODART))
{
curr_um = umart.get(UMART_UM);
curr_fc = umart.get_real(UMART_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 codartmag_handler( TMask_field& f, KEY key )
{
bool to_check = key == K_TAB && f.focusdirty();
TMask & m = f.mask();
if (!to_check)
{
TSheet_field * s = m.get_sheet();
if (s)
to_check = !s->mask().is_running();
}
if (to_check)
{
const bool artmag = f.get().not_empty();
m.show(FR_UMQTA, artmag);
m.show(FR_UMQTA2, !artmag);
}
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;
}
void set_curr_um(const TMask & m)
{
curr_um = m.get(FR_UMQTA);
curr_fc = -1.0;
}
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);
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(UMART_CODART, row_mask.get(FR_CODARTMAG));
umart.put(UMART_UM, um);
if (umart.read() == NOERR)
{
real qta(row_mask.get_real(FR_QTA));
fc = umart.get_real(UMART_FC);
if (curr_fc < ZERO)
{
umart.put(UMART_CODART, row_mask.get(FR_CODARTMAG));
umart.put(UMART_UM, curr_um);
if (umart.read() == NOERR)
curr_fc = umart.get_real(UMART_FC);
else
curr_fc = 1.0;
}
qta *= curr_fc;
qta /= fc;
qta.round(5);
row_mask.set(FR_QTA, qta);
}
}
curr_um = um;
curr_fc = fc;
condv.ricerca(TRUE);
}
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(ANAMAG_DESCR, ((TZoom_field &) f).get_first_line());
if (anamag.read() == NOERR)
{
f.mask().set(FR_CODART, anamag.get(ANAMAG_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;
}
// calcola il prezzo per le spese
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))
{
const char tipo = spprrec.get_char("S6");
const bool qta_val_fl = tipo == 'Q';
const bool perc_fl = tipo == 'P';
short pos = row_mask.id2pos(FR_UMQTASP);
if (pos >= 0)
row_mask.fld(pos).enable(!perc_fl);
pos = row_mask.id2pos(FR_PREZZO);
if (pos >= 0)
row_mask.fld(pos).enable(!perc_fl);
pos = row_mask.id2pos(FR_SCONTO);
if (pos >= 0)
row_mask.fld(pos).enable(!perc_fl);
pos = row_mask.id2pos(FR_QTA);
if (pos >= 0)
{
row_mask.fld(pos).show(!perc_fl);
row_mask.fld(pos).enable(qta_val_fl);
}
pos = row_mask.id2pos(FR_PERCSP);
if (pos >= 0)
{
row_mask.fld(pos).show(perc_fl);
row_mask.fld(pos).enable(perc_fl);
}
if (!perc_fl)
{
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;
}
///////////////////////////////////////////////////////////
// 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, "IMPONIBILE") == 0)
return nparms == 0 ? _imponibile : -1;
else
if (strcmp(name, "IVA") == 0)
return nparms == 0 ? _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
if (strcmp(name, "TOTPROVV") == 0)
return nparms < 3 ? _totprovv : -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 & 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 += (real)expr;
}
}
}
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 _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;
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;
}
Reference in New Issue View Git Blame Copy Permalink