From eaf8479508257c759abea35000c3192d4a222e13 Mon Sep 17 00:00:00 2001 From: guy Date: Fri, 6 May 2005 11:02:46 +0000 Subject: [PATCH] Patch level : 2.2 Files correlati : ve0 e indovina Ricompilazione Demo : [ ] Commento : Spostate tutte le elaborazioni da velib.h a veli04.h git-svn-id: svn://10.65.10.50/trunk@13060 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- ve/velib04.h | 466 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 466 insertions(+) create mode 100755 ve/velib04.h diff --git a/ve/velib04.h b/ve/velib04.h new file mode 100755 index 000000000..8db94b31d --- /dev/null +++ b/ve/velib04.h @@ -0,0 +1,466 @@ +#ifndef __VELIB04_H +#define __VELIB04_H + +#ifndef __VELIB_H +#include "velib.h" +#endif + +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() {}; +}; + +enum TTipo_elaborazione { _esterna, _consegna_ordini, _fatturazione_bolle, + _contabilizzazione, _copia_documento, + _generazione_effetti, _consuntivazione_produzione, + _contabilizzazione_analitica }; + +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"); } + bool usa_data_consegna() const { return get_bool("B9"); } + + 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) : TElaborazione(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, + intra_rett_error, + cont_seq_error, + cau_ritintra_error, + generic_error +}; + +class TBill; +class TSaldo_agg; + + +/////////////////////////////////////////////////////////// +// 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, 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* desc, char tipo); + // setta il record delle righe di contabilita' + int set_cg_rec(int n, const TImporto& imp, const TBill& conto, 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); + +public: + 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 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 + *_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&); + error_type write_anal(const TDocumento& doc, const TMovimentoPN& mv); + + // 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 ; + // Controlla se il tipo riga esiste + bool valid_row_type(const char* rt) 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(); +}; + + +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 TConsuntivazione_produzione : public TElaborazione // velib04e +{ +public: + virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, + const TDate& data_elab, bool interattivo = FALSE); + + TConsuntivazione_produzione(const char* cod) : TElaborazione(cod) { } + TConsuntivazione_produzione(const TRectype& rec) : TElaborazione(rec) { } + virtual ~TConsuntivazione_produzione() { } +}; + +class TContabilizzazione_analitica : public TElaborazione // velib04e +{ +public: + virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, + const TDate& data_elab, bool interattivo = FALSE); + bool elabora(const TDocumento& doc_in, const TImporto& totdoc); + + TContabilizzazione_analitica(const char* cod) : TElaborazione(cod) { } + TContabilizzazione_analitica(const TRectype& rec) : TElaborazione(rec) { } + virtual ~TContabilizzazione_analitica() { } +}; + +#endif