root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib.h
alex a16fcd0b21 Patch level : 10.0 patch 808 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :

Bug 0001696: Non viene più proposta l'unità di misura dell'articolo

Non viene più proposta in automatico l'unità di misura di default dell'articolo

Bug 0001698: Errore - Esplosione Articolo con distinta dalle righe documento

	Se esplodo con F8 un articolo nelle sue righe di distinta mantenedo anche la righa originale, quest'ultima in realtà viene sostituita con l'ultima righa di esplosione


git-svn-id: svn://10.65.10.50/branches/R_10_00@20886 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-09-21 11:21:30 +00:00

1074 lines
40 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;
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_char("S3"); }
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; }
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 ecc.) //velib01
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;
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;}
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; }
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
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; }
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;
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 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();
void kill_double_fields(short fld1, short fld2);
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 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;}
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();
TDocumento_mask(const char* tipodoc);
virtual ~TDocumento_mask();
};
#endif
Reference in New Issue View Git Blame Copy Permalink