root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib.h
alex 70df6de698 Patch level : 3.2.1700 
Files correlati     : ve0.exe ve6.exe
Ricompilazione Demo : [ ]
Commento            :

La fatturazione bolle se sono attivate le lettere d'intento aggioran il codcie IVA nella fattura se non e' corretto.


git-svn-id: svn://10.65.10.50/branches/R_10_00@22320 c028cbd2-c16b-5b4b-a496-9718f37d4682
2011-06-24 12:28:22 +00:00

1141 lines
43 KiB
C++
Executable File
Raw Blame History

#ifndef __VELIB_H
#define __VELIB_H
#ifndef __VARMASK_H
#include <varmask.h>
#endif
#ifndef __MULTIREC_H
#include <multirec.h>
#endif
#ifndef __RECSET_H
#include <recset.h>
#endif
#ifndef __VISWIN_H
class TViswin;
#endif
#ifndef __CLIFOR_H
#include "../ve/clifor.h"
#endif
#ifndef __VERIG_H
#include "../ve/verig.h"
#endif
#ifndef __CGLIB01_H
#include "../cg/cglib01.h"
#endif
#ifndef __CGPAGAME_H
#include "../cg/cgpagame.h"
#endif
#ifndef __PRLIB_H
class TProvvigioni_agente;
#endif
#ifndef __MGLIB_H
#include "../mg/mglib.h"
#endif
#ifndef __COLMASK_H
class TSelect_color_mask;
#endif
#ifndef __DOC_H
#include <doc.h>
#endif
#ifndef __RDOC_H
#include <rdoc.h>
#endif
#ifndef __CG2101_H
#include "../cg/cg2101.h"
#endif
#define RIGA_MERCE 'M'
#define RIGA_SPESEDOC 'S'
#define RIGA_PRESTAZIONI 'P'
#define RIGA_RISORSE 'R'
#define RIGA_ATTREZZATURE 'A'
#define RIGA_SCONTI 'C'
#define RIGA_OMAGGI 'O'
#define RIGA_DESCRIZIONI 'D'
#define RIGA_RETTIFICHE 'T'
#define MAX_IVA_SLICES 5
class TDocumento;
class TRiga_documento;
class TCond_vendita;
class TIVA_array;
class TArticolo_giacenza;
class TCache_articoli;
class TSmart_card;
bool is_real_discount(const TString& exp);
bool scontoexpr2perc(const char* exp, bool signal , TString& goodexp, real & val_perc );
real prezzo_scontato(const real& prezzo, const TString& sconto);
bool ora_hndl(TMask_field& field, KEY key);
bool totdoc_hndl(TMask_field& field, KEY key);
bool codcli_hndl(TMask_field& field, KEY key);
bool dummy_hndl(TMask_field& field, KEY key);
bool condpag_hndl(TMask_field& field, KEY key);
bool note_hndl(TMask_field& field, KEY key);
bool data_hndl(TMask_field& field, KEY key);
void set_curr_um(const TString& um);
class TDocumento_variable_field : public TVariable_field
{
bool _dirty;
public:
virtual TObject* dup() const { return new TDocumento_variable_field(*this); }
// @cmember segnala che il campo deve essere ricalcolato
virtual bool dirty() const { return _dirty; }
// @cmember assegna lo stato di campo da ricalcolare
virtual void set_dirty(bool on = true) { _dirty = on; }
// @ cmember Costruttore con una espressione di calcolo
TDocumento_variable_field(const char * name, const char * expr = "", TTypeexp type = _strexpr)
: TVariable_field(name, expr, type), _dirty(true) {}
// @ cmember Costruttore con una funzione
TDocumento_variable_field(const char * name, VIRTUAL_GET_FUNCTION getfunc)
: TVariable_field(name, getfunc), _dirty(true) {}
// @ cmember Costruttore con una espressione di calcolo
TDocumento_variable_field(const char * name, const TExpression & expr, TTypeexp type = _strexpr)
: TVariable_field(name, expr, type), _dirty(true) {}
// @ cmember Costruttore con un variable_field
TDocumento_variable_field(const TVariable_field & f) : TVariable_field(f), _dirty(true) {}
// @ cmember Distruttore
virtual ~TDocumento_variable_field() {}
};
class TSpesa_prest : public TRectype // velib01
{
public:
TObject* dup() const { return new TSpesa_prest(codice()); }
public:
int read(const char* codice);
const TString& codice() const { return get("CODTAB"); }
char tipo() const { return get_char("S6"); }
bool is_qtavalore() const { return tipo() == 'V'; }
bool is_tipo() const { return tipo() == 'Q'; }
bool is_percentuale() const { return tipo() == 'P'; }
const TString& descrizione() const { return get("S0"); }
const TString& field_perc() const { return get("S5"); } // Solo spese
const TString& revenue() const { return get("S5"); } // Solo attrezzature e risorse
const TString& um() const { return get("S7"); }
const TString& cod_iva() const; // S3
real prezzo() const; // R10 o R0
real qta() const { return get_real("R1"); }
real perc() const { return get_real("R2"); }
char tipo_ritenuta() const { return get_char("S9"); }
const TString& tipo_riga() const { return get("S8"); }
char genere() const;
const TString& conto_analitico_vendite() const { return get("S1").left(20); }
const TString& conto_analitico_acquisti() const { return get("S2"); }
const TString& cdc() const { return get("S1").mid(20, 20); }
const TString& cms() const { return get("S1").mid(40, 20); }
const TString& fase() const { return get("S1").mid(60); }
const int caus_770() const { return get_int("I6"); }
TSpesa_prest(const char* codice = NULL, char tipo = 'S');
TSpesa_prest(const TRectype& rec);
virtual ~TSpesa_prest() {}
};
class TExpr_documento : public TExpression // velib01
{
TDocumento * _doc;
TRiga_documento * _row;
protected:
virtual void evaluate_user_func(int index, int nparms, TEval_stack & stack, TTypeexp type) const;
virtual int parse_user_func(const char * name, int nparms) const;
public:
// @cmember Duplica l'espressione
virtual TObject* dup() const;
// @cmember Assegna il documento corrente
void set_doc(TDocumento* doc) { _doc = doc; }
// @cmember Assegna il documento corrente
void set_row(TRiga_documento* row) { _row = row; }
// @cmember Costruttore (assegna l'estressione e il suo tipo)
TExpr_documento(const char* expression, TTypeexp type = _numexpr,
TDocumento* doc = NULL, TRiga_documento * row = NULL);
// @cmember Costruttore (assegna il tipo dell'istruzione)
TExpr_documento(TTypeexp type = _numexpr,
TDocumento* doc = NULL, TRiga_documento* row = NULL)
: TExpression(type, true), _doc(doc), _row(row) {}
// @cmember Costruttore di copia
TExpr_documento(const TExpr_documento & expr)
: TExpression(expr), _doc(expr._doc), _row(expr._row) {}
// @cmember Distruttore
virtual ~TExpr_documento() {}
};
enum TTipo_formula { _documento, _riga };
class TFormula_documento : public TRectype // velib01
{
TString4 _tab;
TExpr_documento* _expr;
protected:
int read(const char* codice, const char* expr = NULL, bool numexpr = true);
public:
TObject* dup() const { return new TFormula_documento(_tab == "%FRD" ? _documento : _riga, codice(), NULL, true); }
const TString& codice() const { return get("CODTAB");}
const TString& name() const { return codice(); }
TExpr_documento* expr() const { return _expr;}
const TString& descrizione() const { return get("S0"); }
const TString& expr_string() const { return get("S1"); }
TTypeexp expr_type() const { return get_bool("B0") ? _numexpr : _strexpr;}
TFormula_documento(TTipo_formula tipo = _documento, const char* codice = NULL, const char* expr = NULL, bool numexpr = true);
TFormula_documento(const TRectype& rec);
virtual ~TFormula_documento();
};
class TTipo_documento : public TRectype // velib03
{
static TAssoc_array _formule_documento;
TToken_string _formule;
TString_array _keys_descrs; // Tipi riga per listbox
TString_array _defaults; // Defaults per i campi della maschera
TString_array _sheet_columns; // Colonne dello spreadsheet
TString_array _handlers; // Handlers
TString16 _imponibile;
TString16 _imposta;
TString16 _totale;
TString16 _totale_netto;
TString16 _basesconto;
TString16 _spese;
TString16 _totprovv;
TString16 _totprovv1;
TString16 _valore;
TString16 _totvalres;
TString16 _totvalore;
TString16 _totale_cont;
TString16 _field_prezzo;
TString16 _field_qta, _field_qtaevasa; // Veri campi Quantit<69> e Quantit<69> Evasa
TString16 _field_qta_mag, _field_qtaevasa_mag; // Veri campi Quantit<69> e Quantit<69> Evasa per magazzino
TString16 _raee_cod, _raee_fld;
TString _str_desc_doc, _str_desc_rdoc;
int _liv, _row;
TString4 _module;
char _tipocf;
char _tipocr;
char _check_qta;
bool _cnt_prezzi, _show_evaded_lines, _load_cont, _non_evadere, _hca_req, _check_double_art;
protected:
void add_formula_if_needed(TConfig& profile, TString& variable, const char* varname, const char* formula);
void read_formule();
int read(const char* tipodoc);
public:
enum { _altro, _bolla, _fattura, _ordine, _scontrino};
TObject* dup() const { return new TTipo_documento(codice()); }
const TFilename& profile_name(TFilename& name) const;
// Funzioni che effettuano la cache di importanti valori contenuti nel profilo
const char tipocf() const;
void set_defaults(TMask& m) const;
const TString_array& keys_descrs() const;
const TString_array& sheet_columns() const;
const TString_array& handlers() const;
const TString& mask_name() const;
const TString& causale() const { return get("S6"); }
int tipo() const { return get_int("I1"); }
const TString& codice() const { return get("CODTAB");}
bool is_generic() const { return tipo() == _altro; }
bool is_fattura() const { return tipo() == _fattura; }
bool is_bolla() const { return tipo() == _bolla; }
bool is_ordine() const { return tipo() == _ordine; }
bool is_scontrino() const { return tipo() == _scontrino; }
bool controllo_prezzi() const { return _cnt_prezzi; }
const char * field_prezzo() const { return _field_prezzo; }
const TString& field_qta() const { return _field_qta; }
const TString& field_qtaevasa() const { return _field_qtaevasa; }
const TString& field_qta_mag() const { return _field_qta_mag; }
const TString& field_qtaevasa_mag() const { return _field_qtaevasa_mag; }
bool check_giac() const { return _check_qta == 'G'; }
bool check_disp() const { return _check_qta == 'D'; }
bool load_cont() const { return _load_cont; }
const TString& raee_cod() const { return _raee_cod; }
const TString& raee_fld() const { return _raee_fld; }
const int dbliv() const { return _liv; }
const int dbrow() const { return _row; }
const TString & descrizione() const { return get("S0"); }
const TString & riferimento(const TDocumento& doc, TString& rif) const;
const TString & imponibile() const { return _imponibile;}
const TString & imposta() const { return _imposta;}
const TString & totale_doc() const { return _totale;}
const TString & totale_netto() const { return _totale_netto; }
const TString & totale_doc_cont() const { return _totale_cont;}
const TString & basesconto() const { return _basesconto;}
const TString & spese() const { return _spese;}
const TString & totprovv() const { return _totprovv;}
const TString & totprovv1() const { return _totprovv1;}
const TString & valore() const { return _valore;}
const TString & totvalres() const { return _totvalres;}
const TString & totvalore() const { return _totvalore;}
bool mov_mag() const { return get_bool("B1"); }
bool statistiche() const { return get_bool("B2"); }
bool provvigioni() const { return get_bool("B3"); }
const char stato_mov_iniziale() const {return get_char("S7"); }
const char stato_mov_finale() const {return get_char("S8"); }
const char stato_provvigioni() const {return get("S3")[0]; }
const TString & elaborazione() const {return get("S3").mid(4,8); }
const TString & elaborazione_stampa() const {return get("S3").mid(12,8); }
const TString & caus_mov() const {return get("S9"); }
const TString & caus_anticipo() const {return get("S10"); }
const TString & tipi_iva_validi() const {return get("S11"); }
const char stato_finale_inserimento() const {return get("S2")[0]; }
const char stato_finale_stampa() const {return get("S2")[1]; }
const char stato_bloccato() const {return get("S2")[2]; }
const char stato_chiuso() const {return get("S2")[3]; }
const TString & stati_iniziali_modifica() const {return get("S2").mid(9,20); }
const TString & stati_iniziali_cancellazione() const {return get("S2").mid(29,20); }
const TString & stati_iniziali_stampa() const {return get("S2").mid(49,20); }
bool stato_with_mov_mag(const char stato) const;
bool scarica_residuo() const;
bool clifo_optional() const { return get_bool("B5"); }
bool printable() const { return get("S5").full(); }
bool main_print_profile(TFilename& report, int filter) const;
bool additional_print_profile(TFilename& report, int filter) const;
bool mail_print_profile(TFilename& report) const;
bool is_costo() const ;
bool is_ricavo() const ;
const TString & module() const { return _module; }
TFormula_documento* first_formula() { return succ_formula(true); }
TFormula_documento* succ_formula(bool restart = false);
const int ncopie() const { return get_int("I0"); }
const int additional_ncopie() const { return get_int("I2"); }
bool spese_aut() const { return get_bool("B0"); }
bool nota_credito() const { return get_bool("B7"); }
bool add_conai() const { return get_bool("B6"); }
bool calcolo_lordo() const { return get_bool("B8"); }
bool fattura_commerciale() const { return get_bool("B9"); }
bool allega_documenti() const { return get_bool("B10"); }
bool auto_add() const { return get_bool("B11"); }
const TString& stringa_descrizione_documento() const { return _str_desc_doc; }
const TString& stringa_descrizione_riga() const { return _str_desc_rdoc; }
bool mostra_righe_evase_in_elaborazione() const { return _show_evaded_lines; }
bool da_evadere() const { return !_non_evadere; }
bool head_ca_required() const { return _hca_req; }
bool check_double_art() const { return _check_double_art; }
TTipo_documento(const char* tipodoc = NULL);
TTipo_documento(const TRectype& rec);
virtual ~TTipo_documento();
};
const TTipo_documento& cached_tipodoc(const char* tipodoc);
class TCodice_numerazione : public TRectype //velib01
{
int _status;
public:
TObject* dup() const { return new TCodice_numerazione(*this); }
public:
int read(const char* cod);
const TString& codice() const { return get("CODTAB"); }
const TString& descrizione() const { return get("S0"); }
const TString& prefisso() const { return get("S6"); }
const TString& postfisso() const { return get("S7"); }
const bool num_provv() const { return get_bool("B0"); }
const bool auto_num() const { return get_bool("B1"); }
const bool dont_test_datadoc() const { return get_bool("B2"); }
const bool fattura_emettere_ricevere() const { return get_bool("B3"); }
const bool save_and_new() const { return get_bool("B4"); }
const bool test_eser() const { return !get_bool("B5"); }
const bool auto_archive() const { return get_bool("B6"); }
const bool newnumdef() const { return get_bool("B8"); }
const TString& codnumdef() const { return get("S8"); }
const TString& tipodocdef() const { return get("S9"); }
const int revision_len() const { return get_int("I0"); }
const TString& tipo_doc(int i) const;
int ntipi_doc() const;
void complete_num(long num, TString& codnum) const;
bool ok() const { return !empty(); }
TCodice_numerazione(const char* codnum = NULL);
TCodice_numerazione(const TRectype& rec);
virtual ~TCodice_numerazione();
};
const TCodice_numerazione& cached_numerazione(const char * codnum);
//metodi jolly per ricavare le numerazioni dati i tipi documento (ca3800,ca3900,ps1001,ha3800 ecc.) //velib01
int numerazioni_documenti(TString_array& num_doc, const TString& tipo_doc);
int numerazioni_documenti(TString_array& num_doc, TString_array& tip_doc, const int tipo);
int numerazioni_ordini(TString_array& num_ordini, TString_array& tip_ordini);
int numerazioni_fatture(TString_array& num_fatture, TString_array& tip_fatture);
class TTipo_riga_documento : public TRectype // velib02
{
static TAssoc_array _formule_riga;
TToken_string _formule;
TString_array _defaults;
TString16 _imponibile, _field_imposta;
TString16 _quant;
TString16 _quantevasa;
TString16 _qtares;
TString16 _valore;
TString16 _valres;
TString16 _field_provv;
TString16 _field_provv1;
TString16 _field_qta, _field_qtaevasa; // Veri campi Quantit<69> e Quantit<69> Evasa
TString16 _field_qta_mag, _field_qtaevasa_mag; // Veri campi Quantit<69> e Quantit<69> Evasa per magazzino
TToken_string _search_nums;
int _search_years;
int _max_rows_art;
bool _no_desc;
bool _extended_desc_search;
TToken_string _search_active_docs;
TToken_string _fields_to_update;
TToken_string _field_list;
TToken_string _header;
TToken_string _order;
bool _select_clifo;
TArray _genconf;
int _decrp, _incrp;
protected:
void read_formule();
void add_formula_if_needed(TConfig& profile, TString& variable,
const char* varname, const char* formula);
public:
TObject* dup() const { return new TTipo_riga_documento(codice()); }
public:
const TFilename& profile_name(TFilename& name) const;
const TString& mask_name(TString& name) const;
const TString& codice() const { return get("CODTAB");}
const TString& descrizione() const { return get("S0"); }
char tipo() const { return get_char("S7"); }
bool has_formula(const char* name) { return _formule.get_pos(name) >= 0; }
bool is_merce() const { return tipo() == RIGA_MERCE;}
bool is_spese() const { return tipo() == RIGA_SPESEDOC;}
bool is_prestazione() const { return tipo() == RIGA_PRESTAZIONI;}
bool is_risorsa() const { return tipo() == RIGA_RISORSE;}
bool is_attrezzatura() const { return tipo() == RIGA_ATTREZZATURE;}
bool is_sconto() const {return tipo() == RIGA_SCONTI;}
const TString& imponibile() const { return _imponibile;}
const TString& imposta() const { return _field_imposta;}
const TString& quant() const { return _quant;}
const TString& quantevasa() const { return _quantevasa;}
const TString& field_qta() const { return _field_qta;}
const TString& field_qtaevasa() const { return _field_qtaevasa;}
const TString& field_qta_mag() const { return _field_qta_mag;}
const TString& field_qtaevasa_mag() const { return _field_qtaevasa_mag;}
const int search_years() const { return _search_years;}
const TToken_string& search_nums() const { return _search_nums;}
const int max_rows_art() const { return _max_rows_art;}
bool no_desc() const { return _no_desc;}
bool extended_desc_search() const { return _extended_desc_search;}
TToken_string& search_active_docs() { return _search_active_docs;}
TToken_string& fields_to_update() { return _fields_to_update;}
TToken_string& field_list() { return _field_list;}
TToken_string& header() { return _header;}
TToken_string& order() { return _order;}
bool select_clifo() const { return _select_clifo;}
const TString& provv() const { return _field_provv;}
const TString& provv1() const { return _field_provv1;}
const int incr_perc_prezzo() const { return _incrp;}
const int decr_perc_prezzo() const { return _decrp;}
TToken_string * genconf(int i) const { return (TToken_string *) _genconf.objptr(i);}
bool formfeed() const { return get_bool("B0"); }
TFormula_documento* first_formula() { return succ_formula(true); }
TFormula_documento* succ_formula(bool restart = FALSE);
int read(const char* tiporig);
void set_defaults(TSheet_field& s, int row) const;
TTipo_riga_documento(const char* tiporig = NULL);
TTipo_riga_documento(const TRectype& rec);
virtual ~TTipo_riga_documento() { }
};
///////////////////////////////////////////////////////////
// Gestione CONAI
///////////////////////////////////////////////////////////
enum TCONAI_class { CONAI_NONE=-1, CONAI_FIRST=0,
CONAI_ACC=0, CONAI_ACCIAIO =0,
CONAI_ALL=1, CONAI_ALLUMINIO=1,
CONAI_CAR=2, CONAI_CARTA =2,
CONAI_PLA=3, CONAI_PLASTICA =3,
CONAI_LEG=4, CONAI_LEGNO =4,
CONAI_VET=5, CONAI_VETRO =5,
CONAI_LAST=5, CONAI_CLASSES=6
};
TCONAI_class conai_str2class(const char* class_or_subclass);
const char* conai_material(TCONAI_class cc);
bool conai_configured_class(TCONAI_class cc);
const char* conai_peso_name(TCONAI_class cc, int logic_num = LF_RIGHEDOC);
const char* conai_sottocat_name(TCONAI_class cc, int logic_num = LF_RIGHEDOC);
const char* conai_esenzione_name(TCONAI_class cc, int logicnum = LF_RIGHEDOC);
#define CHECK_CONAI(cc) CHECKD(cc>=CONAI_FIRST&&cc<CONAI_CLASSES, "Classe CONAI errata: ", cc)
#define FOR_EACH_CONAI_CLASS(cc) for (TCONAI_class cc = CONAI_FIRST; cc < CONAI_CLASSES; cc=TCONAI_class(cc+1))
#define FOR_EACH_CONFIGURED_CONAI_CLASS(cc) FOR_EACH_CONAI_CLASS(cc) if (conai_configured_class(cc))
///////////////////////////////////////////////////////////
// TRiga_documento
///////////////////////////////////////////////////////////
class TRiga_documento : public TAuto_variable_rectype // velib02
{
TDocumento* _doc;
static long _firm;
static TAssoc_array _tipi;
static TAssoc_array _spese;
static TAssoc_array _ive;
static int _iva_calc_mode;
static bool _rit_calc;
protected:
// @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
virtual void put_str(const char* fieldname, const char* val);
virtual TRiga_documento & copy(const TRiga_documento & r);
TObject* dup() const { return new TRiga_documento(*this); }
virtual void set_variables(TExpression * e) const ;
bool has_doc() const { return _doc != NULL;}
static void test_firm();
public:
void dirty_fields(bool dirty_document = true);
bool doc_dependent() const;
int numero() const { return get_int(RDOC_NRIGA); }
void set_numero(int numero) { put(RDOC_NRIGA, numero);}
bool is_generata() const { return get_bool(RDOC_GENERATA);}
void generata(bool on = true) { put(RDOC_GENERATA, on);}
bool is_merce() const { return tipo().tipo() == RIGA_MERCE;}
bool is_spese() const { return tipo().tipo() == RIGA_SPESEDOC;}
bool is_prestazione() const { return tipo().tipo() == RIGA_PRESTAZIONI;}
bool is_risorsa() const { return tipo().tipo() == RIGA_RISORSE;}
bool is_attrezzatura() const { return tipo().tipo() == RIGA_ATTREZZATURE;}
bool is_sconto() const {return tipo().tipo() == RIGA_SCONTI;}
bool is_sconto_perc() const { return is_sconto() && get(RDOC_SCONTO).not_empty();}
bool is_omaggio() const { return tipo().tipo() == RIGA_OMAGGI;}
bool is_descrizione() const { return tipo().tipo() == RIGA_DESCRIZIONI;}
bool is_articolo() const;
bool is_checked() const { return get_bool(RDOC_CHECKED);}
bool is_evadibile() const { return is_merce() || is_omaggio() ||
(is_spese() && !spesa().is_percentuale()) || is_prestazione(); }
bool is_evasa() const; // Ritorna vero se la riga <20> evasa
void checked(bool on = true) { put(RDOC_CHECKED, (bool)on); }
void unchecked() { checked(FALSE); }
bool linked() const { return get(RDOC_DACODNUM).not_empty();}
// @cmember Assegna il documento corrente
void set_doc(TDocumento * doc) { _doc = doc; }
virtual const TDocumento & doc() const { CHECK(_doc, "Documento nullo"); return *_doc;}
virtual bool edit(int logicnum = 0, const char * alternate_key_fields = NULL, const char* hint = NULL) const;
virtual void zero(const char * fieldname);
virtual void zero(char c = '\0');
void cms2tipodet();
// row -> sheet
void autoload(TSheet_field& f);
// sheet -> row
void autosave(TSheet_field& f);
const TTipo_riga_documento & tipo() const ;
static const TTipo_riga_documento & tipo(const char * tiporiga);
const TSpesa_prest & spesa() const;
static const TCodiceIVA & iva(const char * codice);
const TCodiceIVA & iva() const {const TString4 cod(get(RDOC_CODIVA)); return iva(cod);}
const bool tipo_valido() const { return get(RDOC_TIPORIGA).not_empty(); }
void set_tipo(const char * tipo) { put(RDOC_TIPORIGA, tipo);}
bool sola_descrizione() const;
void forza_sola_descrizione();
const TToken_string& get_rdoc_key() const;
const TToken_string& get_original_rdoc_key() const;
void set_original_rdoc_key(const TRectype& orig, int depth = 0);
void reset_original_rdoc_key();
const TRectype* find_original_rdoc() const;
const TRectype* find_original_doc() const;
virtual TRiga_documento& operator =(const TRiga_documento& r) { return copy(r);}
virtual TRectype& operator =(const TRectype & r);
virtual TRectype& operator =(const char * r);
bool cost2revenue();
bool raggruppabile(const TRiga_documento& r, TToken_string& campi) const;
TRiga_documento& operator +=(const TRiga_documento& r);
void reset_fields(TAuto_variable_rectype& rec) { rec.remove_field(); }
void set_fields(TAuto_variable_rectype& rec);
real prezzo(bool scontato, bool lordo, int ndec = AUTO_DECIMALS) const ;
real importo(bool scontato , bool lordo, int ndec = AUTO_DECIMALS) const ;
real sconto() const { return importo(FALSE,FALSE) - importo(true,FALSE); }
real iva(int ndec) const;
real imponibile(bool lordo = FALSE) const;
real imponibile_omaggio(int iva_calc_mode = 1) const;
real iva_omaggio(int ndec, int iva_calc_mode = 1) const;
real imposta(bool round = true) const;
real provvigione(bool first = true, int ndec = AUTO_DECIMALS) const;
real ritenuta(const char tipor = '\0', bool lordo = false, int ndec = AUTO_DECIMALS) const;
const TString& field_qta() const;
const TString& field_qtaevasa() const;
real quantita() const;
real qtaevasa() const;
real qtaresidua() const;
virtual const TString& field_qta_mag() const;
virtual const TString& field_qtaevasa_mag() const;
virtual real quantita_mag() const;
virtual real qtaevasa_mag() const;
virtual real qtaresidua_mag() const;
real calc_conai_qta(TCONAI_class type) const;
real valore(bool totale, bool lordo = false, int ndec = AUTO_DECIMALS) const;
const TString & codice_costo() const;
const TString & codice_commessa() const;
const TString & fase_commessa() const;
TArticolo & articolo() const;
TArticolo_giacenza & articolo_giacenza() const;
TRiga_documento(TDocumento* doc, const char* tipo = NULL);
TRiga_documento(const TRiga_documento & row);
/* Maialata inguardabile: guai a chi la riporta!
TRiga_documento(const TRiga_documento& rec, TDocumento* doc, const char* tipo = NULL); */
virtual ~TRiga_documento() {}
};
enum TTipo_importo { _lordo, _netto, _imposta };
class TRiepilogo_iva : public TObject
{
TCodiceIVA _codiva;
real _imp;
real _imp_orig;
real _imp_spese;
real _imp_spese_row;
real _iva;
real _iva_spese;
real _sconto_perc;
real _sconto_imp;
real _iva_sconto;
byte _tipo;
protected:
virtual TObject* dup() const { return new TRiepilogo_iva(*this); }
virtual TRiepilogo_iva & copy(const TRiepilogo_iva & a);
public:
real imponibile(bool spese = TRUE) const { return _imp + (spese ? _imp_spese : ZERO);} // Imponibile
real imposta(bool spese = TRUE) const { return _iva + (spese ? _iva_spese : ZERO);} // Iva
real & imp() { return _imp;};
real & imp_orig() { return _imp_orig;};
real & imp_spese() { return _imp_spese;};
real & imp_spese_row() { return _imp_spese_row;};
real & iva() { return _iva;};
real & iva_spese() { return _iva_spese;};
real & iva_sconto() { return _iva_sconto;};
const real & iva_sconto() const { return _iva_sconto;};
real & sconto_perc() { return _sconto_perc; }
const real& sconto_perc() const { return _sconto_perc; }
real & sconto_imp () { return _sconto_imp; }
const real & sconto_imp () const { return _sconto_imp; }
const TCodiceIVA & cod_iva() const { return _codiva;}
byte tipo(){ return _tipo;}// Tipo (Vedi opzioni per la selzione di filtro nella validate())
TRiepilogo_iva& operator = (const TRiepilogo_iva & a) {return copy(a);}
TRiepilogo_iva(const TCodiceIVA & codiva);
TRiepilogo_iva(const TRiepilogo_iva & a) {copy(a);}
TRiepilogo_iva() : _tipo(0) {}
~TRiepilogo_iva() {};
};
class TAgente ;
class TDocumento : public TMultiple_rectype // velib03
{
TRecfield *_tipocf;
TRecfield *_codcf;
TRecfield *_cod_occas;
char _stato_originale;
TCli_for _cli_for;
TOccasionale _occas;
TPagamento _pag;
TAssoc_array _tabella_iva; // tabella di imponibili ed imposte
TString_array _cod_iva;
TString8 _old_agente; // Agente originale
TString8 _old_agente1; // Secondo Agente originale
TRiga_documento * _sconto; // Riga per lo sconto di testata
TRiga_documento * _esenzione; // Riga per l' esenzione iva
bool _dirty_deny;
static long _firm;
static TString4 _codiva_spese;
static TString4 _codiva_bolli;
static short _has_mag;
static short _has_stat_ven;
static short _has_provv;
static TCodgiac_livelli *_livelli;
protected:
virtual TRectype * new_body_record(int logicnum = 0)
{ return new TRiga_documento(this); }
virtual TRiga_documento & row(int index);
const TRiga_documento& physical_row(int index) const;
long get_next_key(char provv, int anno, const char* codnum) const;
virtual void put_str(const char* fieldname, const char* val);
virtual const TString & get_str(const char* fieldname) const ;
int update_provvigione(bool remove, const bool first = true);
int update_provvigioni(bool remove);
virtual bool key_complete() { return numero() > 0; }
void set_riga_sconto();
int write_rewrite(TBaseisamfile & f, bool re) const;
virtual TDocumento & copy(const TDocumento & d);
virtual TObject* dup() const { return new TDocumento(*this); }
void calc_iva_fattura_commerciale();
void update_tabella_iva(bool solo_imponibili);
void dirty_tabella_iva() { _tabella_iva.destroy();}
static void test_firm();
void init();
void check_modules();
virtual void set_variables(TExpression * e) const ;
void update_raee();
public:
int set_row_ids();
long renum_ndoc(long numdoc = 0);
virtual bool renum() { return renum_ndoc() > 0;}
const TString& codiva_spese() const ;
const TString& codiva_bolli() const ;
TCodgiac_livelli & livelli() const ;
void dirty_fields();
TAssoc_array& tabella_iva(bool solo_imponibili = false) { update_tabella_iva(solo_imponibili); return _tabella_iva; }
int riepilogo_iva_items() const { return _cod_iva.items();}
const TRiepilogo_iva * riepilogo_iva(const char * cod) const { return (const TRiepilogo_iva *) _tabella_iva.objptr(cod); }
const TRiepilogo_iva * riepilogo_iva(int index) const { return (index >= 0 && index < _cod_iva.items()) ? riepilogo_iva(_cod_iva.row(index)) : NULL; }
TCli_for& clifor(bool force_reload = false) const;
TOccasionale& occas() const;
const TAgente& agente(bool first = true) const;
const TString& riferimento(TString& rif) const { return tipo().riferimento(*this, rif); }
virtual TRecord_array& body(int logicnum = 0) const;
virtual TDocumento & operator =(const TDocumento & d) {return copy(d);}
virtual TRectype & operator =(const TRectype & r);
virtual TRectype & operator =(const char * r);
virtual void zero(const char * fieldname);
virtual void zero(char c = '\0') { TMultiple_rectype::zero(c); }
void sort_rows(const char * key);
int physical_rows() const { return body().rows(); }
virtual int rows() const { return physical_rows() + ((_sconto != NULL) ? 1 : 0) + ((_esenzione != NULL) ? 1 : 0); }
const TRiga_documento& operator[](int index) const { return (const TRiga_documento&)((TDocumento *)this)->row(index); }
TRiga_documento& operator[](int index) { return (TRiga_documento&)row(index); }
const TRiga_documento* get_row_id(long id) const;
int id2rownum(long id) const;
TRiga_documento& insert_row(int row, const char *tipo = NULL);
TRiga_documento& new_row(const char *tipo = NULL);
virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
virtual int write(TBaseisamfile& f) const { return write_rewrite(f, FALSE); }
virtual int rewrite(TBaseisamfile& f) const { return write_rewrite(f, true); }
virtual int remove(TBaseisamfile& f) const;
int read(char provv, int anno, const char* codnum, long numdoc, word op = _isequal, word lockop = _nolock);
int read(const TRectype& rec, word op = _isequal, word lockop = _nolock) { *this = rec; return read(op, lockop); }
int read(word op = _isequal, word lockop = _nolock) { TLocalisamfile f(LF_DOC); return read(f, op, lockop);}
int write(bool re = FALSE) const { TLocalisamfile f(LF_DOC); return write_rewrite(f, re);}
int rewrite() const { return write(true); }
int remove() const { TLocalisamfile f(LF_DOC); return remove(f);}
int decimals(bool price = FALSE) const;
void flush_rows();
void calc_provvigione(TProvvigioni_agente & provv, const TString & key, bool first = true, bool generata = true);
char tipo_numerazione() const { return get_char(DOC_PROVV); }
int anno() const { return get_int(DOC_ANNO); }
const TString& numerazione() const { return get(DOC_CODNUM); }
long numero() const { return get_long(DOC_NDOC); }
TDate data() const { return get_date(DOC_DATADOC); }
bool in_valuta() const;
const TString& valuta() const { return get(DOC_CODVAL); }
real cambio() const { return get_real(DOC_CAMBIO); }
bool tipo_valido() const { return get(DOC_TIPODOC).full(); }
const TTipo_documento& tipo() const;
int tipo_riclassificato() const;
static const TCodice_numerazione& codice_numerazione(const char * numerazione);
const TCodice_numerazione& codice_numerazione() const;
void set_tipo(const char * tipo) { head().put(DOC_TIPODOC, tipo);}
bool provvisorio() const { return get_char(DOC_PROVV) == 'P'; }
char stato() const { return get_char(DOC_STATO); }
void stato(char s) { put(DOC_STATO, s); }
const TString & codice_costo() const { return get(DOC_CODCOSTO);}
const TString & codice_commessa() const { return get(DOC_CODCMS);}
const TString & commessa_principale() const;
const TString & fase_commessa() const { return get(DOC_FASCMS);}
bool modificabile() const;
bool cancellabile() const;
bool stampabile() const;
bool bloccato() const;
bool chiuso() const;
bool sospeso() const { return !chiuso();}
bool raggruppabile() const { return get_bool(DOC_RAGGR); }
bool raggruppabile(const TDocumento& doc, TToken_string& campi) const;
char tipocf() const {return *(const char *) (*_tipocf);}
long codcf() const {return (long) *_codcf;}
const char * cod_occas() const { return (const char *) *_cod_occas; }
static void set_key(TRectype& rec, char provv, int anno, const char* codnum, long numdoc);
static void copy_data(TRectype& dst, const TRectype& src);
static void copy_data(TRiga_documento& dst, const TRiga_documento& src);
void copy_contents(const TDocumento& src, bool copy_header = true);
void set_fields(TAuto_variable_rectype & rec);
void update_esenzione();
void set_riga_esenzione();
bool ha_riga_sconto() const { return _sconto != NULL; }
bool ha_riga_esenzione() const { return _esenzione != NULL; }
void iva_esente(TString & codiva_es) const;
real spese_incasso(real &imp, int ndec, TTipo_importo netto = _lordo) const ;
real bolli(real & imp, int ndec, TTipo_importo netto = _lordo) const ;
real imponibile(bool spese = FALSE, int ndec = AUTO_DECIMALS) const;
real imposta(bool spese = FALSE, int ndec = AUTO_DECIMALS) const;
real totale_doc() const;
real totale_netto() const;
real basesconto() const;
real spese() const;
real ritenute(const char tipo = '\0', bool lordo = false, int ndec = AUTO_DECIMALS) const;
real provvigione(bool first = true, int ndec = AUTO_DECIMALS) const;
real valore(bool totale, bool lordo = false, int ndec = AUTO_DECIMALS) const;
TPagamento & pagamento();
void update_spese_aut(TString_array & spese, bool preserve_old = FALSE, TSheet_field * sh = NULL);
real calc_conai_qta(TCONAI_class type);
void update_conai();
bool is_generic() const { return tipo_valido() && tipo().is_generic(); }
bool is_fattura() const { return tipo_valido() && tipo().is_fattura(); }
bool is_bolla() const { return tipo_valido() && tipo().is_bolla(); }
bool is_ordine() const { return tipo_valido() && tipo().is_ordine(); }
bool is_evaso() const;
bool is_nota_credito() const;
const TString & codesiva() const;
void get_protocolli_esenzione(TString & esenzione, TString & data_esenzione,
TString & registrazione, TString & data_registrazione) const;
void cli2doc() { clifor().cli2doc(*this); }
TDocumento ();
TDocumento (const TDocumento & d);
TDocumento(char provv, int anno, const char* codnum, long numdoc);
TDocumento(const TRectype& doc);
virtual ~TDocumento();
};
#define FOR_EACH_PHYSICAL_RDOC(__doc, __r, __rdoc) TRiga_documento* __rdoc=NULL; \
TRecord_array& bodyof##__rdoc = (__doc).body(); \
for (int __r = bodyof##__rdoc.first_row(); bodyof##__rdoc.exist(__r) && (__rdoc=&(__doc)[__r])!=NULL; __r=bodyof##__rdoc.succ_row(__r))
#define FOR_EACH_PHYSICAL_RDOC_BACK(__doc, __r, __rdoc) TRiga_documento* __rdoc=NULL; \
TRecord_array& bodyof##__rdoc = (__doc).body(); \
for (int __r = bodyof##__rdoc.last_row(); __r>0 && (__rdoc=&(__doc)[__r])!= NULL; __r = bodyof##__rdoc.pred_row(__r))
class TCurrency_documento : public TCurrency
{
protected:
void copy(const TCurrency& cur) {TCurrency::copy(cur); }
public:
const TCurrency_documento& operator=(const TCurrency_documento& cur) { copy(cur); return *this; }
const TCurrency_documento& operator=(const TCurrency& cur) { copy(cur); return *this; }
TCurrency_documento(const TCurrency& cur) { copy(cur); }
TCurrency_documento(const TCurrency_documento& cur) { copy(cur); }
TCurrency_documento(const real& num, const TDocumento &doc, bool price = FALSE);
virtual ~TCurrency_documento() { }
};
class TCodgiac_livelli;
class TStati : public TObject
{
char _iniziale;
char _finale;
public:
char iniziale() const { return _iniziale;}
char finale() const { return _finale;}
TStati(char iniziale, char finale) { _iniziale = iniziale; _finale = finale;}
};
class TColor_rule : public TExpr_documento
{
COLOR _back, _fore, _def_back, _def_fore;
TString _desc, _key;
public:
const TString& description() const { return _desc; }
const TString& key() const { return _key; }
void default_colors(COLOR& back, COLOR& fore) const { back = _def_back; fore = _def_fore; }
void colors(COLOR& back, COLOR& fore) const { back = _back; fore = _fore; }
void set_colors(COLOR back, COLOR fore) { _back = back; _fore = fore; }
TColor_rule(const char* desc, const char* expr, TTypeexp type, COLOR back, COLOR fore);
};
class TDocumento_mask : public TVariable_mask // velib06
{
int _progs_page; // pagina in cui cominciano i progressivi
TSheet_field* _sheet; // Spreadsheet
TDocumento _doc; // documento
TCodgiac_livelli * _livelli_giac; // livelli di giacenza
TCond_vendita* _condv; // condizioni di vendita
TAssoc_array _maskriga; // Maschere delle righe
TPointer_array _handlers;
TBit_array _calculated_pages;
bool _ges_mag, _ges_dep, _ges_ca;
TString8 _std_mag, _std_dep;
real _fconv_qta;
TSmart_card * _smartcard;
static TAssoc_array _father_rows;
static TAssoc_array _auto_reopen_nums;
static TAssoc_array _tipidoc_rels;
short _cdc_start;
short _cdc_end;
short _cms_start;
short _cms_end;
short _cdc_start_sh;
short _cdc_end_sh;
short _cms_start_sh;
short _cms_end_sh;
TString _codcms, _codcms_sh;
TArray _color_rules;
int _sh_y;
protected:
virtual void next_page(int p);
virtual void start_run();
void sconto_testa2mask();
void spese2mask();
void configura_sheet(TSheet_field& sheet);
static TMask* ss_getmask(int numriga, TMask& fullmask);
int insert_anal_fields(TMask& m, int page, int lf, int& y, short& dlg, short& dlgd, bool required);
void insert_anal_page();
public:
virtual bool is_omaggio_enabled() { return true;}
void update_progs(bool stop_run = false);
virtual bool on_key(KEY key);
virtual bool stop_run(KEY key);
int sh_y() const { return _sh_y; }
void set_field_handler(short fieldid, CONTROL_HANDLER handler);
bool call_handler( TMask_field& f, KEY key);
static bool universal_handler( TMask_field& f, KEY key);
static bool occas_handler( TMask_field& f, KEY key );
static bool occas_code_handler( TMask_field& f, KEY key );
static bool occas_cfpi_handler( TMask_field& f, KEY key );
static bool clifo_handler( TMask_field& f, KEY key );
static bool print_handler( TMask_field& f, KEY key );
static bool elabora_handler( TMask_field& f, KEY key );
static bool codlist_handler( TMask_field& f, KEY key );
static bool codcont_handler( TMask_field& f, KEY key );
static bool codcamp_handler( TMask_field& f, KEY key );
static bool datacambio_handler( TMask_field& f, KEY key );
static bool codval_handler( TMask_field& f, KEY key );
static bool confirm_handler( TMask_field& f, KEY key );
static bool sort_row_handler( TMask_field& f, KEY key );
static bool ss_notify(TSheet_field& ss, int r, KEY key);
static bool ss_handler(TMask_field& f, KEY key);
virtual void user_set_handler( short fieldid, int index);
virtual void user_set_row_handler(TMask& rm, short field, int index);
void reset_masks(const TString& tipo_doc);
bool new_mask(int numriga) const;
virtual TVariable_mask * riga_mask(int numriga);
TDocumento& doc() { return _doc; }
const TDocumento& doc() const { return _doc; }
TCond_vendita & condv() const;
void occ2mask();
void cli2mask(bool force_load = false);
virtual void doc2mask(bool reload_clifo = true, bool force_load = false, bool update = true);
void mask2doc();
void update_giacenza();
static TAssoc_array & auto_reopen_nums() { return _auto_reopen_nums;}
static TAssoc_array & tipidoc_rels() { return _tipidoc_rels;}
const TAssoc_array & father_rows() const { return _father_rows;}
void reset_father_rows() {_father_rows.destroy();}
void update_father_rows(bool add = true);
void save_father_rows();
const TString& stdmag() const { return _std_mag; }
const TString& stddep() const { return _std_dep; }
TSheet_field& sheet() const { return *_sheet; }
TCodgiac_livelli& livelli() const { return *_livelli_giac; }
static bool anno_handler( TMask_field& f, KEY key);
static bool num_handler( TMask_field& f, KEY key );
static bool numdocrif_search_handler( TMask_field& f, KEY key );
static bool ragsoc_search_handler( TMask_field& f, KEY key );
static bool datadocrif_handler(TMask_field& f, KEY key);
virtual void highlight_row(int row, COLOR back = COLOR_INVALID, COLOR fore = COLOR_INVALID, bool dirty = true, bool update = true);
void highlight();
const real & fconv_qta() const { return _fconv_qta;}
bool is_calculated_page(int p) const { return _calculated_pages[p]; }
TSmart_card* smartcard() const { return _smartcard;}
bool show_note_articolo(const TString& codart);
short cdc_start() const { return _cdc_start;}
short cdc_end() const { return _cdc_end;}
short cms_start() const { return _cms_start;}
short cms_end() const { return _cms_end;}
short cdc_start_sh() const { return _cdc_start_sh;}
short cdc_end_sh() const { return _cdc_end_sh;}
short cms_start_sh() const { return _cms_start_sh;}
short cms_end_sh() const { return _cms_end_sh;}
TString& codcms() { return _codcms;}
const TString& codcms() const { return _codcms;}
TString& codcms_sh() { return _codcms_sh;}
const TString & codcms_sh() const { return _codcms_sh;}
TArray& color_rules() { return _color_rules; }
void sel_color();
bool gestione_note_per_articolo() const;
TDocumento_mask(const char* tipodoc);
virtual ~TDocumento_mask();
};
////////////////////////
//// TDOC_KEY ////
////////////////////////
//classe TDoc_key
class TDoc_key: public TToken_string
{
public:
const char provv();
const int anno();
const char* codnum();
const long ndoc();
void set_provv(const char = 'D');
void set_anno(const int anno);
void set_codnum(const char* codnum);
void set_ndoc(const long ndoc);
TDoc_key& operator= (const char* key){set(key);}
TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv = 'D');
TDoc_key(const TRectype& rec);
TDoc_key(const char* key):TToken_string(key){}
TDoc_key(const TToken_string& key):TToken_string(key){}
TDoc_key(const TDoc_key& key):TToken_string(key){}
TDoc_key():TToken_string(){}
};
/////////////////////////
//// TRDOC_KEY ////
/////////////////////////
//classe TRdoc_key
class TRdoc_key: public TToken_string
{
public:
const char provv();
const int anno();
const char* codnum();
const long ndoc();
const int nriga();
TRdoc_key& operator= (const char* key){set(key);}
TRdoc_key(const int anno, const TString& codnum, const long ndoc, const int nriga, const char provv = 'D');
TRdoc_key(const char* key):TToken_string(key){}
TRdoc_key(const TToken_string& key):TToken_string(key){}
TRdoc_key(const TRdoc_key& key):TToken_string(key){}
};
#endif
Reference in New Issue View Git Blame Copy Permalink