9ecc861e7b
Files correlati : ve0.exe ve6.exe Ricompilazione Demo : [ ] Commento : GF20114 Il paragrafo [DEFAULTS] dei profili dei documenti contiene la lista dei valori di default da assegnare a certi campi della maschera di immissione. Tale paragrafo nella versione a 32 bit viene completamente ignorato, mentre nella precedente versione funzionava "quasi" sempre. GF20115 Se si cerca di contabilizzare una fattura di vendita con calcolo al lordo e con sconti "di testa", la procedura tenta di generare un movimento sbilanciato e quindi fallisce. Il problema sembra essere nel fatto che il totale documento e' corretto, mentre imponibile e iva non tengono conto dello sconto. Se si utilizzano gli sconti "di riga" o si toglie il calcolo al lordo, tutto funziona bene. GF20116 Nell'eventualità avessimo una causale contabile definita sull'anagrafica di un nostro cliente/fornit bisogna fare in modo che se stiamo contabilizzando una nota di credito la causale utilizzata non sia quella prevista in anagrafica, ma bensì quella prevista nella tipologia del documento sul quale naturalmente ci sarà la spunta di nota di credito/debito (questa appunto può essere la discriminante) git-svn-id: svn://10.65.10.50/trunk@11704 c028cbd2-c16b-5b4b-a496-9718f37d4682
1417 lines
55 KiB
C++
Executable File
1417 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 "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
|
||
{
|
||
TCausale * _caus;
|
||
bool _valuta;
|
||
|
||
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
|
||
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 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 |