root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 2.2

Browse Source 
Files correlati     : ve0 ve6
Ricompilazione Demo : [ ]
Commento            :

Tolte commesse dalla elaborazione di contabilizzazione ed aggiunta
contabilizzazione analitica


git-svn-id: svn://10.65.10.50/trunk@13059 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2005-05-06 10:58:49 +00:00
parent 4c6b507b64
commit 1ba069822a
14 changed files with 442 additions and 890 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ve/ve1200.cpp
View File

@ -5,7 +5,7 @@
#include <recarray.h>
#include <tabutil.h>
#include "velib.h"
#include "velib04.h"
#include "ve1200a.h"
#include <doc.h>

2
ve/ve6100.cpp
View File

@ -34,7 +34,7 @@
#include <tabutil.h>
#include <urldefid.h>
#include "velib.h"
#include "velib04.h"
#include "../cg/cgsaldac.h"
#include "ve6100a.h"

233
ve/ve6200.cpp
View File

@ -2,11 +2,81 @@
#include <mask.h>
#include <progind.h>
#include "velib.h"
#include "velib04.h"
#include "ve6200a.h"
#include <doc.h>
///////////////////////////////////////////////////////////
// Lista Cliente/Fornitore per vendite
///////////////////////////////////////////////////////////
class TLista_clifo : public TObject
{
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'; }
};
class TLista_cf : public TLista_clifo
{
char _tipo;
@ -18,6 +88,167 @@ public:
TLista_cf(char tipo) { _tipo = tipo;}
};
void TLista_clifo::TClifo::init(const TRectype& rec, const TRectype& ven)
{
_codice = rec.get_long(CLI_CODCF);
CHECK(_codice > 0, "Codice cliente nullo");
if (!ven.empty())
{
_agente = ven.get_long(CLI_CODAG);
_zona = ven.get_long(CLI_CODZONA);
}
else
_agente = _zona = 0;
}
bool TLista_clifo::TClifo::read(char tipo, long cod)
{
TRelation clifo(LF_CLIFO);
clifo.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
TRectype& curr = clifo.curr();
curr.put(CLI_TIPOCF, tipo);
curr.put(CLI_CODCF, cod);
if (clifo.read() == NOERR)
init(curr, clifo.curr(LF_CFVEN));
else
zero();
return ok();
}
TLista_clifo::TClifo::TClifo(const TRectype& rec)
{
CHECK(rec.num() == LF_CLIFO, "Record non clienti");
const char tipo = rec.get_char(CLI_TIPOCF);
const long codice = rec.get_long(CLI_CODCF);
read(tipo, codice);
}
int TLista_clifo::leggi(long dc, long ac, long da, long aa, const char * dz, const char * az)
{
TRelation clifo(LF_CLIFO);
clifo.add(LF_CFVEN, "TIPOCF==TIPOCF|CODCF==CODCF");
TRectype start(LF_CLIFO), stop(LF_CLIFO);
start.put(CLI_TIPOCF, tipo());
if (dc > 0)
start.put(CLI_CODCF, dc);
stop.put(CLI_TIPOCF, tipo());
if (ac > 0)
stop.put(CLI_CODCF, ac);
TString filter(32);
if (da > 0)
filter << '(' << LF_CFVEN << "->" << CLI_CODAG << ">=" << da << ')';
if (aa > 0)
{
if (filter.not_empty()) filter << "&&";
filter << '(' << LF_CFVEN << "->" << CLI_CODAG << "<=" << aa << ')';
}
if (dz && (*dz !='\0'))
{
if (filter.not_empty()) filter << "&&";
filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << ">=\"" << dz << "\")";
}
if (az && (*az !='\0'))
{
if (filter.not_empty()) filter << "&&";
filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << "<=\"" << az << "\")";
}
TCursor cur(&clifo, "", 1, &start, &stop);
if (filter.not_empty())
cur.setfilter(filter, TRUE);
const TRectype& cli = cur.curr();
const TRectype& ven = cur.curr(LF_CFVEN);
for (cur = 0; cur.ok(); ++cur)
{
TClifo* c = new TClifo(cli, ven);
_clifo.add(c);
}
if (dc > 0 || ac > 0)
ordina_per_codice();
else
if (da > 0 || aa > 0)
ordina_per_agente();
else
if ((dz && (*dz !='\0')) || (az && (*dz !='\0')))
ordina_per_zona();
return _clifo.items();
}
int TLista_clifo::sort_by_code(const TObject** o1, const TObject** o2)
{
TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
const long d = c1->codice() - c2->codice();
return d == 0L ? 0 : (d > 0 ? +1 : -1);
}
int TLista_clifo::sort_by_agent(const TObject** o1, const TObject** o2)
{
TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
const long d = c1->agente() - c2->agente();
return d == 0L ? 0 : (d > 0 ? +1 : -1);
}
int TLista_clifo::sort_by_zone(const TObject** o1, const TObject** o2)
{
TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
const long d = c1->zona() - c2->zona();
return d == 0L ? 0 : (d > 0 ? +1 : -1);
}
int TLista_clifo::ordina_per_codice()
{
_clifo.sort(sort_by_code);
return _clifo.items();
}
int TLista_clifo::ordina_per_agente()
{
_clifo.sort(sort_by_agent);
return _clifo.items();
}
int TLista_clifo::ordina_per_zona()
{
_clifo.sort(sort_by_zone);
return _clifo.items();
}
int TLista_clifo::find(long cod) const
{
int i;
for (i = items()-1; i >= 0; i--)
if (clifo(i).codice() == cod) break;
return i;
}
int TLista_clifo::add(long cod)
{
int pos = find(cod);
if (pos < 0)
{
TClifo* c = new TClifo(tipo(), cod);
pos = _clifo.add(c);
}
return pos;
}
///////////////////////////////////////////////////////////
// TFatturazione_bolle_app
///////////////////////////////////////////////////////////
class TFatturazione_bolle_app : public TSkeleton_application
{
TString4 _default_selection;

2
ve/ve6300.cpp
View File

@ -28,7 +28,7 @@
#include <tabutil.h>
#include <urldefid.h>
#include "velib.h"
#include "velib04.h"
#include "ve6300a.h"
#include <doc.h>

2
ve/ve7100.cpp
View File

@ -9,7 +9,7 @@
#include <rmov.h>
#include <rmoviva.h>
#include "velib.h"
#include "velib04.h"
#include "../cg/cgsaldac.h"
#include "ve7100a.h"

523
ve/velib.h
View File

@ -854,529 +854,6 @@ public:
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, _consuntivazione_produzione };
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, 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);
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&);
// 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 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,

162
ve/velib04.cpp
View File

