root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/velib04.h
alex 8e11b8a91a Patch level : 10.0 patch 820 
Files correlati     : ve0.exe ve6.exe
Ricompilazione Demo : [ ]
Commento

Nella distribuzione delle spese  senza conto sui movimenti contabile e analitico ora non cosidera piu' le righe di spesa.
NB queste spese devono essere esenti per poter utilizzare questo meccanismo.


git-svn-id: svn://10.65.10.50/branches/R_10_00@21000 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-10-12 16:17:48 +00:00

645 lines
26 KiB
C++
Executable File
Raw Blame History

#ifndef __VELIB04_H
#define __VELIB04_H
#ifndef __VELIB_H
#include "velib.h"
#endif
#ifndef __CG2101_H
#include "../cg/cg2101.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() {};
};
///////////////////////////////////////////////////////////
// Lista Cliente/Fornitore per vendite
///////////////////////////////////////////////////////////
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 = "");
int leggi_ragsoc(const char *dr, const char * ar, 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'; }
};
class TLista_cf : public TLista_clifo
{
char _tipo;
protected:
virtual char tipo() const { return _tipo; }
public:
TLista_cf(char tipo) : _tipo(tipo) {}
};
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);
virtual void pre_process_input(TLista_documenti& doc_in) {}
virtual void post_process_input(TLista_documenti& doc_in) {}
virtual void post_process(TLista_documenti& doc_out, TLista_documenti& doc_in) {}
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"); }
virtual void tipi_stati_iniziali(TToken_string& tipi, TToken_string& stati) const;
bool doc_uguale(int u) const { return get("S1").mid(u, 1) == "X"; }
bool riga_uguale(int u) const { return get("S1").mid(40+u, 1) == "X"; }
bool raggruppa_righe() const { return get_bool("B0"); }
virtual bool gestione_riferimenti() const { return get_bool("B1"); }
virtual 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 protocollo_da_registro() const { return get_bool("B4"); }
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"); }
bool pack_rif() const { return get_bool("B15"); }
bool calcola_scarti() const { return get_bool("B11"); }
bool reload_prices() { return get_bool("B13"); }
const TString & num_riferimenti_in() const { return get("S11"); }
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;}
bool is_document_ok(const TRectype & doc) const ;
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:
bool nettifica() { return get_bool("B12"); }
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, _lista_campi, _rowsort;
bool _cambia_codice;
real _impminfat;
protected:
virtual void campi_raggruppamento_righe(TToken_string& campi_riga) const;
virtual void campi_raggruppamento(TToken_string& campi) const;
virtual bool doc_raggruppabile(const TDocumento & doc) const { return doc.raggruppabile(); }
virtual bool doc_raggruppabili(const TDocumento & doc_in, const TDocumento & doc_out, TToken_string & campi) const;
virtual void add_rows(TRiga_documento & rout, TRiga_documento & rin) { rout += rin; }
virtual void create_row(TDocumento& doc_out, const TRiga_documento & rin);
virtual const TString & get_tipo_out(const TDocumento & doc_out) { return get("S8"); }
virtual bool da_raggruppare(const TRiga_documento & rin) { return true; }
virtual void elabora_riga(TRiga_documento& r, TDocumento& doc_out, bool usa_dcons, bool ragg_rig, bool ignora_desc,
TToken_string & campi_riga, const TDate & dcons, const TDate & ddoc);
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);
bool change_clifo() { return get_bool("B14"); }
TFatturazione_bolle(const char* cod);
TFatturazione_bolle(const TRectype& 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,
contocf_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,
m770_write_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_ENTER di iva_notify
void enter_row(int i, const TString & descr_cr);
// 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);
void add_row_tot_re(TDocumento& doc);
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
int _nrow; // numero di riga documento errata
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
TString16 _fld_cms_cont; // Campo delle commesse per reperire la causale
protected:
// Carica i parametri dalla configurazione
bool load_parameters();
// Testa il fatto che il documento sia una nota di credito/debito
bool test_swap();
// Istanzia la causale contabile
TCausale * get_caus(const TDocumento& doc, const int year);
// 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&);
bool spalma_spese() const { return get("I2") == "X"; }
// Funzione per distribuire le spese
void split_sp_amount(const real & amount, int decimals);
// Funzione per ricercare il conto di costo/ricavo
error_type search_costo_ricavo(TBill& conto, const TRiga_documento& r, real & amount_to_split, const real & valore);
// Funzione per ricercare il conto di costo/ricavo materiali
error_type search_costo_ricavo_mat(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(const TString& catven);
// Cerca il conto di contropartita per il movimento d'anticipo
error_type search_counter_bill(TDocumento& doc, const TDate& datareg);
// 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(TDocumento& doc, const TMovimentoPN& mv);
error_type write_percip(TDocumento& doc, const TMovimentoPN& movimento);
TRecnotype kill_righe_percip(TIsam_handle logic, char tipopercip, long codpercip, long nprog) const;
// 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 TDate& data) 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;
virtual void export_movimento(TMovimentoPN_VE & mov, TViswin & v) {};
virtual bool exporting() { return false; }
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
{
bool _preserve_original_rif;
public:
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo = false);
void preserve_original_rif(bool on = true) { _preserve_original_rif = on;}
TCopia_documento(const char* cod);
TCopia_documento(const TRectype& rec) : TElaborazione(rec), _preserve_original_rif(false) { }
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
real _impmin;
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& doc, bool interattivo);
// Istanzia il pagamento corrente
void calc_pagamento(TDocumento&);
// Scrive i record array degli effetti raggruppati
error_type write_groups(bool interattivo);
// 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& group_array, bool interattivo);
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 TCache_causali; // Internal use only
class TContabilizzazione_analitica : public TElaborazione // velib04f
{
TCache_ripartizioni _rip;
TToken_string _search_seq;
TBill _sco_perc_bill_an, _sco_imp_bill_an, _spin_billa, _spin_billv, _spbo_billa, _spbo_billv;
TString _spin_cod, _spbo_cod;
TCache_causali* _caus;
TString16 _fld_cms_cont;
long _total_docs;// Numero di documenti contabilizzati
error_type _error; // Errore rilevato durante l'elaborazione
bool _usepdcc;
protected:
bool find_conti_iva_indetraibile(const TRiga_documento& riga, const TBill & bill, TString_array& conti, int annoes, const char tipomov, bool & pareggio);
bool spalma_spese() const { return get("I2") == "X"; }
void split_sp_amount(TAnal_mov & mov, bool pareggio, const TImporto & totdoc, const TBit_array & spese, const real & amount, const real & no_ca_amount, int decimals);
bool find_conti(const TRiga_documento& riga, TString_array& conti, int annoes, bool riclassifica_fdr_fde, const char tipomov, real & amount_to_split, real & no_ca_amount, const real & valore, bool & pareggio);
void init();
virtual const TCausale& doc2caus(const TDocumento& doc);
const TCausale& rdoc2caus(const TRiga_documento& rdoc);
void init_distrib(TString_array& conti, TGeneric_distrib& distrib, bool pareggio);
void calcola_date_comp(const TDocumento& doc, TDate& datacomp, TDate& datafcomp, int annoes);
public:
bool search_costo_ricavo(const TRiga_documento& riga, TBill& conto, bool riclassifica_fdr_fde);
const long processed_docs() const { return _total_docs; }
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo = false);
virtual bool elabora(TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write, TAnal_mov& mov,
bool riclassifica_fdr_fde = true);
TContabilizzazione_analitica(const char* cod = NULL);
TContabilizzazione_analitica(const TRectype& rec);
TContabilizzazione_analitica(const TContabilizzazione & el);
virtual ~TContabilizzazione_analitica();
};
#endif
Reference in New Issue View Git Blame Copy Permalink