1418 lines
55 KiB
C++
Executable File
1418 lines
55 KiB
C++
Executable File
#ifndef __VELIB_H
|
||
#define __VELIB_H
|
||
|
||
#ifndef __VARMASK_H
|
||
#include <varmask.h>
|
||
#endif
|
||
|
||
#ifndef __MULTIREC_H
|
||
#include <multirec.h>
|
||
#endif
|
||
|
||
#ifndef __VISWIN_H
|
||
class TViswin;
|
||
#endif
|
||
|
||
#ifndef __CLIFOR_H
|
||
#include "../ve/clifor.h"
|
||
#endif
|
||
|
||
#ifndef __CURRENCY_H
|
||
#include <currency.h>
|
||
#endif
|
||
|
||
#ifndef __CGLIB01_H
|
||
#include "../cg/cglib01.h"
|
||
#endif
|
||
|
||
#ifndef __CGPAGAME_H
|
||
#include "../cg/cgpagame.h"
|
||
#endif
|
||
|
||
#ifndef __PRLIB_H
|
||
#include "../pr/prlib.h"
|
||
#endif
|
||
|
||
#ifndef __MGLIB_H
|
||
#include "../mg/mglib.h"
|
||
#endif
|
||
|
||
#ifndef __COLMASK_H
|
||
#include <colmask.h>
|
||
#endif
|
||
|
||
#ifndef __DOC_H
|
||
#include <doc.h>
|
||
#endif
|
||
|
||
#ifndef __RDOC_H
|
||
#include <rdoc.h>
|
||
#endif
|
||
|
||
#include "../cg/cg2101.h"
|
||
|
||
#define RIGA_MERCE 'M'
|
||
#define RIGA_SPESEDOC 'S'
|
||
#define RIGA_PRESTAZIONI 'P'
|
||
#define RIGA_SCONTI 'C'
|
||
#define RIGA_OMAGGI 'O'
|
||
#define RIGA_DESCRIZIONI 'D'
|
||
|
||
#define MAX_TIPI_DOC 10
|
||
|
||
#define MAX_IVA_SLICES 5
|
||
|
||
class TDocumento;
|
||
class TRiga_documento;
|
||
class TCond_vendita;
|
||
class TIVA_array;
|
||
class TArticolo_giacenza;
|
||
class TCache_articoli;
|
||
|
||
|
||
bool scontoexpr2perc(const char * exp, bool signal , TString & goodexp, real & val_perc );
|
||
real prezzo_scontato(const real& prezzo, const char * 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:
|
||
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
|
||
{
|
||
|
||
protected:
|
||
|
||
public:
|
||
TObject* dup() const { return new TSpesa_prest(codice()); }
|
||
|
||
public:
|
||
int read(const char* codice);
|
||
|
||
const TString& codice() const { return get("CODTAB");}
|
||
const TString& descrizione() const { return get("S0"); }
|
||
const TString& field_perc() const { return get("S5"); }
|
||
const TString & um() const { return get("S7"); }
|
||
const TString& cod_iva() const { return get("S3"); }
|
||
real prezzo() const { return get_real("R0"); }
|
||
real qta() const { return get_real("R1"); }
|
||
real perc() const { return get_real("R2"); }
|
||
char tipo() const { return get_char("S6"); }
|
||
char tipo_ritenuta() const { return get_char("S9"); }
|
||
const TString & tipo_riga() const { return get("S8"); }
|
||
char genere() const { return get("COD") == "SPP" ? 'S' : 'P'; }
|
||
|
||
TSpesa_prest(const char* codice = NULL, char tipo = 'S');
|
||
TSpesa_prest(const TRectype& rec);
|
||
virtual ~TSpesa_prest() {}
|
||
};
|
||
|
||
/*class TIVA : public TRectype // velib01
|
||
{
|
||
|
||
protected:
|
||
int read(const char* codice);
|
||
|
||
public:
|
||
TObject* dup() const { return new TIVA(codice()); }
|
||
|
||
public:
|
||
const TString& codice() const { return get("CODTAB");}
|
||
const TString& descrizione() const { return get("S0"); }
|
||
const real aliquota() const { return get_real("R0"); }
|
||
const TString& tipo() const { return get("S1"); }
|
||
|
||
TIVA(const char* codice = NULL);
|
||
TIVA(const TRectype& rec);
|
||
virtual ~TIVA() {}
|
||
};*/
|
||
|
||
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), _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
|
||
{
|
||
TString16 _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); }
|
||
|
||
public:
|
||
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
|
||
{
|
||
enum { _altro, _bolla, _fattura, _ordine};
|
||
|
||
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 _valore;
|
||
TString16 _totvalres;
|
||
TString16 _totvalore;
|
||
TString16 _totale_cont;
|
||
TString16 _field_prezzo;
|
||
TString16 _field_qta, _field_qtaevasa; // Veri campi Quantit<69> e Quantit<69> Evasa
|
||
TString _str_desc_doc, _str_desc_rdoc;
|
||
|
||
char _tipocf;
|
||
char _check_qta;
|
||
bool _cnt_prezzi, _show_evaded_lines;
|
||
|
||
|
||
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:
|
||
TObject* dup() const { return new TTipo_documento(codice()); }
|
||
|
||
public:
|
||
// const TString& profile_name() const { return get("S4"); }
|
||
const TFilename& profile_name(TFilename& name) const;
|
||
|
||
// Funzioni che effettuano la cache di importanti valori contenuti nel profilo
|
||
const char tipocf();
|
||
void set_defaults(TMask& m) const;
|
||
const TString_array& keys_descrs();
|
||
const TString_array& sheet_columns();
|
||
const TString_array& handlers();
|
||
|
||
const TString& mask_name() const { return get("S4");}
|
||
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 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; }
|
||
bool check_giac() const { return _check_qta == 'G'; }
|
||
bool check_disp() const { return _check_qta == 'D'; }
|
||
|
||
|
||
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 & 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 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"); }
|
||
|
||
TFormula_documento * first_formula() { return succ_formula(TRUE); }
|
||
TFormula_documento * succ_formula(bool restart = FALSE);
|
||
|
||
const int ncopie() const { return get_int("I0"); }
|
||
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"); }
|
||
|
||
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; }
|
||
|
||
TTipo_documento(const char* tipodoc = NULL);
|
||
TTipo_documento(const TRectype& rec);
|
||
virtual ~TTipo_documento();
|
||
};
|
||
|
||
class TCodice_numerazione : public TRectype
|
||
{
|
||
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 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();
|
||
};
|
||
|
||
class TTipo_riga_documento : public TRectype // velib02
|
||
{
|
||
static TAssoc_array _formule_riga;
|
||
TToken_string _formule;
|
||
|
||
TString16 _imponibile;
|
||
TString16 _quant;
|
||
TString16 _quantevasa;
|
||
TString16 _qtares;
|
||
TString16 _valore;
|
||
TString16 _valres;
|
||
|
||
TString16 _field_provv;
|
||
TString16 _field_qta, _field_qtaevasa; // Veri campi Quantit<69> e Quantit<69> Evasa
|
||
|
||
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"); }
|
||
|
||
const TString& imponibile() const { return _imponibile;}
|
||
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& provv() const { return _field_provv;}
|
||
const int incr_perc_prezzo() const { return _incrp;}
|
||
const int decr_perc_prezzo() const { return _decrp;}
|
||
|
||
bool formfeed() const { return get_bool("B0"); }
|
||
int detraibilita() const { return get_int("I0"); }
|
||
real perc_indetraibilita() const { return get_real("R0"); }
|
||
|
||
TFormula_documento* first_formula() { return succ_formula(TRUE); }
|
||
TFormula_documento* succ_formula(bool restart = FALSE);
|
||
|
||
int read(const char* tiporig);
|
||
TTipo_riga_documento(const char* tiporig = NULL);
|
||
TTipo_riga_documento(const TRectype& rec);
|
||
virtual ~TTipo_riga_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 TCache_articoli * _articoli;
|
||
static int _iva_calc_mode;
|
||
|
||
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 ;
|
||
|
||
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() == 'M';}
|
||
bool is_spese() const { return tipo().tipo() == 'S';}
|
||
bool is_prestazione() const { return tipo().tipo() == 'P';}
|
||
bool is_sconto() const {return tipo().tipo() == 'C';}
|
||
bool is_sconto_perc() const { return get(RDOC_SCONTO).not_empty();}
|
||
bool is_omaggio() const { return tipo().tipo() == 'O';}
|
||
bool is_descrizione() const { return tipo().tipo() == 'D';}
|
||
bool is_articolo() const;
|
||
bool is_checked() const { return get_bool(RDOC_CHECKED);}
|
||
bool is_evadibile() const { return is_merce() || is_omaggio() || is_spese() || 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 void zero(const char * fieldname);
|
||
virtual void zero(char c = '\0');
|
||
// row -> sheet
|
||
void autoload( TSheet_field& f);
|
||
// sheet -> row
|
||
void autosave( TSheet_field& f);
|
||
|
||
const TTipo_riga_documento & tipo() const;
|
||
const TSpesa_prest & spesa() const;
|
||
static const TCodiceIVA & iva(const char * codice);
|
||
const TCodiceIVA & iva() const {const TString16 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();
|
||
|
||
void set_original_rdoc_key(const TRiga_documento& orig);
|
||
void reset_original_rdoc_key();
|
||
const TRectype* find_original_rdoc() 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 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(int ndec = AUTO_DECIMALS) const;
|
||
|
||
const TString& field_qta() const;
|
||
const TString& field_qtaevasa() const;
|
||
real quantita() const;
|
||
real qtaevasa() const;
|
||
real qtaresidua() const;
|
||
real valore(bool totale, int ndec) const;
|
||
const TString & codice_commessa() const;
|
||
const TString & fase_commessa() const;
|
||
TArticolo_giacenza * articolo() const;
|
||
|
||
TRiga_documento(TDocumento* doc, const char* tipo = NULL);
|
||
TRiga_documento(const TRiga_documento & row);
|
||
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_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_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
|
||
|
||
TProvvigioni_agente* _provv_agente;
|
||
TString16 _old_agente; // Agente originale
|
||
|
||
TRiga_documento * _sconto; // Riga per lo sconto di testata
|
||
TRiga_documento * _esenzione; // Riga per l' esenzione iva
|
||
|
||
bool _dirty_deny;
|
||
|
||
static TAssoc_array _tipi;
|
||
static TAssoc_array _numerazioni;
|
||
static long _firm;
|
||
static TString16 _codiva_spese;
|
||
static TString16 _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); }
|
||
|
||
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 ;
|
||
|
||
long renum_ndoc(long numdoc = 0);
|
||
virtual bool key_complete() { return numero() > 0; }
|
||
virtual bool renum() { return renum_ndoc() > 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();
|
||
void dirty_tabella_iva() { _tabella_iva.destroy();}
|
||
static void test_firm();
|
||
|
||
void init();
|
||
void check_modules();
|
||
virtual void set_variables(TExpression * e) const ;
|
||
int set_row_ids();
|
||
|
||
public:
|
||
const TString& codiva_spese() const ;
|
||
const TString& codiva_bolli() const ;
|
||
|
||
TCodgiac_livelli & livelli() const ;
|
||
void dirty_fields();
|
||
|
||
TAssoc_array & tabella_iva() { update_tabella_iva(); return _tabella_iva; }
|
||
TCli_for & clifor() const;
|
||
TOccasionale & occas() const;
|
||
const TAgente & agente() 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); }
|
||
|
||
int physical_rows() const { return body().rows(); }
|
||
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();
|
||
|
||
TProvvigioni_agente& calc_provvigioni(const bool generata = TRUE);
|
||
int write_provvigioni() { return calc_provvigioni().write();}
|
||
|
||
char tipo_numerazione() const { return get_char("PROVV"); }
|
||
int anno() const { return get_int("ANNO"); }
|
||
const TString& numerazione() const { return get("CODNUM"); }
|
||
long numero() const { return get_long("NDOC"); }
|
||
TDate data() const { return get_date("DATADOC"); }
|
||
bool in_valuta() const;
|
||
const TString& valuta() const { return get("CODVAL"); }
|
||
real cambio() const { return get_real("CAMBIO"); }
|
||
bool tipo_valido() const { return get("TIPODOC").not_empty(); }
|
||
static const TTipo_documento& tipo(const char * tipodoc);
|
||
const TTipo_documento& tipo() const;
|
||
static const TCodice_numerazione& codice_numerazione(const char * numerazione);
|
||
const TCodice_numerazione& codice_numerazione() const;
|
||
void set_tipo(const char * tipo) { head().put("TIPODOC", tipo);}
|
||
bool provvisorio() const { return get_char("PROVV") == 'P'; }
|
||
char stato() const { return get_char("STATO"); }
|
||
void stato(char s) { put("STATO", s); }
|
||
const TString & codice_commessa() const { return get(DOC_CODCMS);}
|
||
const TString & fase_commessa() const { return get(DOC_FASCMS);}
|
||
bool modificabile() const;
|
||
bool cancellabile() const;
|
||
bool stampabile() const;
|
||
bool bloccato() const;
|
||
|
||
bool raggruppabile() const { return get_bool("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);
|
||
|
||
void set_fields(TAuto_variable_rectype & rec);
|
||
void set_riga_esenzione();
|
||
|
||
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 provvigione(int ndec = AUTO_DECIMALS) const;
|
||
real valore(bool totale, 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(int 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;
|
||
|
||
TDocumento ();
|
||
TDocumento (const TDocumento & d);
|
||
TDocumento(char provv, int anno, const char* codnum, long numdoc);
|
||
TDocumento(const TRectype& doc);
|
||
virtual ~TDocumento();
|
||
};
|
||
|
||
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 TDocumento_mask : public TVariable_mask // velib06
|
||
{
|
||
int _progs_page; // pagina in cui cominciano i progressivi
|
||
int _last_prog; // numero dell'ultimo progressivo
|
||
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
|
||
|
||
bool _ges_mag, _ges_dep;
|
||
TString _std_mag, _std_dep;
|
||
|
||
protected:
|
||
void update_progs();
|
||
virtual void next_page(int p);
|
||
virtual bool stop_run(KEY key);
|
||
void sconto_testa2mask();
|
||
void spese2mask();
|
||
|
||
void configura_sheet(TSheet_field& sheet);
|
||
static bool ss_notify(TSheet_field& ss, int r, KEY key);
|
||
static bool ss_handler(TMask_field& f, KEY key);
|
||
static TMask* ss_getmask(int numriga, TMask& fullmask);
|
||
|
||
static bool occas_handler( TMask_field& f, KEY key );
|
||
static bool occas_code_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 controeuro_handler( TMask_field& f, KEY key );
|
||
static bool datacambio_handler( TMask_field& f, KEY key );
|
||
static bool codval_handler( TMask_field& f, KEY key );
|
||
void user_set_handler( int fieldid, int index);
|
||
|
||
void reset_masks(const TString& tipo_doc);
|
||
|
||
public:
|
||
TVariable_mask* riga_mask(int numriga);
|
||
virtual bool on_key(KEY key);
|
||
|
||
TDocumento& doc() { return _doc; }
|
||
const TDocumento& doc() const { return _doc; }
|
||
TCond_vendita & condv() const;
|
||
|
||
void occ2mask();
|
||
void cli2mask();
|
||
void doc2mask(bool reload_clifo = TRUE);
|
||
void mask2doc();
|
||
|
||
void update_giacenza();
|
||
|
||
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 tip_handler( TMask_field& f, KEY key );
|
||
static bool numdocrif_search_handler( TMask_field& f, KEY key );
|
||
static bool datadocrif_handler(TMask_field& f, KEY key);
|
||
|
||
void highlight(COLOR high_back_color, COLOR high_color);
|
||
|
||
TDocumento_mask(const char* tipodoc);
|
||
virtual ~TDocumento_mask();
|
||
};
|
||
|
||
class TLista_documenti : public TObject // velib04
|
||
{
|
||
TArray _documenti;
|
||
|
||
protected:
|
||
const TDocumento& doc(int n) const { return (const TDocumento&)_documenti[n]; }
|
||
TDate num2date(char provv, int anno, const char* codnum, long num) const;
|
||
|
||
public:
|
||
int read(char provv, char tipo, long clifo, int anno,
|
||
TToken_string& tipidoc, TToken_string& statidoc,
|
||
const TDate& dd, const TDate& ad,
|
||
const char* codnum = "", long dn = 0L, long an = 0L);
|
||
int write(bool re = FALSE) const;
|
||
int rewrite() const { return write(TRUE); }
|
||
|
||
int add(TDocumento* doc) { return _documenti.add(doc); }
|
||
int add(const TDocumento& doc) { return _documenti.add(doc); }
|
||
int destroy(int i, bool pack = TRUE) { return _documenti.destroy(i, pack); }
|
||
|
||
const TDocumento& operator[] (int n) const { return doc(n); }
|
||
TDocumento& operator[] (int n) { return (TDocumento&)_documenti[n]; }
|
||
int items() const { return _documenti.items(); }
|
||
|
||
TLista_documenti() { }
|
||
virtual ~TLista_documenti() {};
|
||
};
|
||
|
||
class TLista_clifo : public TObject // velib04
|
||
{
|
||
class TClifo : public TObject
|
||
{
|
||
long _codice;
|
||
long _agente;
|
||
long _zona;
|
||
|
||
protected:
|
||
void zero() { _codice = _agente = _zona = 0L; }
|
||
void init(const TRectype& rec, const TRectype& ven);
|
||
bool read(char tipo, long cod);
|
||
|
||
public: // TObject
|
||
virtual bool ok() const { return _codice > 0; }
|
||
|
||
public:
|
||
long codice() const { return _codice; }
|
||
long agente() const { return _agente; }
|
||
long zona() const { return _zona; }
|
||
|
||
TClifo() { zero(); }
|
||
TClifo(char tipo, long cod) { read(tipo, cod); }
|
||
TClifo(const TRectype& rec, const TRectype& ven) { init(rec, ven); }
|
||
TClifo(const TRectype& rec);
|
||
virtual ~TClifo() { }
|
||
};
|
||
|
||
TArray _clifo;
|
||
|
||
protected:
|
||
virtual char tipo() const pure;
|
||
const TClifo& clifo(int n) const { return (TClifo&)_clifo[n]; }
|
||
|
||
static int sort_by_code(const TObject** o1, const TObject** o2);
|
||
static int sort_by_agent(const TObject** o1, const TObject** o2);
|
||
static int sort_by_zone(const TObject** o1, const TObject** o2);
|
||
|
||
public:
|
||
int ordina_per_codice();
|
||
int ordina_per_agente();
|
||
int ordina_per_zona();
|
||
|
||
int leggi(long dc, long ac, long da = 0, long aa = 0, const char * dz = "", const char * az = "");
|
||
|
||
long operator[] (int n) const { return clifo(n).codice(); }
|
||
int items() const { return _clifo.items(); }
|
||
int find(long cod) const;
|
||
int add(long cod);
|
||
|
||
TLista_clifo() { }
|
||
virtual ~TLista_clifo() { }
|
||
};
|
||
|
||
class TLista_clienti : public TLista_clifo
|
||
{
|
||
protected:
|
||
virtual char tipo() const { return 'C'; }
|
||
};
|
||
|
||
class TLista_fornitori : public TLista_clifo
|
||
{
|
||
protected:
|
||
virtual char tipo() const { return 'F'; }
|
||
};
|
||
|
||
enum TTipo_elaborazione {_esterna, _consegna_ordini, _fatturazione_bolle, _contabilizzazione, _copia_documento, _generazione_effetti };
|
||
|
||
class TParametri_elaborazione : public TObject // velib04
|
||
{
|
||
TAssoc_array _par;
|
||
|
||
public:
|
||
void set(const char * name, const char * val);
|
||
void set(const char * name, const real & val) { set(name, val.string());}
|
||
|
||
const TString & get(const char * name) const ;
|
||
const real get_real(const char * name) const { return (real) get(name);}
|
||
|
||
TParametri_elaborazione & copy(const TParametri_elaborazione & p) { _par = p._par; return *this;}
|
||
virtual TObject* dup() const { return new TParametri_elaborazione(*this); }
|
||
TParametri_elaborazione & operator =(const TParametri_elaborazione & p) {return copy(p);}
|
||
TParametri_elaborazione() { }
|
||
TParametri_elaborazione(const TParametri_elaborazione & p) {copy(p);}
|
||
virtual ~TParametri_elaborazione() { }
|
||
};
|
||
|
||
class TElaborazione : public TRectype // velib04
|
||
{
|
||
TParametri_elaborazione _parms;
|
||
|
||
protected:
|
||
int read(const char* cod);
|
||
|
||
public:
|
||
enum { _max_tipi_doc_elab = 10 };
|
||
const TString& codice() const { return get("CODTAB"); }
|
||
const TString& descrizione() const { return get("S0"); }
|
||
const TTipo_elaborazione tipo() const { return (TTipo_elaborazione) get_int("I0"); }
|
||
|
||
bool doc_uguale(int u) const { return get("S1")[u] == 'X'; }
|
||
bool riga_uguale(int u) const { return get("S1")[40+u] == 'X'; }
|
||
|
||
bool raggruppa_righe() const { return get_bool("B0"); }
|
||
bool gestione_riferimenti() const { return get_bool("B1"); }
|
||
bool riferimenti_in_testa() const { return get_bool("B2"); }
|
||
bool ignora_descrizioni() const { return get_bool("B3"); }
|
||
char tipo_numerazione() const { return get_bool("B4") ? 'P' : 'D'; }
|
||
bool prezzo_da_ordine() const { return get_bool("B5"); }
|
||
bool aggiorna_testata_se_vuoto() const { return get_bool("B6"); }
|
||
bool ordina_per_codice() const { return get_bool("B7"); }
|
||
bool usa_doc_rif() const { return get_bool("B8"); }
|
||
|
||
int intestazioni_sheet() const { return get_int("I1"); }
|
||
|
||
const TString& codice_numerazione_iniziale() const { return get("S5"); }
|
||
const TString tipo_iniziale(int i) const { return get("S2").smid(i*4, 4).rtrim(); }
|
||
const char stato_iniziale(int i) const { return i < 5 ? get("S7")[i] : get("S10")[i - 5]; }
|
||
const TString& tipo_finale() const { return get("S8"); }
|
||
const TString& stato_finale_doc_iniziale() const { return get("S4"); }
|
||
const TString& stato_finale() const { return get("S9"); }
|
||
|
||
const TString& codice_numerazione_finale() const { return get("S6"); }
|
||
const TString& applicazione_esterna() const { return get("S3"); }
|
||
void set_params(const TParametri_elaborazione & parms) { _parms = parms;}
|
||
TParametri_elaborazione & params() { return _parms;}
|
||
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE) pure;
|
||
|
||
TElaborazione(const char* cod);
|
||
TElaborazione(const TRectype& rec) : TRectype(rec) { }
|
||
virtual ~TElaborazione() { }
|
||
};
|
||
|
||
class TElaborazione_esterna : public TElaborazione // velib04
|
||
{
|
||
public:
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE);
|
||
|
||
TElaborazione_esterna(const char* cod);
|
||
TElaborazione_esterna(const TRectype& rec) : TElaborazione(rec) { }
|
||
virtual ~TElaborazione_esterna() { }
|
||
};
|
||
|
||
class TConsegna_ordini : public TElaborazione // velib04d
|
||
{
|
||
public:
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE);
|
||
|
||
TConsegna_ordini(const char* cod);
|
||
TConsegna_ordini(const TRectype& rec) : TElaborazione(rec) { }
|
||
virtual ~TConsegna_ordini() { }
|
||
};
|
||
|
||
class TFatturazione_bolle : public TElaborazione // velib04a
|
||
{
|
||
TToken_string _cod_desc;
|
||
|
||
public:
|
||
virtual bool raggruppa(TDocumento& din, TDocumento& dout);
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE);
|
||
|
||
void tipi_validi(TToken_string& tipi) const;
|
||
void stati_validi(TToken_string& stati) const;
|
||
|
||
TFatturazione_bolle(const char* cod);
|
||
TFatturazione_bolle(const TRectype& rec) : TElaborazione(rec) { }
|
||
virtual ~TFatturazione_bolle() { }
|
||
};
|
||
|
||
// Tipi di errore validi solo per TContabilizzazione e TGenerazione_effetti
|
||
|
||
enum error_type {
|
||
no_error,
|
||
nr_es_error,
|
||
nr_reg_error,
|
||
nr_doc_error,
|
||
chg_stat_error,
|
||
clifo_error,
|
||
ultprot_error,
|
||
datadoc_error,
|
||
caus_error,
|
||
causre_error,
|
||
cauval_error,
|
||
ivasto_error,
|
||
register_error,
|
||
change_error,
|
||
val_error,
|
||
codpag_error,
|
||
row_type_error,
|
||
no_rows_error,
|
||
conto_error,
|
||
sconto_error,
|
||
spinbo_error,
|
||
movement_error,
|
||
write_error,
|
||
scadenze_error,
|
||
bank_error,
|
||
caus_ant_error,
|
||
counter_p_ant_error,
|
||
cau_abb_error,
|
||
cau_spe_error,
|
||
write_part_error,
|
||
intra_mov_error,
|
||
cont_seq_error,
|
||
cau_ritintra_error,
|
||
generic_error
|
||
};
|
||
|
||
class TBill;
|
||
class TMovimentoPN_VE;
|
||
class TSaldo_agg;
|
||
|
||
|
||
class TContabilizzazione : public TElaborazione // velib04b
|
||
{
|
||
bool _auto_data; // Flag per data di registrazione automatica
|
||
bool _nump_iva; // se TRUE prende il numero protocollo da registro iva, se no prende il numero protocollo dal numero doc.
|
||
TDate _data_reg; // Data di registrazione documenti
|
||
long _total_docs;// Numero di documenti contabilizzati
|
||
error_type _error; // Errore rilevato durante l'elaborazione
|
||
bool _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance
|
||
TString16 _spin_cod, // codice iva spese d'incasso
|
||
_spbo_cod; // codice iva spese bolli
|
||
TAssoc_array _totali_lordi;// array per totalizzare i lordi per aliquota, al fine di aggiustare gli imponibili
|
||
// nel caso di calcolo lordo sul documento
|
||
TIVA_array *_righe_iva; // array per la memorizzazione delle righe iva raggruppate in codesto modo:
|
||
// CODICE_IVA+TIPOCF+GRUPPO+CONTO+SOTTOCONTO+COMMESSA+FASE+DETRAIBILITA
|
||
// una volta completo, tale array viene scorso per comporre le righe IVA
|
||
// del movimento
|
||
|
||
// Files, tabelle, oggetti contabili ed altre amenita'...
|
||
TLocalisamfile *_anamag, // file delle anagrafiche di magazzino
|
||
*_fcaus,
|
||
*_frcaus,
|
||
*_attiv,
|
||
*_part,
|
||
*_scad,
|
||
*_pags,
|
||
*_intra,
|
||
*_rintra,
|
||
*_occas,
|
||
*_saldi,
|
||
*_docfile,
|
||
*_rdocfile;
|
||
|
||
TTable *_cpg, // tabella condizioni di pagamento
|
||
*_gmc, // tabella gruppi/sottogruppi merceologici
|
||
*_rfa, // tabella raggruppamenti fiscali
|
||
*_cve, // tabella categorie di vendita
|
||
*_val, // tabella valute estere
|
||
*_tri, // tabella tipi di riga
|
||
*_prs, // tabella prestazioni
|
||
*_spp, // tabella spese
|
||
*_caa, // tabella categorie acquisto articoli
|
||
*_cra, // tabella categorie ricavo articoli
|
||
*_cco; // tabella categorie contabili
|
||
TRelation *_clifo; // relazione dei clienti e fornitori + cfven
|
||
TViswin* _viswin; // Visualizzazione log di elaborazione
|
||
TBill _conto_errato; // Conto da visualizzare in messaggio d'errore
|
||
bool _check_prev_cont; // Controllare se il documento precedente e' stato contabilizzato
|
||
|
||
protected:
|
||
// Carica i parametri dalla configurazione
|
||
bool load_parameters();
|
||
// Testa il fatto che il documento sia una nota di credito/debito
|
||
bool test_swap();
|
||
// Ritorna l'ultimo numero di registrazione disponibile dei movimenti di prima nota
|
||
error_type get_next_reg_num(long &);
|
||
// Compila la testata del movimento
|
||
error_type compile_head_mov(TDocumento&);
|
||
// Compila la testata del movimento per le fatture da emettere / ricevere;
|
||
error_type compile_head_mov_re(TDocumento&);
|
||
// Funzione per ricercare il conto di costo/ricavo
|
||
error_type search_costo_ricavo(TBill&, const TRiga_documento&);
|
||
// Funzione per aggiungere la riga iva al TAssoc_array _righe_iva
|
||
// error_type add_iva_row(const TBill&, const TRiga_documento&, const int ndec, const real p = 1.0);
|
||
// Funzione atomica per aggiungere le righe di spese d'incasso e bolli al TAssoc_array _righe_iva
|
||
void calculate_spese(real&, real&, int, bool, bool, const TString &, const TDocumento & );
|
||
// Funzione per aggiungere le righe di spese d'incasso e bolli al TAssoc_array _righe_iva (chiama calculate_spese())
|
||
error_type add_spese_inbo(TDocumento&, const int);
|
||
// Aggiorna le righe di sconto importo o percentuale
|
||
error_type adjust_sconto_rows(TDocumento&);
|
||
// Controlla la corrispondenza tra limposta del documento e quelle generate
|
||
error_type adjust_iva_rows(TDocumento&);
|
||
// Crea le righe iva sul movimento
|
||
error_type create_iva_rows(TDocumento&);
|
||
// Crea la riga di totale documento
|
||
error_type create_total_doc_row(TDocumento&);
|
||
// Compila le righe del movimento
|
||
error_type compile_rows_mov(TDocumento&);
|
||
// Compila le righe del movimento per le fatture da emettere / ricevere
|
||
error_type compile_rows_mov_re(TDocumento&);
|
||
// scrive le scadenze
|
||
error_type write_scadenze(TDocumento&);
|
||
// scrive il movimento e le scadenze
|
||
virtual error_type write_all(TDocumento& doc, TMovimentoPN_VE & movimento);
|
||
// scrive il movimento e le scadenze per le fatture da emettere / ricevere
|
||
virtual error_type write_all_re(TDocumento& doc, TMovimentoPN_VE & movimento);
|
||
// restituisce la sezione per sto cliente
|
||
char sezione() const;
|
||
// Cerca il conto cliente per il movimento d'anticipo
|
||
error_type search_clifo_bill(TString &);
|
||
// Cerca il conto di contropartita per il movimento d'anticipo
|
||
error_type search_counter_bill(TDocumento&);
|
||
// compila la testata del movimento di anticipo
|
||
error_type compile_head_anticipo(TDocumento&);
|
||
// compila le righe del movimento di anticipo
|
||
error_type compile_rows_anticipo(TDocumento&);
|
||
// compila e scrive il pagamento del movimento di anticipo
|
||
error_type write_pagamento_anticipo(TDocumento&);
|
||
// scrive il movimento di anticipo pagamento
|
||
error_type write_anticipo(TDocumento&);
|
||
// scrive il movimento INTRA
|
||
error_type write_intra(TDocumento&);
|
||
// Aggiorna i saldi
|
||
void aggiorna_saldi(TSaldo_agg& saldo, TMovimentoPN& mv, bool save);
|
||
// Visualizza l'ultimo errore rilevato
|
||
void display_error(TDocumento&);
|
||
// Verifica se non ci sono stati errori
|
||
bool good() const { return _error == no_error;}
|
||
// Ritorna TRUE se il saldaconto e' abilitato (verifica anche la causale del documento corrente)
|
||
bool sc_enabled() const ;
|
||
// Ritorna TRUE se il modulo INTRA e' abilitato (verifica anche la causale del documento corrente)
|
||
bool in_enabled() const ;
|
||
public:
|
||
// Cambia lo stato del documento
|
||
error_type change_doc_status(TDocumento&);
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE);
|
||
void set_auto(const bool a) { _auto_data = a; }
|
||
void set_writeable(const bool b) { _can_write = b; }
|
||
const long processed_docs() const { return _total_docs; }
|
||
void inc_processed_docs() { _total_docs++; }
|
||
|
||
// Ritorna il numero dell'eventuale movimento con cui il documento stato contabilizzato
|
||
long doc_contabilized(const TDocumento& doc, bool anticipo) const;
|
||
|
||
// Personalizzazioni
|
||
bool call_exe(const TDocumento& doc, const TMovimentoPN& movimento) const;
|
||
|
||
// Ritorna TRUE se il documento precedente a doc e' gia' stato contabilizzato
|
||
bool prev_contabilized(const TDocumento& doc) const;
|
||
|
||
TContabilizzazione(const char* cod);
|
||
TContabilizzazione(const TRectype& rec);
|
||
virtual ~TContabilizzazione();
|
||
};
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// TContabilizzazione
|
||
///////////////////////////////////////////////////////////
|
||
|
||
// TMovimentoPN_VE
|
||
// Classe derivata da TMovimentoPN per calcolare automaticamente le righe conabili
|
||
// una volta settate le righe iva e la riga di totale documento
|
||
// Sostanzialmente di tratta di aggiungere un metodo in piu' :
|
||
// recalc_cg_rows(), liberamente ispirato alla notify_iva() in cg2102.cpp
|
||
|
||
class TMovimentoPN_VE : public TMovimentoPN
|
||
{
|
||
bool _valuta;
|
||
TCausale * _caus;
|
||
|
||
protected:
|
||
// simula il K_SPACE di iva_notify
|
||
void create_row(int i, const TString & descr_cr);
|
||
// simula il K_ENTER di iva_notify
|
||
void enter_row(int i, const TString & descr_cr);
|
||
// verifica se si tratta di iva indetraibile
|
||
bool detraibile(TRectype& rec) const ;
|
||
// cerca la prima tra quelle di contabilita' che corrisponde al tipo indicato
|
||
int type2pos(char tipo);
|
||
// Trova nelle righe contabili un conto nelle righe di tipo prescelto
|
||
int bill2pos(const TBill& conto, const TString & codcms, const TString & fascms, char tipo);
|
||
// trasforma un real in TImporto, in base al tipo riga
|
||
TImporto real2imp(const real& r, char row_type);
|
||
// setta il record delle righe di contabilita'
|
||
int insert_cg_rec(int n, const TImporto& imp, TBill& conto, const char * codcms, const char * fascms, const char* desc, char tipo);
|
||
// setta il record delle righe di contabilita'
|
||
int set_cg_rec(int n, const TImporto& imp, TBill& conto, const char * codcms, const char * fascms, const char* desc, char tipo);
|
||
// aggiunge l'importo indicato alla n-esima riga di contabilita'
|
||
bool add_cg_rec(int n, const TImporto& imp);
|
||
// Legge l'importo della riga n e lo ritorna col segno dovuto
|
||
TImporto get_cg_imp(int n);
|
||
// Setta l'importo della riga n
|
||
void set_cg_imp(int n, const TImporto& imp);
|
||
// verifica se il movimento e' quadrato oppure ha qualche maledetto sbilancio
|
||
// ritorna TRUE, ovviamente, se everything's alright.
|
||
public:
|
||
// ricalcola le righe di contabilita' dalle righe iva presenti
|
||
// e verifica la quadratura del movimento. Ritorna TRUE se il movimento e' scrivibile
|
||
void set_caus(TCausale * c) { _caus = c;}
|
||
bool movement_ok() ;
|
||
void add_row_re(int i);
|
||
bool add_row_cp_re(int i);
|
||
void map_conto_re(TBill & c);
|
||
void destroy_iva_row(int i = -1);
|
||
int recalc_cg_rows(const TString & descr_cr, TCausale & caus);
|
||
TMovimentoPN_VE(bool valuta) : _valuta(valuta), _caus(NULL) {};
|
||
virtual ~TMovimentoPN_VE() {}
|
||
};
|
||
|
||
class TCopia_documento : public TElaborazione // velib04
|
||
{
|
||
public:
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE);
|
||
|
||
TCopia_documento(const char* cod);
|
||
TCopia_documento(const TRectype& rec) : TElaborazione(rec) { }
|
||
virtual ~TCopia_documento() { }
|
||
};
|
||
|
||
|
||
class TGenerazione_effetti : public TElaborazione // velib04c
|
||
{
|
||
error_type _error; // Errore rilevato durante l'elaborazione
|
||
long _total_bills; // Totale effetti generati
|
||
bool _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance
|
||
TBit_array _valid_array; // array dei tipi di pagamento validi per la generazione di effetti
|
||
|
||
TLocalisamfile *_efffile, // file effetti
|
||
*_refffile, // file righe di effetti
|
||
*_cessfile,
|
||
*_docfile,
|
||
*_rdocfile,
|
||
*_clifo,
|
||
*_cfven,
|
||
*_tab,
|
||
*_occas;
|
||
TArray _effetti_array;//Array di effetti (TEffetto) da scrivere
|
||
protected:
|
||
// Visualizza l'ultimo errore rilevato
|
||
void display_error(TDocumento& doc);
|
||
// Restituisce TRUE se il tipo di pagamento passato e' valido per generare l'effetto
|
||
bool valid_type(int) const ;
|
||
// Genera l'effetto
|
||
void generate_bill(TDocumento&);
|
||
// Istanzia il pagamento corrente
|
||
void calc_pagamento(TDocumento&);
|
||
// Scrive i record array degli effetti raggruppati
|
||
error_type write_groups();
|
||
// Cambia lo stato dei gruppi di documenti raggruppati in effetti
|
||
error_type change_group_status(TDocumento&, TAssoc_array&);
|
||
// Cambia lo stato del documento
|
||
error_type change_doc_status(TDocumento&);
|
||
// Verifica se non ci sono stati errori
|
||
bool good() const { return _error == no_error;}
|
||
public:
|
||
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
||
const TDate& data_elab, bool interattivo = FALSE);
|
||
|
||
// Effettua il raggruppamento vero e proprio degli effetti (solo se ci sono elementi nell'assoc_array passato)
|
||
long group_bills(TAssoc_array&);
|
||
long bills() const { return _total_bills; }
|
||
// void set_group(TAssoc_array& a) { _group_array = a; }
|
||
void set_writeable(const bool b) { _can_write = b; }
|
||
|
||
TGenerazione_effetti(const char* cod);
|
||
TGenerazione_effetti(const TRectype& rec);
|
||
virtual ~TGenerazione_effetti();
|
||
};
|
||
|
||
class TLista_elaborazioni : public TObject // velib04
|
||
{
|
||
TAssoc_array * _elab;
|
||
|
||
protected:
|
||
void read();
|
||
|
||
public:
|
||
TElaborazione & operator [](const char * key) const;
|
||
int select(TString_array & result, const char * tipo_iniziale = NULL, const char * stato_iniziale = NULL, const char * tipo_finale = NULL, const char * stato_finale = NULL);
|
||
void update();
|
||
TLista_elaborazioni() : _elab(NULL) {}
|
||
virtual ~TLista_elaborazioni();
|
||
};
|
||
|
||
struct dec_parm {
|
||
int qta_lit,
|
||
qta_val;
|
||
// add other groups here
|
||
};
|
||
|
||
//////////////////////////////////////////////////////////////////////////////////////////////
|
||
// classe TDocumentoEsteso: oggetto che ha come finalita' il calcolo dei riepiloghi IVA
|
||
//////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
||
class TDocumentoEsteso : public TDocumento
|
||
{
|
||
// Parametri del documento
|
||
dec_parm _parm; // Parametri per gli arrotondamenti
|
||
|
||
// Totali del documento ricalcolati non appena la tabellina di riepilogo IVA e' completa
|
||
// real _importi_netti, _imposte;
|
||
|
||
// membri per il calcolo del riepilogo IVA
|
||
int _sum_filter; // Filtro corrente della riga TRiepilogo_iva in corso di stampa (-1 se non ha ancora calcolato la tabella)
|
||
bool _sum_selected; // TRUE se ha selezionato una riga del riepilogo, funge da semaforo per leggere la prossima
|
||
TString_array _order_array; // Array di TToken_string contenenti i codici IVA soddisfacenti ad ogni tipo di filtro
|
||
TAssoc_array _summary_table; // Array associativo contenete imonibili ed imposte pronte per la stampa;
|
||
TArray _summary_array; // Array dove vengono memorizzate le imposte/imponibili per riga
|
||
TRiepilogo_iva _sum_current; // Riga corrente del riepilogo
|
||
|
||
// membri per il calcolo del riepilogo scadenze
|
||
TString_array _scadenze_array;// Array che contiene le scadenze ("<data>|<importo>")
|
||
int _scadenze_current; // indice per identificare l'elementi corrente sull'array (-1 se non ha ancora calcolato)
|
||
|
||
public:
|
||
// Funzioni per il riepilogo IVA
|
||
const bool summary_compiled() { return _sum_filter > -1; }
|
||
void compile_summary(); // Aggiorna la tabella riepilogativa
|
||
void summary_filter(byte selector); // filtra la tabellina secondo il filtro corrente se non e' gia' stato fatto
|
||
void summary_reset(bool force=FALSE); // riposiziona l'array dei codici IVA (_order_array). Se il parametro e' TRUE forza il ricalcolo della tabella
|
||
void summary_set_next(); // seleziona il prossimo elemento del filtro
|
||
const TRiepilogo_iva& sum_current() const { return _sum_current; } // ritorna la riga corrente del filtro corrente
|
||
const char * summary_get(const TString& w); // ritorna l'informazione richiesta estratta dall'elemento corrente
|
||
int summary_items() { return tabella_iva().items();} // ritorna il numero di righe in totale della tabellina
|
||
const TAssoc_array& summary() const { return _summary_table; }
|
||
const TArray& summary_array() const { return _summary_array;}
|
||
|
||
// Funzioni per il ricalcolo delle scadenze
|
||
void scadenze_reset(); // riposiziona sulla prima scadenza
|
||
void scadenze_recalc(); // resetta e ricalcola le scadenze
|
||
void scadenze_set_next(); // seleziona il prossimo elemento dell'array delle scadenze
|
||
const char * scadenze_get(const TString& w); // reperisce l'informazione richiesta dall'elemento corrente
|
||
int scadenze_items() { return _scadenze_array.items(); } // restituisce il numero di scadenze
|
||
TString_array& scadenze() { return _scadenze_array; }
|
||
|
||
// restituisce tot_imponibili, tot_esenti, tot_nonsoggetti a seconda del selettore:
|
||
// 1 = regime normale
|
||
// 2 = da ventilare (non usato)
|
||
// 4 = esenti
|
||
// 8 = non imponibili
|
||
// 16 = non soggetti
|
||
// pertanto i non imponibili avranno selettore 1 e gli esenti selettore 4.
|
||
// per avere esenti + non soggetti il selettore sara' 20 e cosi' via.
|
||
real tot_imponibili(byte selector);
|
||
|
||
// Funzioni per settare i parametri
|
||
void set_decimals(dec_parm & parm) { _parm = parm ; }
|
||
// void set_condv(TCli_for * cli); // Cambia le condizioni di vendita
|
||
TDocumentoEsteso (const TRectype & rec, dec_parm & parm) ;
|
||
TDocumentoEsteso (const TRectype & rec) ;
|
||
TDocumentoEsteso () ;
|
||
virtual ~TDocumentoEsteso();
|
||
};
|
||
|
||
#endif
|