@ -2,6 +2,7 @@
#include <tabutil.h>
#include "velib.h"
#include "velib04.h"
#include <clifo.h>
@ -152,167 +153,6 @@ int TLista_documenti::write(bool re) const
return err;
}
///////////////////////////////////////////////////////////
// Cliente/Fornitore per vendite
///////////////////////////////////////////////////////////
void TLista_clifo::TClifo::init(const TRectype& rec, const TRectype& ven)
{
_codice = rec.get_long(CLI_CODCF);
CHECK(_codice > 0, "Codice cliente nullo");
if (!ven.empty())
{
_agente = ven.get_long(CLI_CODAG);
_zona = ven.get_long(CLI_CODZONA);
}
else
_agente = _zona = 0;
}
bool TLista_clifo::TClifo::read(char tipo, long cod)
{
TRelation clifo(LF_CLIFO);
clifo.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
TRectype& curr = clifo.curr();
curr.put(CLI_TIPOCF, tipo);
curr.put(CLI_CODCF, cod);
if (clifo.read() == NOERR)
init(curr, clifo.curr(LF_CFVEN));
else
zero();
return ok();
}
TLista_clifo::TClifo::TClifo(const TRectype& rec)
{
CHECK(rec.num() == LF_CLIFO, "Record non clienti");
const char tipo = rec.get_char(CLI_TIPOCF);
const long codice = rec.get_long(CLI_CODCF);
read(tipo, codice);
}
int TLista_clifo::leggi(long dc, long ac, long da, long aa, const char * dz, const char * az)
{
TRelation clifo(LF_CLIFO);
clifo.add(LF_CFVEN, "TIPOCF==TIPOCF|CODCF==CODCF");
TRectype start(LF_CLIFO), stop(LF_CLIFO);
start.put(CLI_TIPOCF, tipo());
if (dc > 0)
start.put(CLI_CODCF, dc);
stop.put(CLI_TIPOCF, tipo());
if (ac > 0)
stop.put(CLI_CODCF, ac);
TString filter(32);
if (da > 0)
filter << '(' << LF_CFVEN << "->" << CLI_CODAG << ">=" << da << ')';
if (aa > 0)
{
if (filter.not_empty()) filter << "&&";
filter << '(' << LF_CFVEN << "->" << CLI_CODAG << "<=" << aa << ')';
}
if (dz && (*dz !='\0'))
{
if (filter.not_empty()) filter << "&&";
filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << ">=\"" << dz << "\")";
}
if (az && (*az !='\0'))
{
if (filter.not_empty()) filter << "&&";
filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << "<=\"" << az << "\")";
}
TCursor cur(&clifo, "", 1, &start, &stop);
if (filter.not_empty())
cur.setfilter(filter, TRUE);
const TRectype& cli = cur.curr();
const TRectype& ven = cur.curr(LF_CFVEN);
for (cur = 0; cur.ok(); ++cur)
{
TClifo* c = new TClifo(cli, ven);
_clifo.add(c);
}
if (dc > 0 || ac > 0)
ordina_per_codice();
else
if (da > 0 || aa > 0)
ordina_per_agente();
else
if ((dz && (*dz !='\0')) || (az && (*dz !='\0')))
ordina_per_zona();
return _clifo.items();
}
int TLista_clifo::sort_by_code(const TObject** o1, const TObject** o2)
{
TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
const long d = c1->codice() - c2->codice();
return d == 0L ? 0 : (d > 0 ? +1 : -1);
}
int TLista_clifo::sort_by_agent(const TObject** o1, const TObject** o2)
{
TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
const long d = c1->agente() - c2->agente();
return d == 0L ? 0 : (d > 0 ? +1 : -1);
}
int TLista_clifo::sort_by_zone(const TObject** o1, const TObject** o2)
{
TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
const long d = c1->zona() - c2->zona();
return d == 0L ? 0 : (d > 0 ? +1 : -1);
}
int TLista_clifo::ordina_per_codice()
{
_clifo.sort(sort_by_code);
return _clifo.items();
}
int TLista_clifo::ordina_per_agente()
{
_clifo.sort(sort_by_agent);
return _clifo.items();
}
int TLista_clifo::ordina_per_zona()
{
_clifo.sort(sort_by_zone);
return _clifo.items();
}
int TLista_clifo::find(long cod) const
{
int i;
for (i = items()-1; i >= 0; i--)
if (clifo(i).codice() == cod) break;
return i;
}
int TLista_clifo::add(long cod)
{
int pos = find(cod);
if (pos < 0)
{
TClifo* c = new TClifo(tipo(), cod);
pos = _clifo.add(c);
}
return pos;
}
///////////////////////////////////////////////////////////
// TParametri_elaborazione
///////////////////////////////////////////////////////////

2
ve/velib04a.cpp
View File

@ -1,4 +1,4 @@
#include "velib.h"
#include "velib04.h"
///////////////////////////////////////////////////////////
// TFatturazione bolle

353
ve/velib04b.cpp
View File

