root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib04.h
alex 520f73114a Patch level : 2.2 112 
Files correlati     : ve0.exe bacnv.exe profili riga e documento
Ricompilazione Demo : [ ]
Commento            :

Bug 0000423

Possibilità di variare il tipo riga direttamente sulla riga
Possibilità di selezionare piu' documenti in caso di elaborazione interattiva che aggiunge al documento attuale
Modificati i profili documento per le definizioni dei tipi riga colonne handlers etc..
Per quest'ultimo esiste il programma di conversione bacnv 23 nomeprofilo.ini


git-svn-id: svn://10.65.10.50/trunk@13151 c028cbd2-c16b-5b4b-a496-9718f37d4682
2005-05-25 11:32:58 +00:00

493 lines
20 KiB
C++
Executable File
Raw Blame History

#ifndef __VELIB04_H
#define __VELIB04_H
#ifndef __VELIB_H
#include "velib.h"
#endif
#ifndef __CALIB01_H
#include "../ca/calib01.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:
bool find(char provv, int anno, const char * codnum, long ndoc) const;
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"); }
bool kill_descrizione_estesa() const { return get_bool("B10"); }
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
{
protected:
bool calcola_ncolli_tara_pnetto(const TString& codart, const real& qta,
real& nolli, real& tara, real& pnetto) const;
bool aggiorna_ncolli_tara_pnetto(TRiga_documento& r) const;
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
{
protected:
bool ref2doc(char & provv, int & anno, TString8 & codnum, long & ndoc, int & nriga, const TString & codart);
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 // velib04b
{
error_type _error; // Errore rilevato durante l'elaborazione
protected:
error_type search_costo_ricavo(const TRiga_documento& riga, TBill& conto);
bool find_conti(const TRiga_documento& riga, TString_array& conti);
const TCausale& doc2caus(const TDocumento& doc);
const TCausale& rdoc2caus(const TRiga_documento& rdoc);
void init_distrib(TString_array& conti, TGeneric_distrib& distrib);
public:
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo = false);
bool elabora(const TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write);
TContabilizzazione_analitica();
TContabilizzazione_analitica(const TRectype& rec);
virtual ~TContabilizzazione_analitica();
};
#endif
Reference in New Issue View Git Blame Copy Permalink