829 lines
30 KiB
C++
Executable File
829 lines
30 KiB
C++
Executable File
#ifndef __VELIB_H
|
|
#define __VELIB_H
|
|
|
|
|
|
#ifndef __RELATION_H
|
|
#include <relation.h>
|
|
#endif
|
|
|
|
#ifndef __RECARRAY_H
|
|
#include <recarray.h>
|
|
#endif
|
|
|
|
#ifndef __VARREC_H
|
|
#include <varrec.h>
|
|
#endif
|
|
|
|
#ifndef __VARMASK_H
|
|
#include <varmask.h>
|
|
#endif
|
|
|
|
#ifndef __PAGAMENT_H
|
|
#include "../cg/pagament.h"
|
|
#endif
|
|
|
|
#ifndef __TCLIFOR_H
|
|
#include "tclifor.h"
|
|
#endif
|
|
|
|
#define RIGA_MERCE 'M'
|
|
#define RIGA_SPESEDOC 'S'
|
|
#define RIGA_PRESTAZIONI 'P'
|
|
#define RIGA_SCONTI 'C'
|
|
#define RIGA_OMAGGI 'O'
|
|
#define RIGA_DESCRIZIONI 'D'
|
|
|
|
class TDocumento;
|
|
class TRiga_documento;
|
|
class TCond_vendita;
|
|
class TIVA;
|
|
|
|
// velib01
|
|
real lordo2netto(real& lordo, const TString& codiva, int ndec);
|
|
inline real lordo2netto(real& lordo, const TString& codiva, bool is_valuta = FALSE) { return lordo2netto(lordo, codiva, is_valuta ? 3 : 0);}
|
|
real netto2lordo(const real& netto, const TString& codiva, int ndec);
|
|
inline real netto2lordo(const real& netto, const TString& codiva, bool is_valuta = FALSE) { return netto2lordo(netto, codiva, is_valuta ? 3 : 0);}
|
|
real lordo2netto(real& lordo, const real& iva, int ndec);
|
|
inline real lordo2netto(real& lordo, const real& iva, bool is_valuta = FALSE) {return lordo2netto(lordo, iva, is_valuta ? 3 : 0); }
|
|
real netto2lordo(const real& netto, const real& iva, int ndec);
|
|
inline real netto2lordo(const real& netto, const real& iva, bool is_valuta = FALSE) { return netto2lordo(netto, iva, is_valuta ? 3 : 0); }
|
|
real prezzo_scontato(const real& prezzo, const char * sconto);
|
|
real iva(real imponibile, const TIVA & codiva,int ndec);
|
|
|
|
bool ora_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);
|
|
|
|
class TDocumento_variable_field : public TVariable_field
|
|
{
|
|
bool _dirty;
|
|
|
|
public:
|
|
// @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, 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
|
|
~TDocumento_variable_field() {}
|
|
};
|
|
|
|
class TSpesa_prest : public TRectype // velib01
|
|
{
|
|
|
|
protected:
|
|
int read(const char* codice);
|
|
|
|
public:
|
|
TObject* dup() const { return new TSpesa_prest(codice()); }
|
|
|
|
public:
|
|
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"); }
|
|
char tipo() const { return get_char("S6"); }
|
|
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 ? new TExpr_documento(*_expr) : NULL;}
|
|
|
|
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, _fattura, _bolla, _ordine};
|
|
|
|
static TAssoc_array _formule_documento;
|
|
TToken_string _formule;
|
|
TString16 _imponibile;
|
|
TString16 _imposta;
|
|
TString16 _totale;
|
|
TString16 _totale_netto;
|
|
TString16 _basesconto;
|
|
TString16 _spese;
|
|
|
|
protected:
|
|
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 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; }
|
|
|
|
const TString& descrizione() const { return get("S0"); }
|
|
const TString& riferimento() const { return get("S1"); }
|
|
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& basesconto() const { return _basesconto;}
|
|
const TString& spese() const { return _spese;}
|
|
|
|
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"); }
|
|
|
|
TTipo_documento(const char* tipodoc = NULL);
|
|
TTipo_documento(const TRectype& rec);
|
|
virtual ~TTipo_documento();
|
|
};
|
|
|
|
class TTipo_riga_documento : public TRectype // velib02
|
|
{
|
|
|
|
static TAssoc_array _formule_riga;
|
|
TToken_string _formule;
|
|
TString16 _name;
|
|
TString16 _imponibile;
|
|
TString16 _imposta;
|
|
TVariable_mask * _mask;
|
|
|
|
protected:
|
|
void read_formule();
|
|
int read(const char* tiporig);
|
|
|
|
public:
|
|
TObject* dup() const { return new TTipo_riga_documento(codice()); }
|
|
|
|
public:
|
|
const TString& profile_name() const { return _name;}
|
|
const TString& mask_name() const { return profile_name();}
|
|
const TString& codice() const { return get("CODTAB");}
|
|
bool mask_loaded() const { return _mask != NULL; }
|
|
TVariable_mask * mask();
|
|
|
|
const TString& descrizione() const { return get("S0"); }
|
|
char tipo() const { return get_char("S7"); }
|
|
const TString& imponibile() const { return _imponibile;}
|
|
const TString& imposta() const { return _imposta;}
|
|
|
|
TFormula_documento * first_formula() { return succ_formula(TRUE); }
|
|
TFormula_documento * succ_formula(bool restart = FALSE);
|
|
|
|
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 TAssoc_array _tipi;
|
|
static TAssoc_array _spese;
|
|
static TAssoc_array _ive;
|
|
bool _iva_calc;
|
|
|
|
|
|
protected:
|
|
// @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
|
|
virtual void put_str(const char* fieldname, const char* val);
|
|
|
|
protected:
|
|
TObject* dup() const { return new TRiga_documento(*this); }
|
|
|
|
public:
|
|
void dirty_fields(bool dirty_document = TRUE);
|
|
bool doc_dependent() const;
|
|
int numero() const { return get_int("NRIGA");}
|
|
void set_numero(int numero) { put("NRIGA", numero);}
|
|
bool generata() const { return get_bool("GENERATA");}
|
|
void set_generata(bool on = TRUE) { put("GENERATA", on);}
|
|
// @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 TIVA & iva(const char * codice);
|
|
const TIVA & iva() const {const TString16 cod(get("CODIVA")); return iva(cod);}
|
|
|
|
const bool tipo_valido() const { return get("TIPORIGA").not_empty(); }
|
|
void set_tipo(const char * tipo) { put("TIPORIGA", tipo);}
|
|
bool sola_descrizione() const;
|
|
void forza_sola_descrizione();
|
|
|
|
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) const ;
|
|
real importo(bool scontato, bool lordo, int ndec) const ;
|
|
real iva(int ndec) const;
|
|
real imponibile() const;
|
|
real imposta(bool round = TRUE) const;
|
|
|
|
TRiga_documento(TDocumento* doc, const char * tipo = NULL);
|
|
TRiga_documento(const TRiga_documento& rec, TDocumento* doc,
|
|
const char * tipo = NULL);
|
|
virtual ~TRiga_documento() {}
|
|
};
|
|
|
|
enum TTipo_importo { _lordo, _netto, _imposta };
|
|
|
|
class TDocumento : public TAuto_variable_rectype // velib03
|
|
{
|
|
static TAssoc_array _tipi;
|
|
|
|
TRecord_array _rows; // Array di TRectype per le righe documenti di vendita.
|
|
bool _nuovo;
|
|
|
|
TRelation * _rel;
|
|
TCond_vendita * _condv;
|
|
TPagamento _pag;
|
|
TRiga_documento * _sconto; // Riga per lo sconto di testata
|
|
TRiga_documento * _esenzione; // Riga per l' esenzione iva
|
|
|
|
protected:
|
|
TRiga_documento & row(int index);
|
|
long get_next_key(char provv, int anno, const char* codnum) const;
|
|
virtual void put_str(const char* fieldname, const char* val);
|
|
long renum(long numdoc = 0);
|
|
void set_riga_sconto();
|
|
void set_riga_esenzione();
|
|
|
|
public:
|
|
void dirty_fields();
|
|
const TAuto_variable_rectype& head() const { return *this; } // Ritorna la testata del documento
|
|
TAuto_variable_rectype& head() { return *this; } // Ritorna la testata del documento
|
|
|
|
TCond_vendita & condv() const {CHECK(_condv, "Condizioni di vendita nulle"); return *_condv;}
|
|
TRelation & get_relation() const {CHECK(_rel, "Relazione nulla"); return *_rel;}
|
|
void set_condv(TCond_vendita * condv) { _condv = condv; }
|
|
void set_relation(TRelation * rel) { _rel = rel; }
|
|
|
|
virtual TDocumento & operator =(const TDocumento & 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');
|
|
|
|
int physical_rows() const { return _rows.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); }
|
|
|
|
TRiga_documento& insert_row(int row, const char *tipo = NULL);
|
|
TRiga_documento& new_row(const char *tipo = NULL);
|
|
bool destroy_row(int n, bool pack = FALSE) { return _rows.destroy_row(n, pack); }
|
|
void destroy_rows() { _rows.destroy_rows(); }
|
|
|
|
int read(char provv, int anno, const char* codnum, long numdoc);
|
|
int read(const TRectype& rec);
|
|
|
|
int write(bool re = FALSE) const;
|
|
int rewrite() const { return write(TRUE); }
|
|
int remove() const;
|
|
|
|
char tipo_numerazione() const { return get_char("PROVV"); }
|
|
int anno() const { return get_int("ANNO"); }
|
|
const TString& numerazione() { return get("CODNUM"); }
|
|
long numero() const { return get_long("NDOC"); }
|
|
TDate data() const { return get_date("DATADOC"); }
|
|
const bool in_valuta() const;
|
|
const TString& valuta() const { return get("CODVAL"); }
|
|
const real cambio() const { return get_real("CAMBIO"); }
|
|
bool tipo_valido() const { return get("TIPODOC").not_empty(); }
|
|
const TTipo_documento& tipo() const;
|
|
void set_tipo(const char * tipo) { head().put("TIPODOC", tipo);}
|
|
|
|
char stato() const { return get_char("STATO"); }
|
|
void stato(char s) { put("STATO", s); }
|
|
|
|
bool raggruppabile() const { return get_bool("RAGGR"); }
|
|
bool raggruppabile(const TDocumento& doc, TToken_string& campi) const;
|
|
|
|
static void set_key(TRectype& rec, char provv, int anno, const char* codnum, long numdoc);
|
|
static void copy_data(TRectype& dst, const TRectype& src);
|
|
void copy_contents(const TDocumento & src);
|
|
|
|
void reset_fields(TAuto_variable_rectype & rec) { rec.remove_field(); }
|
|
void set_fields(TAuto_variable_rectype & rec);
|
|
|
|
|
|
real spese_incasso(real & imp, int ndec, TTipo_importo netto = _lordo) const ;
|
|
real bolli(real & imp, int ndec, TTipo_importo netto = _lordo) const ;
|
|
real descrizione() const;
|
|
real riferimento() const;
|
|
real imponibile(bool spese = FALSE, int ndec = 100) const;
|
|
real imposta(bool spese = FALSE, int ndec = 100) const;
|
|
real totale_doc() const;
|
|
real totale_netto() const;
|
|
real basesconto() const;
|
|
real spese() const;
|
|
|
|
TPagamento & pagamento();
|
|
|
|
void update_spese_aut(TString_array & spese, bool preserve_old = FALSE, TSheet_field * sh = NULL);
|
|
|
|
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(); }
|
|
|
|
|
|
TDocumento ();
|
|
TDocumento(char provv, int anno, const char* codnum, long numdoc,
|
|
TCond_vendita * condv = NULL, TRelation * rel = NULL);
|
|
TDocumento(const TRectype& doc, TCond_vendita * condv = NULL,
|
|
TRelation * rel = NULL);
|
|
virtual ~TDocumento();
|
|
};
|
|
|
|
class TDocumento_mask : public TVariable_mask // velib03
|
|
{
|
|
int _progs_page; // pagina in cui cominciano i progressivi
|
|
int _last_prog; // numero dell'ultimo progressivo
|
|
TDocumento * _doc; // documento
|
|
|
|
protected:
|
|
virtual void next_page(int p);
|
|
|
|
public:
|
|
virtual bool on_key(KEY key);
|
|
TDocumento & doc() const {CHECK(_doc, "Documento nullo"); return *_doc;}
|
|
TCond_vendita & condv() const {CHECK(_doc, "Documento nullo"); return _doc->condv();}
|
|
TRelation & get_relation() const {CHECK(_doc, "Documento nullo"); return _doc->get_relation();}
|
|
|
|
TDocumento_mask(const char* name, TDocumento * _doc, int num = 0, int max = MAX_PAGES);
|
|
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); }
|
|
|
|
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, long dz = 0, long az = 0);
|
|
|
|
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 TElaborazione : public TRectype // velib04
|
|
{
|
|
protected:
|
|
int read(const char* cod);
|
|
|
|
public:
|
|
const TString& codice() const { return get("CODTAB"); }
|
|
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"); }
|
|
bool interattivo() const { return get_bool("B5"); }
|
|
bool insert_mode() const { return get_bool("B6"); }
|
|
|
|
const TString& tipo_iniziale(int i) const { return get("S8").mid(i*4, 4); }
|
|
const char stato_iniziale(int i) const { return get("S9")[i]; }
|
|
const TString& tipo_finale() const { return get("S8"); }
|
|
const TString& stato_finale() const { return get("S9"); }
|
|
|
|
char tipo_numerazione() const { return get_bool("B4") ? 'P' : 'D'; }
|
|
const TString& codice_numerazione_finale() const { return get("S6"); }
|
|
const TString & applicazione_esterna() const { return get("S5"); }
|
|
|
|
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab) pure;
|
|
|
|
TElaborazione(const char* cod);
|
|
TElaborazione(const TRectype& rec) : TRectype(rec) { }
|
|
virtual ~TElaborazione() { }
|
|
};
|
|
|
|
class TEsterna : public TElaborazione // velib04
|
|
{
|
|
public:
|
|
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab);
|
|
|
|
TEsterna(const char* cod);
|
|
TEsterna(const TRectype& rec) : TElaborazione(rec) { }
|
|
virtual ~TEsterna() { }
|
|
};
|
|
|
|
class TConsegna_ordini : public TElaborazione // velib05
|
|
{
|
|
public:
|
|
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab);
|
|
|
|
TConsegna_ordini(const char* cod);
|
|
TConsegna_ordini(const TRectype& rec) : TElaborazione(rec) { }
|
|
virtual ~TConsegna_ordini() { }
|
|
};
|
|
|
|
class TFatturazione_bolle : public TElaborazione // velib04
|
|
{
|
|
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);
|
|
|
|
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() { }
|
|
};
|
|
|
|
class TContabilizzazione : public TElaborazione // velib04
|
|
{
|
|
public:
|
|
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab);
|
|
|
|
TContabilizzazione(const char* cod);
|
|
TContabilizzazione(const TRectype& rec) : TElaborazione(rec) { }
|
|
virtual ~TContabilizzazione() { }
|
|
};
|
|
|
|
class TCopia_documento : public TElaborazione // velib04
|
|
{
|
|
public:
|
|
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab);
|
|
|
|
TCopia_documento(const char* cod);
|
|
TCopia_documento(const TRectype& rec) : TElaborazione(rec) { }
|
|
virtual ~TCopia_documento() { }
|
|
};
|
|
|
|
|
|
class TGenerazione_effetti : public TElaborazione // velib04
|
|
{
|
|
public:
|
|
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
|
|
const TDate& data_elab);
|
|
|
|
TGenerazione_effetti(const char* cod);
|
|
TGenerazione_effetti(const TRectype& rec) : TElaborazione(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, bool interattivo, bool insert_mode, 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 pri_lit,
|
|
pri_val,
|
|
qta_lit,
|
|
qta_val, // si lo so non ha senso, ma lo faccio lo stesso
|
|
imp_lit,
|
|
imp_val;
|
|
// add other groups here
|
|
};
|
|
|
|
class TCodice_numerazione : public TRectype
|
|
{
|
|
int _status;
|
|
public:
|
|
TObject* dup() const { return new TCodice_numerazione(codice()); }
|
|
|
|
public:
|
|
int read(const char * cod);
|
|
const TString& codice() const { return get("CODTAB"); }
|
|
const TString& prefisso() const { return get("S6"); }
|
|
const TString& postfisso() const { return get("S7"); }
|
|
const bool manual_num() const { return get_bool("B0"); }
|
|
const bool auto_num() const { return get_bool("B1"); }
|
|
const TString& tipo_doc1() { return get("S2").mid(0,4);}
|
|
const TString& tipo_doc2() { return get("S2").mid(4,4);}
|
|
const TString& tipo_doc3() { return get("S2").mid(8,4);}
|
|
const TString& tipo_doc4() { return get("S2").mid(12,4);}
|
|
const TString& tipo_doc5() { return get("S2").mid(16,4);}
|
|
|
|
const char * complete_num (long num);
|
|
int status() { return _status; }
|
|
TCodice_numerazione(const char* codnum = NULL);
|
|
TCodice_numerazione(const TRectype& rec);
|
|
virtual ~TCodice_numerazione();
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
// classe TDocumentoEsteso: oggetto che ha come finalita' il calcolo dei riepiloghi IVA
|
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class TRiepilogo_Iva : public TObject
|
|
{
|
|
real _imp;
|
|
real _iva;
|
|
real _ali;
|
|
byte _tipo;
|
|
TString16 _cod;
|
|
TString _des;
|
|
|
|
protected:
|
|
|
|
public:
|
|
real& imp() { return _imp;} // Imponibile
|
|
real& iva() { return _iva;} // Iva
|
|
real& ali() { return _ali;} // Aliquota
|
|
TString& cod() { return _cod;} // Descrizione
|
|
TString& des() { return _des;} // Descrizione
|
|
byte& tipo(){ return _tipo;}// Tipo (Vedi opzioni per la selzione di filtro nella validate())
|
|
void zero(){ _imp = 0.0; _iva = 0.0; _ali = 0.0; _tipo = 0; _cod = ""; _des = ""; }
|
|
virtual TObject* dup() const { return new TRiepilogo_Iva(*this); }
|
|
TRiepilogo_Iva& operator = (TRiepilogo_Iva& a);
|
|
TRiepilogo_Iva() {_imp = 0.0; _iva = 0.0; _ali = 0.0; _tipo = 0;}
|
|
~TRiepilogo_Iva() {};
|
|
};
|
|
|
|
class TDocumentoEsteso : public TDocumento
|
|
{
|
|
// Parametri del documento
|
|
dec_parm _parm; // Parametri per gli arrotondamenti
|
|
TTable * _iva; // Tabella codici IVA
|
|
|
|
// Totali del documento ricalcolati non appena la tabellina di riepilogo IVA e' completa
|
|
real _importi_netti, _imposte;
|
|
|
|
// membri per il calcolo del riepilogo IVA
|
|
bool _sum_selected; // TRUE se ha selezionato una riga del riepilogo, funge da semaforo per leggere la prossima
|
|
int _sum_filter; // Filtro corrente della riga TRiepilogo_Iva in corso di stampa (-1 se non ha ancora calcolato la tabella)
|
|
TString_array _order_array; // Array di TToken_string contenenti i codici IVA soddisfacenti ad ogni tipo di filtro
|
|
TAssoc_array _summary_table; // Array dove vengono memorizzate le imposte per aliquota
|
|
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() { 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 _summary_table.items();} // ritorna il numero di righe in totale della tabellina
|
|
const TAssoc_array& summary() { return _summary_table; }
|
|
const TArray& summary_array() { 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; }
|
|
|
|
// Funzioni di totalizzazione
|
|
real& tot_importi_netti();
|
|
real& tot_imposte();
|
|
real tot_spese();
|
|
real tot_documento();
|
|
// 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);
|
|
|
|
// Reperisce l'informazione <what> dal campo G1 della testata
|
|
const char* get_head_info(const TString& what);
|
|
|
|
// Funzioni per settare i parametri
|
|
void set_decimals(dec_parm & parm) { _parm = parm ; }
|
|
void set_condv(TCliFor * cli); // Cambia le condizioni di vendita
|
|
TDocumentoEsteso (const TRectype & rec, dec_parm & parm, TCond_vendita * condv = NULL) ;
|
|
TDocumentoEsteso (const TRectype & rec, TCond_vendita * condv = NULL) ;
|
|
TDocumentoEsteso () ;
|
|
~TDocumentoEsteso();
|
|
};
|
|
|
|
|
|
#endif
|