@ -1,12 +1,19 @@
#include <applicat.h>
#include <diction.h>
#include <dongle.h>
#include <execp.h>
#include <mailbox.h>
#include <modaut.h>
#include <tabutil.h>
#include <progind.h>
#include <printer.h>
#include <viswin.h>
#include <utility.h>
#include "velib04.h"
#include "../ca/calib01.h"
#include "../cg/cg2103.h"
#include "../cg/cglib02.h"
#include "../cg/cgsaldac.h"
#include "../in/inlib01.h"
#include "../mg/anamag.h"
#include <mov.h>
#include <rmov.h>
@ -16,33 +23,23 @@
#include <comuni.h>
#include <nditte.h>
#include <occas.h>
#include <scadenze.h>
#include <unloc.h>
#include <doc.h>
#include <rdoc.h>
#include "../mg/anamag.h"
#include "velib.h"
#include "../cg/cg2103.h"
#include "../cg/cgsaldac.h"
#include "../cg/cglib02.h"
#include "../in/inlib01.h"
void TMovimentoPN_VE::destroy_iva_row(int i)
{
if (i < 0)
((TRecord_array&)iva_rows()).destroy_rows();
iva_rows().destroy_rows();
else
((TRecord_array&)iva_rows()).destroy_row(i+1, TRUE);
iva_rows().destroy_row(i+1, true);
}
TImporto TMovimentoPN_VE::real2imp(const real& r, char row_type)
{
CHECK(_caus,"Orgggssbb..._caus pointer is NULL!");
bool dare = FALSE;
bool dare = false;
if (row_type == 'S')
{
dare = _caus->sezione_ritsoc() == 'D';
@ -68,41 +65,31 @@ bool TMovimentoPN_VE::detraibile(TRectype& rec) const
{
CHECK(_caus,"Orgggssbb..._caus pointer is NULL!");
if (_caus->iva() == iva_vendite)
return TRUE;
return true;
if (rec.get_int(RMI_TIPODET) != 0)
return FALSE;
return false;
const int annodoc = curr().get_date(MOV_DATADOC).year();
const bool prorata100 = _caus->reg().prorata100(annodoc);
return !prorata100; // Se prorata = 100% e' indetraibile
}
int TMovimentoPN_VE::bill2pos(const TBill& conto, const TString & codcms, const TString & fascms, char tipo)
int TMovimentoPN_VE::bill2pos(const TBill& conto, char tipo)
{
const int items = cg_items();
const bool has_cm = main_app().has_module(CMAUT, CHK_DONGLE);
for (int i = 0; i < items; i++)
{
TRectype& s = cg(i);
const char t = s.get_char(RMV_ROWTYPE);
if (t == tipo)
{
TBill c;
const int gr = s.get_int(RMV_GRUPPO);
const int co = s.get_int(RMV_CONTO);
const long so = s.get_long(RMV_SOTTOCONTO);
c.set(gr,co,so);
if (has_cm)
{
if (c == conto && (codcms == s.get(RMV_CODCMS)) && (fascms == s.get(RMV_FASCMS)))
return i;
}
else
if (c == conto)
return i;
const long so = s.get_long(RMV_SOTTOCONTO);
const TBill c(gr,co,so);
if (c == conto)
return i;
}
}
return -1;
@ -130,11 +117,10 @@ void TMovimentoPN_VE::set_cg_imp(int n, const TImporto& imp)
TImporto TMovimentoPN_VE::get_cg_imp(int n)
{
TRectype& rec = cg(n);
TImporto importo;
const TRectype& rec = cg(n);
const char sez = rec.get_char(RMV_SEZIONE);
const real valore(rec.get_real(RMV_IMPORTO));
importo.set(sez,valore);
TImporto importo(sez,valore);
return importo;
}
@ -147,8 +133,7 @@ bool TMovimentoPN_VE::add_cg_rec(int n, const TImporto& imp)
return tot.is_zero();
}
int TMovimentoPN_VE::set_cg_rec(int n, const TImporto& imp, TBill& conto, const char * codcms, const char * fascms,
const char* desc, char tipo)
int TMovimentoPN_VE::set_cg_rec(int n, const TImporto& imp, const TBill& conto, const char* desc, char tipo)
{
const bool insert = n < 0;
if (insert) n = cg_items(); // Questa e' la prima riga di contabilita' vuota e disponibile
@ -170,16 +155,6 @@ int TMovimentoPN_VE::set_cg_rec(int n, const TImporto& imp, TBill& conto, const
rec.put(RMV_GRUPPO,conto.gruppo());
rec.put(RMV_CONTO,conto.conto());
rec.put(RMV_SOTTOCONTO,conto.sottoconto());
if (main_app().has_module(CMAUT, CHK_DONGLE))
{
TString cms = codcms;
TString fsc = fascms;
if (cms.blank() && fsc.blank()) // Se la commessa e' vuota ...
conto.default_cdc(cms, fsc); // ... ne cerco una standard
rec.put(RMV_CODCMS, cms);
rec.put(RMV_FASCMS, fsc);
}
rec.put(RMV_DESCR, desc);
if (tipo != ' ')
@ -226,7 +201,7 @@ int TMovimentoPN_VE::set_cg_rec(int n, const TImporto& imp, TBill& conto, const
return n;
}
int TMovimentoPN_VE::insert_cg_rec(int n, const TImporto& imp, TBill& conto, const char * codcms, const char * fascms,
int TMovimentoPN_VE::insert_cg_rec(int n, const TImporto& imp, TBill& conto,
const char* desc, char tipo)
{
if (n >= 0 && n < cg_items())
@ -241,9 +216,9 @@ int TMovimentoPN_VE::insert_cg_rec(int n, const TImporto& imp, TBill& conto, con
row->put(RMV_NUMRIG, n + 1);
row->put(RMV_ANNOES,annoes);
row->put(RMV_DATAREG,datareg);
((TRecord_array &) cg_rows()).insert_row(row);
cg_rows().insert_row(row);
}
return set_cg_rec(n, imp, conto, codcms, fascms, desc, tipo);
return set_cg_rec(n, imp, conto, desc, tipo);
}
void TMovimentoPN_VE::create_row(int i, const TString & descr_cr)
@ -269,7 +244,7 @@ void TMovimentoPN_VE::create_row(int i, const TString & descr_cr)
if (c.ok())
{
const TString80 d(_caus->desc_agg(ri));
set_cg_rec(-1, real2imp(ZERO, 'I'), c, "", "", d, tipod);
set_cg_rec(-1, real2imp(ZERO, 'I'), c, d, tipod);
}
else
if (ri == RIGA_IVA_NON_DETRAIBILE) // Se non esiste il conto IVA indetraibile ...
@ -279,20 +254,17 @@ void TMovimentoPN_VE::create_row(int i, const TString & descr_cr)
}
}
TBill oldconto;
const int gr = cur.get_int(RMI_GRUPPO);
const int co = cur.get_int(RMI_CONTO);
const long so = cur.get_long(RMI_SOTTOCONTO);
const TString80 codcms = cur.get(RMI_CODCMS);
const TString80 fascms = cur.get(RMI_FASCMS);
oldconto.set(gr,co,so);
const TBill oldconto(gr,co,so);
if (oldconto.ok())
{
if (bill2pos(oldconto, codcms, fascms, 'I') < 0)
if (bill2pos(oldconto, 'I') < 0)
{
const TString d(_caus->desc_agg(2));
set_cg_rec(-1, real2imp(ZERO, 'I'), oldconto, codcms, fascms, d.empty() ? descr_cr: d, 'I');
set_cg_rec(-1, real2imp(ZERO, 'I'), oldconto, d.empty() ? descr_cr: d, 'I');
}
}
}
@ -311,16 +283,8 @@ void TMovimentoPN_VE::enter_row(int i, const TString & descr_cr)
imposta = i.scorpora(imponibile); // ... scorpora imposta dall'imponibile
}
TBill conto;
const char t = cur.get_char(RMI_TIPOC);
const int gr = cur.get_int(RMI_GRUPPO);
const int co = cur.get_int(RMI_CONTO);
const long so = cur.get_long(RMI_SOTTOCONTO);
const TString80 codcms = cur.get(RMI_CODCMS);
const TString80 fascms = cur.get(RMI_FASCMS);
conto.set(gr,co,so,t);
int newpos = bill2pos(conto, codcms, fascms, 'I'); // Riga in cui andra' l'imponibile
const TBill conto(cur);
int newpos = bill2pos(conto, 'I'); // Riga in cui andra' l'imponibile
const bool detrarre = detraibile(cur); // Determina se IVA detraibile
@ -341,7 +305,7 @@ void TMovimentoPN_VE::enter_row(int i, const TString & descr_cr)
if (conto.ok() && !val.is_zero()) // Se c'e' imponibile ...
{ // crea una nuova riga contabile
const TString d(_caus->desc_agg(2));
set_cg_rec(-1, val, conto, codcms, fascms, d.empty() ? descr_cr : d, 'I');
set_cg_rec(-1, val, conto, d.empty() ? descr_cr : d, 'I');
}
}
else
@ -362,7 +326,7 @@ void TMovimentoPN_VE::enter_row(int i, const TString & descr_cr)
{ // ... crea nuova riga per l'IVA
const TImporto val(real2imp(imposta, 'I'));
const TString d(_caus->desc_agg(ri));
newposiva = set_cg_rec(-1, val, contoiva, "", "", d, tipod);
newposiva = set_cg_rec(-1, val, contoiva, d, tipod);
}
}
else
@ -377,9 +341,7 @@ void TMovimentoPN_VE::add_row_re(int i)
TRectype& cur = iva(i);
real oldimp = cur.get_real(RMI_IMPONIBILE);
real oldiva = cur.get_real(RMI_IMPOSTA);
const TString80 codcms = cur.get(RMI_CODCMS);
const TString80 fascms = cur.get(RMI_FASCMS);
const char tipod = detraibile(cur) ? 'D' : 'N';
TBill c;
@ -388,9 +350,9 @@ void TMovimentoPN_VE::add_row_re(int i)
_caus->bill(RIGA_IVA_NON_DETRAIBILE, c);
if (c.ok())
{
int ivapos = bill2pos(c, codcms, fascms, 'I');
int ivapos = bill2pos(c, 'I');
if (ivapos < 0)
ivapos= set_cg_rec(-1, real2imp(ZERO, 'I'), c, codcms, fascms, "", 'I');
ivapos= set_cg_rec(-1, real2imp(ZERO, 'I'), c, "", 'I');
const TImporto val(real2imp(oldiva, 'I'));
@ -406,10 +368,10 @@ void TMovimentoPN_VE::add_row_re(int i)
c.set(gr,co,so);
if (c.ok())
{
int poscg = bill2pos(c, codcms, fascms, ' ');
int poscg = bill2pos(c, ' ');
if (poscg < 0)
poscg = set_cg_rec(-1, real2imp(ZERO, 'I'), c, codcms, fascms, _caus->desc_agg(2), ' ');
poscg = set_cg_rec(-1, real2imp(ZERO, 'I'), c, _caus->desc_agg(2), ' ');
TImporto val(real2imp(oldimp, 'I'));
@ -420,24 +382,18 @@ void TMovimentoPN_VE::add_row_re(int i)
bool TMovimentoPN_VE::add_row_cp_re(int i)
{
TRectype& cur = cg(i);
bool inserted_row = FALSE;
bool inserted_row = false;
TBill c;
const int gr = cur.get_int(RMV_GRUPPO);
const int co = cur.get_int(RMV_CONTO);
const long so = cur.get_long(RMV_SOTTOCONTO);
c.set(gr,co,so);
TBill cp;
TBill c(cur);
map_conto_re(c);
if (c.ok())
{
int poscg = bill2pos(c, "", "", ' ');
int poscg = bill2pos(c, ' ');
if (poscg < 0)
{
poscg = insert_cg_rec(0, real2imp(ZERO, 'P'), c, "", "", _caus->desc_agg(1), ' ');
inserted_row = TRUE;
poscg = insert_cg_rec(0, real2imp(ZERO, 'P'), c, _caus->desc_agg(1), ' ');
inserted_row = true;
}
TImporto val(real2imp(cur.get_real(RMV_IMPORTO), 'P'));
@ -517,8 +473,8 @@ bool TMovimentoPN_VE::movement_ok()
}
if (!tot_imp.is_zero())
return FALSE;
return TRUE;
return false;
return true;
}
int TMovimentoPN_VE::recalc_cg_rows(const TString & descr_cr, TCausale & caus)
@ -532,7 +488,7 @@ int TMovimentoPN_VE::recalc_cg_rows(const TString & descr_cr, TCausale & caus)
create_row(i, descr_cr);
enter_row(i, descr_cr);
}
bool ok = TRUE;
bool ok = true;
if (_caus->intra() && _caus->iva() == iva_acquisti)
{
TBill c; _caus->bill(RIGA_RITENUTE_FISCALI, c);
@ -541,7 +497,7 @@ int TMovimentoPN_VE::recalc_cg_rows(const TString & descr_cr, TCausale & caus)
{
const TString80 d(_caus->desc_agg(RIGA_RITENUTE_FISCALI));
const char rowtype = 'F';
set_cg_rec(-1, real2imp(head.get_real(MOV_RITFIS), rowtype), c, "","", d, rowtype);
set_cg_rec(-1, real2imp(head.get_real(MOV_RITFIS), rowtype), c, d, rowtype);
}
else
return 2;
@ -558,7 +514,7 @@ int TMovimentoPN_VE::recalc_cg_rows(const TString & descr_cr, TCausale & caus)
{
const TString80 d(_caus->desc_agg(RIGA_RITENUTE_FISCALI));
const char rowtype = 'F';
set_cg_rec(-1, real2imp(ritfis, rowtype), c, "", "", d, rowtype);
set_cg_rec(-1, real2imp(ritfis, rowtype), c, d, rowtype);
}
else
return 1;
@ -574,7 +530,7 @@ int TMovimentoPN_VE::recalc_cg_rows(const TString & descr_cr, TCausale & caus)
{
const TString80 d(_caus->desc_agg(RIGA_RITENUTE_SOCIALI));
const char rowtype = 'S';
set_cg_rec(-1, real2imp(ritsoc, rowtype), c, "", "", d, rowtype);
set_cg_rec(-1, real2imp(ritsoc, rowtype), c, d, rowtype);
}
else
return 1;
@ -601,9 +557,9 @@ static TBill _sco_perc_bill, _sco_imp_bill, // Conti per gli sconti a percentua
static TBill _co_cliente, // conto clifo per movimento d'anticipo
_co_controp; // conto di contropartita per il movimetno d'anticipo
static bool _nump_cfg; // se TRUE prende il numero rif. partita dal numero protocollo
static bool _sc_enabled; // se TRUE il saldaconto di ditta e' abilitato
static bool _in_enabled; // se TRUE l'intra e' abilitato
static bool _nump_cfg; // se true prende il numero rif. partita dal numero protocollo
static bool _sc_enabled; // se true il saldaconto di ditta e' abilitato
static bool _in_enabled; // se true l'intra e' abilitato
static TToken_string* _search_seq = NULL;
// Sequenza di ricerca del conto costo/ricavo la correttezza dell'ordinamento
// va controllata nel programma di modifica parametri:
@ -621,7 +577,7 @@ static TToken_string* _search_seq = NULL;
// di ricerca.
static TString16 _ivasto; // Codice IVA per storno articoli Omaggio
static bool _contsclor; // Contabilizza sconti al netto o al lordo (sconti suddiviso per ogni contropartita)
//static bool _loaded = FALSE;// Flag per evitare di caricare i parametri più di una volta
//static bool _loaded = false;// Flag per evitare di caricare i parametri più di una volta
static TEsercizi_contabili _esc; // Per sapere a quale esercizio appartiene il documento
static TCausale *_caus = NULL; // causale del documento corrente
@ -678,13 +634,7 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
const TCodiceIVA& tiva = r.iva();
TString16 cod(tiva.codice());
TBill c(conto);
char tipo = c.tipo();
int gr = c.gruppo();
int co = c.conto();
long so = c.sottoconto();
int ord = 0;
TString80 codcms;
TString16 fascms;
int detr = 0;
real pind = ZERO;
real impon;
@ -699,7 +649,7 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
const TCodice_numerazione & num = TDocumento::codice_numerazione(key);
if (num.fattura_emettere_ricevere())
{
key.format("%3d%3d%6ld", gr, co, so);
key.format("%3d%3d%6ld", c.gruppo(), c.conto(), c.sottoconto());
TRectype & rs = (TRectype &) cache().get("MRE", key);
if (rs.empty())
{
@ -724,16 +674,13 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
TCausale caus(codcau);
caus.bill(1, c);
gr = c.gruppo();
co = c.conto();
so = c.sottoconto();
}
else
{
gr = rs.get_int("I0");
co = rs.get_int("I1");
so = rs.get_int("I2");
tipo = rs.get_char("S6");
const int gr = rs.get_int("I0");
const int co = rs.get_int("I1");
const long so = rs.get_int("I2");
const char tipo = rs.get_char("S6");
c.set(gr, co, so, tipo);
}
if (c.tipo() > ' ')
@ -743,7 +690,7 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
if (!sconto_lordo) // Al netto dello sconto
impon = r.imponibile();
else
impon = r.importo(FALSE,FALSE,ndec); // Imponibile della riga al lordo dello sconto
impon = r.importo(false,false,ndec); // Imponibile della riga al lordo dello sconto
switch (t.tipo())
{
@ -777,26 +724,10 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
real imposta = tiva.imposta(impon, ndec);
if (main_app().has_module(CMAUT, CHK_DONGLE))
{
codcms = r.codice_commessa();
fascms = r.fase_commessa();
}
if (_caus->iva() == iva_acquisti || _caus->iva() == nessuna_iva)
{
detr = t.detraibilita();
pind = t.perc_indetraibilita();
if (codcms.not_empty())
{
const TRectype & rec = cache().get("CMS", codcms);
if (rec.get("S7") == "NR")
{
detr = 9;
pind = CENTO;
}
}
}
real impres = (impon * pind) / CENTO;
@ -814,7 +745,8 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
if (pind < CENTO)
{
key.format("%d|%-4s|%c|%3d|%3d|%6ld|%s|%s|%d",ord,(const char*)cod,tipo,gr,co,so, (const char *)codcms, (const char *)fascms, 0);
key.format("%d|%-4s|%c|%3d|%3d|%6ld|%d",
ord,(const char*)cod,c.tipo(),c.gruppo(),c.conto(),c.sottoconto(), 0);
TRectype * iva = (TRectype *) objptr(key);
if (iva == NULL)
@ -827,9 +759,7 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
iva->put(RMI_GRUPPO, c.gruppo());
iva->put(RMI_CONTO, c.conto());
iva->put(RMI_SOTTOCONTO, c.sottoconto());
iva->put(RMI_CODCMS, codcms);
iva->put(RMI_FASCMS, fascms);
TAssoc_array::add(key, iva, TRUE);
TAssoc_array::add(key, iva, true);
}
real val = iva->get_real(RMI_IMPONIBILE);
@ -842,7 +772,8 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
}
if (pind > ZERO)
{
key.format("%d|%-4s|%c|%3d|%3d|%6ld|%s|%s|%d",ord,(const char*)cod,tipo,gr,co,so, (const char *)codcms, (const char *)fascms, detr);
key.format("%d|%-4s|%c|%3d|%3d|%6ld|%d",ord,
(const char*)cod,c.tipo(),c.gruppo(),c.conto(),c.sottoconto(), detr);
TRectype * iva = (TRectype *) objptr(key);
if (iva == NULL)
@ -855,10 +786,8 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
iva->put(RMI_GRUPPO, c.gruppo());
iva->put(RMI_CONTO, c.conto());
iva->put(RMI_SOTTOCONTO, c.sottoconto());
iva->put(RMI_CODCMS, codcms);
iva->put(RMI_FASCMS, fascms);
iva->put(RMI_TIPODET, detr);
TAssoc_array::add(key, iva, TRUE);
TAssoc_array::add(key, iva, true);
}
real val = iva->get_real(RMI_IMPONIBILE);
@ -890,7 +819,7 @@ error_type TIVA_array::add(const TRiga_documento & r, const TBill& conto, const
TContabilizzazione::TContabilizzazione(const char* cod)
: TElaborazione(cod), _auto_data(FALSE)
: TElaborazione(cod), _auto_data(false)
{
_fcaus = new TLocalisamfile(LF_CAUSALI);
_frcaus = new TLocalisamfile(LF_RCAUSALI);// Per far andare TCausale
@ -921,14 +850,14 @@ TContabilizzazione::TContabilizzazione(const char* cod)
_righe_iva = new TIVA_array;
_nump_iva = get_bool("B4");
_can_write = TRUE;
_can_write = true;
_error = no_error;
_total_docs = 0L;
_caus = NULL;
}
TContabilizzazione::TContabilizzazione(const TRectype& rec)
: TElaborazione(rec), _auto_data(FALSE), _viswin(NULL)
: TElaborazione(rec), _auto_data(false), _viswin(NULL)
{
_fcaus = new TLocalisamfile(LF_CAUSALI);
_frcaus = new TLocalisamfile(LF_RCAUSALI);// Per far andare TCausale
@ -960,7 +889,7 @@ TContabilizzazione::TContabilizzazione(const TRectype& rec)
_nump_iva = get_bool("B4");
_can_write = TRUE;
_can_write = true;
_error = no_error;
_total_docs = 0L;
_caus = NULL;
@ -998,7 +927,7 @@ TContabilizzazione::~TContabilizzazione()
bool TContabilizzazione::load_parameters()
{
// if (_loaded)
// return TRUE;
// return true;
TConfig conf(CONFIG_DITTA, "ve");
@ -1012,10 +941,10 @@ bool TContabilizzazione::load_parameters()
if (_search_seq->items() == 0)
{
error_box("Non e' abilitata alcuna ricerca per il conto di costo/ricavo in configurazione.");
return FALSE;
return false;
}
_sc_enabled = conf.get_bool("GesSal","cg");
_in_enabled = main_app().has_module(INAUT, CHK_DONGLE);
_in_enabled = dongle().active(INAUT);
_nump_cfg = conf.get_bool("RifPro","cg");
int gr,co;
@ -1060,7 +989,7 @@ bool TContabilizzazione::load_parameters()
_check_prev_cont = conf.get_bool("CHECKPREVCONT","ve");
return TRUE;
return true;
}
bool TContabilizzazione::test_swap()
@ -1142,7 +1071,7 @@ error_type TContabilizzazione::compile_head_mov(TDocumento& doc)
}
// reperisce l'ultimo numero di registrazione disponibile
long numreg = doc_contabilized(doc, FALSE);
long numreg = doc_contabilized(doc, false);
const bool recontabilizing = numreg > 0;
if (recontabilizing)
{
@ -1526,7 +1455,7 @@ error_type TContabilizzazione::compile_head_mov_re(TDocumento& doc)
}
// reperisce l'ultimo numero di registrazione disponibile
long numreg = doc_contabilized(doc, FALSE);
long numreg = doc_contabilized(doc, false);
const bool recontabilizing = numreg > 0;
if (recontabilizing)
{
@ -1676,7 +1605,7 @@ error_type TContabilizzazione::search_costo_ricavo(TBill& conto, const TRiga_doc
const int items = _search_seq->items();
TLocalisamfile & cli_file = _clifo->lfile(); // YES, arriva qui dentro quando la relazione e' gia' posizionata
const bool is_cli = cli_file.get(CLI_TIPOCF) == "C";
bool skip_art_related = FALSE;
bool skip_art_related = false;
bool skip_clifo = _clifo->bad();
TCodiceIVA codiva(r.get(RDOC_CODIVA));
const char t = r.tipo().tipo();
@ -1691,7 +1620,7 @@ error_type TContabilizzazione::search_costo_ricavo(TBill& conto, const TRiga_doc
// posiziona l'anagrafica sull'articolo specificato sulla ..iga
_anamag->put(ANAMAG_CODART,r.get(RDOC_CODART));
if (_anamag->read() != NOERR) // se non trova l'articolo saltera' anche gmc,smc,rfa.
skip_art_related = TRUE;
skip_art_related = true;
TString16 tok;
// Scorre la stringa di ricerca
@ -1855,7 +1784,7 @@ void TContabilizzazione::calculate_spese(real& spese, real& sp_iva, int ndec, bo
r.put(RDOC_PREZZO, spese);
r.put(RDOC_CODIVA, codiva_es);
_righe_iva->add(r, zio, ndec);
sp_iva = r.imposta(FALSE);
sp_iva = r.imposta(false);
sp_iva.round(ndec);
if (doc.tipo().calcolo_lordo()) // Si ricorda che calcolo_lordo() e fattura_commerciale sono esclusivi.
{
@ -1886,13 +1815,13 @@ error_type TContabilizzazione::add_spese_inbo(TDocumento& doc, const int ndec)
doc.iva_esente(codiva_es);
if (sp_incasso != 0.0)
calculate_spese(sp_incasso,iva_sp_incasso,ndec,TRUE,is_cli, codiva_es.not_empty() ? codiva_es : doc.codiva_spese(), doc);
calculate_spese(sp_incasso,iva_sp_incasso,ndec,true,is_cli, codiva_es.not_empty() ? codiva_es : doc.codiva_spese(), doc);
// Aggiunge le spese bolli
tot_netto += sp_incasso + iva_sp_incasso - rit;
sp_bolli = doc.bolli(tot_netto, ndec, _netto);
if (sp_bolli != 0)
calculate_spese(sp_bolli, iva_sp_bolli, ndec, FALSE, is_cli, codiva_es.not_empty() ? codiva_es : doc.codiva_bolli(), doc);
calculate_spese(sp_bolli, iva_sp_bolli, ndec, false, is_cli, codiva_es.not_empty() ? codiva_es : doc.codiva_bolli(), doc);
return _error;
}
@ -2156,8 +2085,6 @@ error_type TContabilizzazione::create_iva_rows(TDocumento& doc)
rec_iva.put(RMI_GRUPPO, gruppo);
rec_iva.put(RMI_CONTO, conto);
rec_iva.put(RMI_SOTTOCONTO, sottoconto);
rec_iva.put(RMI_CODCMS, cur.get(RMI_CODCMS));
rec_iva.put(RMI_FASCMS, cur.get(RMI_FASCMS));
rec_iva.put(RMI_TIPODET, cur.get(RMI_TIPODET));
nr++;
}
@ -2210,7 +2137,7 @@ error_type TContabilizzazione::create_total_doc_row(TDocumento& doc)
rec_cg.put(RMV_DATAREG,datareg); rec_cg.put(RMV_TIPOC,tipocf);
rec_cg.put(RMV_GRUPPO,gruppo);rec_cg.put(RMV_CONTO,conto);
rec_cg.put(RMV_SOTTOCONTO,codcf); rec_cg.put(RMV_DESCR,descr);
contro.put(rec_cg, TRUE);
contro.put(rec_cg, true);
rec_cg.put(RMV_IMPORTO,totdoc); rec_cg.put(RMV_ROWTYPE,"T");
if (tipocf == " ")
{
@ -2337,7 +2264,7 @@ error_type TContabilizzazione::compile_rows_mov(TDocumento& doc)
if (!_totali_lordi.is_key(cod))
_totali_lordi.add(cod, new real);
real& rl = (real&) _totali_lordi[cod];
rl += r.imponibile(TRUE);
rl += r.imponibile(true);
}
}
}
@ -2547,7 +2474,7 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
{
TPagamento& pag = doc.pagamento();
const TCurrency_documento totspese(doc.spese(), doc);
TCurrency_documento totimposte(doc.imposta(TRUE), doc);
TCurrency_documento totimposte(doc.imposta(true), doc);
real imposte;
for (int j = _movimento->iva_items()-1; j >= 0; j--)
@ -2620,7 +2547,7 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
TCurrency_documento anticipo_base(anticipo); anticipo_base.change_to_firm_val();
// Crea una rimessa diretta con la data del documento per il valore dell'anticipo
pag.set_rata(0, in_valuta ? anticipo.get_num() : ZERO, anticipo_base.get_num(), first_date, 1, "", FALSE);
pag.set_rata(0, in_valuta ? anticipo.get_num() : ZERO, anticipo_base.get_num(), first_date, 1, "", false);
}
real imponibile, imponibile_val;
@ -2699,7 +2626,7 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
TCurrency_documento totdoc(abs(doc.totale_doc()), doc);
TCurrency_documento totspese(abs(doc.spese()), doc);
TCurrency_documento totimposte(abs(doc.imposta(TRUE)), doc);
TCurrency_documento totimposte(abs(doc.imposta(true)), doc);
TCurrency_documento totimponibili = totdoc - totspese - totimposte;
if (in_valuta)
{
@ -2717,10 +2644,10 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
for (int r = 1; r <= fatt.rate() && r <= pag.n_rate(); r++)
{
const TRiga_scadenze& rata = fatt.rata(r);
const real imprata = rata.residuo(FALSE).valore();
const real imprataval = rata.residuo(TRUE).valore();
real importo_rata_lit = pag.importo_rata(r-1, FALSE);
real importo_rata_val = in_valuta ? pag.importo_rata(r-1, TRUE) : importo_rata_lit;
const real imprata = rata.residuo(false).valore();
const real imprataval = rata.residuo(true).valore();
real importo_rata_lit = pag.importo_rata(r-1, false);
real importo_rata_val = in_valuta ? pag.importo_rata(r-1, true) : importo_rata_lit;
real delta_lit = importo_rata_lit - imprata;
real delta_val = in_valuta ? importo_rata_val - imprataval : ZERO;
// Controlla se l'importo della nota di credito supera quello della fattura
@ -2738,12 +2665,12 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
else
{
// Incrementa importo rata
delta_lit += pag.importo_rata(r, FALSE);
delta_val += pag.importo_rata(r, TRUE);
delta_lit += pag.importo_rata(r, false);
delta_val += pag.importo_rata(r, true);
}
const TDate oggi(TODAY);
const int tiporata = pag.tipo_rata(r-1);
pag.set_rata(r, delta_val, delta_lit, oggi, tiporata, "", FALSE);
pag.set_rata(r, delta_val, delta_lit, oggi, tiporata, "", false);
}
if (!importo_rata_lit.is_zero() || (in_valuta && !importo_rata_val.is_zero()))
{
@ -2759,7 +2686,7 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
residuolit -= TImporto(sezione, importo_rata_lit);
pag.put(PAGSCA_ACCSAL, "A");
newgame->modifica_pagamento(pag, cambio, TRUE);
newgame->modifica_pagamento(pag, cambio, true);
}
}
}
@ -2776,7 +2703,7 @@ error_type TContabilizzazione::write_scadenze(TDocumento& doc)
else
unpag.put(PAGSCA_IMPORTO, residuoval.valore());
unpag.put(PAGSCA_ACCSAL, "A");
newgame->modifica_pagamento(unpag, cambio, TRUE);
newgame->modifica_pagamento(unpag, cambio, true);
}
}
}
@ -2824,14 +2751,14 @@ error_type TContabilizzazione::write_all(TDocumento& doc, TMovimentoPN_VE & movi
TSaldo_agg saldo;
int err = NOERR;
const long old_numreg = doc_contabilized(doc, FALSE);
const long old_numreg = doc_contabilized(doc, false);
if (old_numreg > 0)
{
TMovimentoPN oldmov;
oldmov.curr().put(MOV_NUMREG, old_numreg);
if (oldmov.read() == NOERR)
aggiorna_saldi(saldo, oldmov, FALSE); // Leggo i vecchi saldi
aggiorna_saldi(saldo, oldmov, false); // Leggo i vecchi saldi
err = movimento.rewrite();
}
else
@ -2842,7 +2769,7 @@ error_type TContabilizzazione::write_all(TDocumento& doc, TMovimentoPN_VE & movi
return generic_error;
}
// Aggiorno subito i saldi
aggiorna_saldi(saldo, movimento, TRUE);
aggiorna_saldi(saldo, movimento, true);
if (sc_enabled())
write_scadenze(doc);
@ -2850,10 +2777,13 @@ error_type TContabilizzazione::write_all(TDocumento& doc, TMovimentoPN_VE & movi
if (good() && in_enabled())
write_intra(doc);
if (good() && (dongle().active(CMAUT) || dongle().active(CAAUT)))
write_anal(doc, movimento);
if (doc.get_real(DOC_IMPPAGATO) != ZERO)
if (write_anticipo(doc) != no_error)
movimento.remove(); // Se si è verificato un errore nella scrittura dell'anticipo rimuove il movimento di prima nota
if (good())
{
_total_docs++;
@ -2882,13 +2812,13 @@ error_type TContabilizzazione::write_all_re(TDocumento& doc, TMovimentoPN_VE & m
TSaldo_agg saldo;
int err = NOERR;
const long old_numreg = doc_contabilized(doc, FALSE);
const long old_numreg = doc_contabilized(doc, false);
if (old_numreg > 0)
{
TMovimentoPN oldmov;
oldmov.curr().put(MOV_NUMREG, old_numreg);
if (oldmov.read() == NOERR)
aggiorna_saldi(saldo, oldmov, FALSE); // Leggo i vecchi saldi
aggiorna_saldi(saldo, oldmov, false); // Leggo i vecchi saldi
err = movimento.rewrite();
}
else
@ -2899,7 +2829,7 @@ error_type TContabilizzazione::write_all_re(TDocumento& doc, TMovimentoPN_VE & m
return generic_error;
}
// Aggiorno subito i saldi
aggiorna_saldi(saldo, movimento, TRUE);
aggiorna_saldi(saldo, movimento, true);
if (good())
{
@ -2926,7 +2856,7 @@ error_type TContabilizzazione::compile_head_anticipo(TDocumento& doc)
if (!_caus->read(codcaus,datareg.year()))
return caus_ant_error;
long nr = doc_contabilized(doc, TRUE);
long nr = doc_contabilized(doc, true);
if (nr <= 0)
{
if (get_next_reg_num(nr) != no_error)
@ -3232,7 +3162,7 @@ error_type TContabilizzazione::write_pagamento_anticipo(TDocumento& doc)
if (is_saldo_doc)
rp.put(PAGSCA_ACCSAL, 'S');
partita->modifica_pagamento(rp, tval, old_ap, old_abb, old_diffcam, new_ap, new_abb, new_diffcam, TRUE);
partita->modifica_pagamento(rp, tval, old_ap, old_abb, old_diffcam, new_ap, new_abb, new_diffcam, true);
abb += new_abb.valore();
}
@ -3310,12 +3240,12 @@ error_type TContabilizzazione::write_anticipo(TDocumento& doc)
TSaldo_agg saldo;
int err = NOERR;
if (doc_contabilized(doc, TRUE))
if (doc_contabilized(doc, true))
{
TMovimentoPN oldant;
oldant.curr().put(MOV_NUMREG, doc.get(DOC_NUMANT));
if (oldant.read() == NOERR)
aggiorna_saldi(saldo, oldant, FALSE);
aggiorna_saldi(saldo, oldant, false);
err = _anticipo->rewrite();
}
else
@ -3326,7 +3256,7 @@ error_type TContabilizzazione::write_anticipo(TDocumento& doc)
err, _anticipo->curr().get_long(MOV_NUMREG));
return generic_error;
}
aggiorna_saldi(saldo, *_anticipo, TRUE);
aggiorna_saldi(saldo, *_anticipo, true);
}
delete _anticipo;
_anticipo = NULL;
@ -3457,7 +3387,7 @@ error_type TContabilizzazione::write_intra(TDocumento& doc)
righe.add(key, rc);
}
const real qta = rr.get_real(RDOC_QTA);
TCurrency_documento imp_val(rr.exist("VALINTRA") ? rr.get_real("VALINTRA") : rr.importo(TRUE, FALSE), doc);
TCurrency_documento imp_val(rr.exist("VALINTRA") ? rr.get_real("VALINTRA") : rr.importo(true, false), doc);
TCurrency_documento imp(imp_val); imp.change_to_firm_val();
imp_val.change_value(codvali, cambioi);
real ammlire = rc->get_real("AMMLIRE");
@ -3545,7 +3475,7 @@ error_type TContabilizzazione::write_intra(TDocumento& doc)
if (intra.status() == NOERR)
{
// righe!
if (rintra.write(TRUE) != NOERR) // Forza la riscrittura se necessario
if (rintra.write(true) != NOERR) // Forza la riscrittura se necessario
_error = intra_mov_error;
}
else
@ -3555,6 +3485,43 @@ error_type TContabilizzazione::write_intra(TDocumento& doc)
return _error;
}
error_type TContabilizzazione::write_anal(const TDocumento& doc, const TMovimentoPN& movimento)
{
// Controlla flag sulla causale
if (!_caus->link_analitica())
return _error;
TConfig_anal cfg;
const TDate data_att = cfg.get("DtAttCa");
if (data_att.ok())
{
const TDate data_cmp = movimento.curr().get(MOV_DATACOMP);
if (data_cmp < data_att) // La data di competenza precede la data di attivazione analitica
return _error;
}
bool is_anal = false;
TImporto totanal;
for (int i = movimento.cg_items(); i > 0; i--)
{
const TRectype& cgrow = movimento.cg_rows().row(i);
const TBill bill(cgrow);
if (bill.is_analitico())
{
const TImporto imp(cgrow.get_char(RMV_SEZIONE), cgrow.get_real(RMV_IMPORTO));
totanal += imp;
is_anal = true;
}
}
if (is_anal)
{
TContabilizzazione_analitica canal(NULL);
canal.elabora(doc, totanal);
}
return _error;
}
void TContabilizzazione::aggiorna_saldi(TSaldo_agg& saldo, TMovimentoPN& mv, bool save)
{
const TRectype& mov = mv.curr();
@ -3572,12 +3539,12 @@ void TContabilizzazione::aggiorna_saldi(TSaldo_agg& saldo, TMovimentoPN& mv, boo
// if (save) saldo.reset(); // Bella ca%%ata: distrugge i saldi del vecchio movimento!
saldo.set_movprovv(FALSE);
saldo.set_movprovv(false);
saldo.set_tipo_saldo(tsal);
saldo.set_anno_es(mov.get_int(MOV_ANNOES));
saldo.set_num_ulmov(mov.get_long(MOV_NUMREG));
saldo.set_data_ulmov(datareg);
saldo.set_movimentato(TRUE);
saldo.set_movimentato(true);
const int cgitems = mv.cg_items();
for (int i = 0; i < cgitems; i++)
@ -3748,7 +3715,7 @@ void TContabilizzazione::display_error(TDocumento& doc)
else
error_box(msg);
_error = no_error; // reset error, as any other one would do, so you can show me the other ones.
_can_write = FALSE; // But from now on u cannot write anymore. U must exit this program and repair errors occurred.
_can_write = false; // But from now on u cannot write anymore. U must exit this program and repair errors occurred.
}
bool TContabilizzazione::sc_enabled() const
@ -3818,7 +3785,7 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc
if (interattivo)
{
_auto_data = TRUE;
_auto_data = true;
_nump_iva = 1;
}
@ -3826,12 +3793,12 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc
_cpg->setkey(1); // Setta per sicurezza la chiave 1 nel caso l'elaborazione sia invocata da VE0
if (!load_parameters()) // Carica i parametri dalla configurazione
return FALSE;
return false;
TPrinter& p = printer();
p.links().add("Movimento Prima Nota |b|w", 0);
p.setlinkhandler(link_handler);
_viswin = new TViswin(NULL, TR("Contabilizzazione documenti"), FALSE, TRUE, TRUE);
_viswin = new TViswin(NULL, TR("Contabilizzazione documenti"), false, true, true);
_viswin->open_modal();
const clock_t start_time = clock();
@ -3843,7 +3810,7 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc
{
const bool acquisto = doc_in[0].get_char(DOC_TIPOCF) == 'F';
if (acquisto)
_check_prev_cont = FALSE;
_check_prev_cont = false;
}
for (int i = 0; i < items; i++) // Scorriamo tutti i documenti nella lista
@ -3923,9 +3890,9 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc
const char sez = r.get_char(RMV_SEZIONE);
const TCurrency imp(r.get_real(RMV_IMPORTO));
if (sez == 'D')
msg.format("%24s %24s", imp.string(TRUE), "");
msg.format("%24s %24s", imp.string(true), "");
else
msg.format("%24s %24s", "", imp.string(TRUE));
msg.format("%24s %24s", "", imp.string(true));
TBill bill(r);
str.cut(0);
@ -3952,7 +3919,7 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc
// Let's free some valuable space
if (!interattivo)
doc_in.destroy(i, FALSE);
doc_in.destroy(i, false);
}
_viswin->close_print();
_viswin->close_modal();
@ -3968,7 +3935,7 @@ bool TContabilizzazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc
printer().print_txt(_viswin->text());
delete _viswin; _viswin = NULL;
return _can_write; // Se non ha riscontrato errori per nessun documento, _can_write = TRUE
return _can_write; // Se non ha riscontrato errori per nessun documento, _can_write = true
}
bool TContabilizzazione::call_exe(const TDocumento& doc, const TMovimentoPN& movimento) const

8
ve/velib04c.cpp
View File

@ -1,14 +1,14 @@
#include <progind.h>
#include "velib04.h"
#include "../cg/cgsaldac.h"
#include "../ef/ef0101.h"
#include <doc.h>
#include <rdoc.h>
#include <effetti.h>
#include <reffetti.h>
#include "../cg/cgsaldac.h"
#include "../ef/ef0101.h"
#include "velib.h"
///////////////////////////////////////////////////////////
// TGenerazione_effetti

2
ve/velib04d.cpp
View File

@ -1,6 +1,6 @@
#include <automask.h>
#include "velib.h"
#include "velib04.h"
#include "velib04d.h"
#include <doc.h>

2
ve/velib04e.cpp
View File

@ -1,7 +1,7 @@
#include <automask.h>
#include <diction.h>
#include "velib.h"
#include "velib04.h"
#include "velib04e.h"
#include <doc.h>

19
ve/velib04f.cpp Executable file
View File

@ -0,0 +1,19 @@
#include "velib04.h"
#include <doc.h>
bool TContabilizzazione_analitica::elabora(const TDocumento& doc_in, const TImporto& totdoc)
{
return false;
}
bool TContabilizzazione_analitica::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo)
{
const TImporto zero;
for (int i = 0; doc_in.items(); i++)
{
if (!elabora(doc_in[i], zero))
return false;
}
return true;
}

20
ve/velib06.cpp
View File

@ -9,7 +9,7 @@
#include <postman.h>
#include <urldefid.h>
#include "velib.h"
#include "velib04.h"
#include "vepriv.h"
#include "verig.h"
@ -1393,6 +1393,21 @@ void TDocumento_mask::highlight(COLOR high_back_color, COLOR high_color)
// TLista_elaborazioni
///////////////////////////////////////////////////////////
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();
};
void TLista_elaborazioni::read()
{
if (_elab == NULL)
@ -1427,6 +1442,9 @@ void TLista_elaborazioni::read()
case _consuntivazione_produzione :
el = new TConsuntivazione_produzione(eld.curr());
break;
case _contabilizzazione_analitica :
el = new TContabilizzazione_analitica(eld.curr());
break;
default :
break;
}