Allineamento file modificati durante la transizione da cvs a svn

git-svn-id: svn://10.65.10.50/branches/R_10_00@22612 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2012-03-20 13:37:23 +00:00
parent cbe7122e89
commit 4dc843a0a2
37 changed files with 41354 additions and 40622 deletions

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,367 +1,367 @@
#ifndef __CGSALDAC_H #ifndef __CGSALDAC_H
#define __CGSALDAC_H #define __CGSALDAC_H
#ifndef __RECARRAY_H #ifndef __RECARRAY_H
#include <recarray.h> #include <recarray.h>
#endif #endif
#ifndef __CGLIB01_H #ifndef __CGLIB01_H
#include "../cg/cglib01.h" #include "../cg/cglib01.h"
#endif #endif
#ifndef __PARTITE_H #ifndef __PARTITE_H
#include <partite.h> #include <partite.h>
#endif #endif
#ifndef __SCADENZE_H #ifndef __SCADENZE_H
#include <scadenze.h> #include <scadenze.h>
#endif #endif
#ifndef __PAGSCA_H #ifndef __PAGSCA_H
#include <pagsca.h> #include <pagsca.h>
#endif #endif
class TTree_rectype : public TRectype class TTree_rectype : public TRectype
{ {
protected: protected:
TRecord_array _recarr; TRecord_array _recarr;
protected: // TRectype protected: // TRectype
virtual TObject* dup() const; virtual TObject* dup() const;
virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock); virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
virtual int write(TBaseisamfile& f) const; virtual int write(TBaseisamfile& f) const;
virtual int rewrite(TBaseisamfile& f) const; virtual int rewrite(TBaseisamfile& f) const;
virtual int remove(TBaseisamfile& f) const; virtual int remove(TBaseisamfile& f) const;
virtual void renum_key(const char* field, const char* val); virtual void renum_key(const char* field, const char* val);
const TRecord_array& rows_array() const { return _recarr; } const TRecord_array& rows_array() const { return _recarr; }
TRecord_array& rows_array() { return _recarr; } TRecord_array& rows_array() { return _recarr; }
public: public:
int fill_array(); int fill_array();
const TRectype& row(int r) const { return _recarr.row(r); } const TRectype& row(int r) const { return _recarr.row(r); }
TRectype& row(int r) { return _recarr.row(r, true); } TRectype& row(int r) { return _recarr.row(r, true); }
TRectype& new_row(int r = 0); TRectype& new_row(int r = 0);
void destroy_rows() { _recarr.destroy_rows(); } void destroy_rows() { _recarr.destroy_rows(); }
void copy_key_to_row(TRectype& row) const; void copy_key_to_row(TRectype& row) const;
int first() const { return _recarr.first_row(); } int first() const { return _recarr.first_row(); }
int last() const { return _recarr.last_row(); } int last() const { return _recarr.last_row(); }
int pred(int r) const { return _recarr.pred_row(r); } int pred(int r) const { return _recarr.pred_row(r); }
int succ(int r) const { return _recarr.succ_row(r); } int succ(int r) const { return _recarr.succ_row(r); }
bool exist(int r) const { return _recarr.exist(r); } bool exist(int r) const { return _recarr.exist(r); }
int rows() const { return _recarr.rows(); } int rows() const { return _recarr.rows(); }
TTree_rectype(const TRectype& testata, const TRectype& riga, const char* num); TTree_rectype(const TRectype& testata, const TRectype& riga, const char* num);
TTree_rectype(int testata, int riga, const char* num); TTree_rectype(int testata, int riga, const char* num);
TTree_rectype(const TTree_rectype& t); TTree_rectype(const TTree_rectype& t);
virtual ~TTree_rectype() {} virtual ~TTree_rectype() {}
}; };
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Valuta // Valuta
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
class TValuta : public TSortable class TValuta : public TSortable
{ {
TString4 _cod; TString4 _cod;
TDate _dat; TDate _dat;
real _cam; real _cam;
protected: // TSortable protected: // TSortable
virtual int compare(const TSortable& s) const; virtual int compare(const TSortable& s) const;
protected: protected:
void adjust(); // Controlla il cambio per le lire void adjust(); // Controlla il cambio per le lire
void set(const TValuta& v); void set(const TValuta& v);
public: public:
const TString& codice() const { return _cod; } const TString& codice() const { return _cod; }
const TDate& data() const { return _dat; } const TDate& data() const { return _dat; }
const real& cambio() const { return _cam; } const real& cambio() const { return _cam; }
real eur2val(const real& lit) const; real eur2val(const real& lit) const;
real val2eur(const real& val) const; real val2eur(const real& val) const;
void val2eur(real& val) const; void val2eur(real& val) const;
void eur2val(real& lit) const; void eur2val(real& lit) const;
void val2eur(TImporto& impval) const; void val2eur(TImporto& impval) const;
void eur2val(TImporto& implit) const; void eur2val(TImporto& implit) const;
bool in_euro() const { return _cod.empty(); } bool in_euro() const { return _cod.empty(); }
bool in_valuta() const { return _cod.not_empty(); } bool in_valuta() const { return _cod.not_empty(); }
void get(const TRectype& rec); void get(const TRectype& rec);
void put(TRectype& rec) const; void put(TRectype& rec) const;
void set(TMask& m, short v, short d, short c) const; void set(TMask& m, short v, short d, short c) const;
void get(const TMask& m, short v, short d, short c); void get(const TMask& m, short v, short d, short c);
const TValuta& operator =(const TValuta& v) { set(v); return *this; } const TValuta& operator =(const TValuta& v) { set(v); return *this; }
TValuta(); TValuta();
TValuta(const char* cod, const TDate& dat, const real& cam); TValuta(const char* cod, const TDate& dat, const real& cam);
TValuta(const TRectype& rec) { get(rec); } TValuta(const TRectype& rec) { get(rec); }
TValuta(const TMask& m, short v, short d, short c) { get(m, v, d, c); } TValuta(const TMask& m, short v, short d, short c) { get(m, v, d, c); }
TValuta(const TValuta& v) { set(v); } TValuta(const TValuta& v) { set(v); }
virtual ~TValuta() {} virtual ~TValuta() {}
}; };
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Riga scadenza // Riga scadenza
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
enum tipo_pagamento { tp_nessuno = 0, tp_rimessa_diretta = 1, tp_tratta = 2, tp_riba = 3, enum tipo_pagamento { tp_nessuno = 0, tp_rimessa_diretta = 1, tp_tratta = 2, tp_riba = 3,
tp_cessione = 4, tp_paghero = 5, tp_lettera_credito = 6, tp_tratta_acc = 7, tp_cessione = 4, tp_paghero = 5, tp_lettera_credito = 6, tp_tratta_acc = 7,
tp_rid = 8, tp_bonifico = 9 }; tp_rid = 8, tp_bonifico = 9 };
class TRiga_scadenze : public TTree_rectype class TRiga_scadenze : public TTree_rectype
{ {
friend class TPartita; friend class TPartita;
friend class TRiga_partite; friend class TRiga_partite;
TRiga_partite* _riga; TRiga_partite* _riga;
protected: protected:
char calcola_abbuono(int p, TImporto& abbuono, bool update); char calcola_abbuono(int p, TImporto& abbuono, bool update);
TImporto calcola_differenza_cambio(int p, bool update); TImporto calcola_differenza_cambio(int p, bool update);
bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta, bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta,
char& old_ap, TImporto& old_abb, TImporto& old_diffcam, char& old_ap, TImporto& old_abb, TImporto& old_diffcam,
char& new_ap, TImporto& new_abb, TImporto& new_diffcam, bool update); char& new_ap, TImporto& new_abb, TImporto& new_diffcam, bool update);
bool elimina_pagamento(int p); bool elimina_pagamento(int p);
protected: // TRecord_tree protected: // TRecord_tree
virtual TObject* dup() const; virtual TObject* dup() const;
public: public:
bool chiusa(bool update = false) const; bool chiusa(bool update = false) const;
const TString& codice_valuta() const; const TString& codice_valuta() const;
bool in_valuta() const; bool in_valuta() const;
TPartita& partita() const; TPartita& partita() const;
TRiga_partite& riga() const { return *_riga; } // Riga partite TRiga_partite& riga() const { return *_riga; } // Riga partite
TImporto importo_pagato_al(bool val, const TDate & al, int mode = 0xF) const; TImporto importo_pagato_al(bool val, const TDate & al, int mode = 0xF) const;
TImporto importo_pagato(bool val, int mode = 0xF) const; TImporto importo_pagato(bool val, int mode = 0xF) const;
TImporto importo(bool val) const; TImporto importo(bool val) const;
TImporto residuo(bool val, int mode = 0xF) const; // Differenza delle due funzioni precedenti TImporto residuo(bool val, int mode = 0xF) const; // Differenza delle due funzioni precedenti
TImporto esposto_al(bool valuta, const TDate & al, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const; TImporto esposto_al(bool valuta, const TDate & al, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const;
TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const ; TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const ;
bool esistono_abbuoni_diffcam() const; bool esistono_abbuoni_diffcam() const;
TRiga_scadenze(TRiga_partite* riga); TRiga_scadenze(TRiga_partite* riga);
TRiga_scadenze(const TRiga_scadenze& s); TRiga_scadenze(const TRiga_scadenze& s);
virtual ~TRiga_scadenze(); virtual ~TRiga_scadenze();
}; };
class TRiga_partite : public TTree_rectype class TRiga_partite : public TTree_rectype
{ {
friend class TPartita; friend class TPartita;
friend class TRiga_scadenze; friend class TRiga_scadenze;
TPartita* _partita; TPartita* _partita;
protected: protected:
void update_rigaptr(); void update_rigaptr();
public: // TTree_rectype public: // TTree_rectype
virtual TObject* dup() const { return new TRiga_partite(*this); } virtual TObject* dup() const { return new TRiga_partite(*this); }
virtual int read(TBaseisamfile& f, word op, word lockop); virtual int read(TBaseisamfile& f, word op, word lockop);
virtual int write(TBaseisamfile& f) const; virtual int write(TBaseisamfile& f) const;
virtual int rewrite(TBaseisamfile& f) const; virtual int rewrite(TBaseisamfile& f) const;
virtual int remove(TBaseisamfile& f) const; virtual int remove(TBaseisamfile& f) const;
public: public:
int rate() const { return _recarr.rows(); } int rate() const { return _recarr.rows(); }
TRiga_scadenze& rata(int r) const { return (TRiga_scadenze&)_recarr.row(r); } TRiga_scadenze& rata(int r) const { return (TRiga_scadenze&)_recarr.row(r); }
void elimina_rata(int r = 0); void elimina_rata(int r = 0);
TRiga_scadenze& new_row(int r = 0); TRiga_scadenze& new_row(int r = 0);
tipo_movimento tipo() const; tipo_movimento tipo() const;
tipo_pagamento tipo_pag() const; tipo_pagamento tipo_pag() const;
bool is_fattura() const { return tipo() == tm_fattura; } bool is_fattura() const { return tipo() == tm_fattura; }
bool is_nota_credito() const { return tipo() == tm_nota_credito; } bool is_nota_credito() const { return tipo() == tm_nota_credito; }
int ultima_ratapagata() const; int ultima_ratapagata() const;
int ultimo_pagamento(int rata) const; int ultimo_pagamento(int rata) const;
int ultima_rata_con_abbuoni_diffcam() const; int ultima_rata_con_abbuoni_diffcam() const;
char sezione() const { return get_char(PART_SEZ); } char sezione() const { return get_char(PART_SEZ); }
char sezione_ritsoc() const; char sezione_ritsoc() const;
TImporto importo(bool valuta, int mode = 0xF) const; TImporto importo(bool valuta, int mode = 0xF) const;
TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const; TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) const;
TImporto calcola_pagato_al(bool valuta,const TDate& al, const TDate & data_scaduto, const TDate& data_rischio, int mode = 0xF) const; TImporto calcola_pagato_al(bool valuta,const TDate& al, const TDate & data_scaduto, const TDate& data_rischio, int mode = 0xF) const;
const TString& codice_valuta() const; const TString& codice_valuta() const;
bool in_valuta() const; bool in_valuta() const;
bool update(const TRectype& vec, const TRectype& nuo, const char* field); bool update(const TRectype& vec, const TRectype& nuo, const char* field);
bool update(const TImporto& vec, const TImporto& nuo, const char* sez, const char* val); bool update(const TImporto& vec, const TImporto& nuo, const char* sez, const char* val);
TPartita& partita() const { CHECK(_partita, "Partita nulla"); return *_partita; } TPartita& partita() const { CHECK(_partita, "Partita nulla"); return *_partita; }
TRiga_partite(TPartita* game); TRiga_partite(TPartita* game);
TRiga_partite(const TRiga_partite& r); TRiga_partite(const TRiga_partite& r);
virtual ~TRiga_partite(); virtual ~TRiga_partite();
}; };
class TPartite_array; class TPartite_array;
class TPartita : public TSortable class TPartita : public TSortable
{ {
TBill _conto; TBill _conto;
int _anno; int _anno;
TString16 _num; TString16 _num;
TRecord_array _part; TRecord_array _part;
TRecord_array _unassigned; TRecord_array _unassigned;
char _align; // current _num alignment char _align; // current _num alignment
static char _cli_align, _for_align; // default _num alignment static char _cli_align, _for_align; // default _num alignment
static bool _diffcam_always; static bool _diffcam_always;
protected: protected:
char allineamento_iniziale() const { return _align; } char allineamento_iniziale() const { return _align; }
char allineamento_corrente() const; char allineamento_corrente() const;
int write_saldo(bool re, TRectype* rec = NULL) const; int write_saldo(bool re, TRectype* rec = NULL) const;
public: // TObject public: // TObject
virtual bool ok() const { return _part.rows() > 0; } virtual bool ok() const { return _part.rows() > 0; }
virtual int compare(const TSortable& s) const; virtual int compare(const TSortable& s) const;
public: public:
enum { NUMLEN = 7, UNASSIGNED = 9999 }; enum { NUMLEN = 7, UNASSIGNED = 9999 };
TRiga_partite& riga(int r) const; TRiga_partite& riga(int r) const;
TRiga_partite& new_row(int r = 0); TRiga_partite& new_row(int r = 0);
void rimuovi_riga(int r); void rimuovi_riga(int r);
TRiga_scadenze& rata(int nriga, int nrata) const; TRiga_scadenze& rata(int nriga, int nrata) const;
TRectype& pagamento(int nriga, int nrata, int nrigp); TRectype& pagamento(int nriga, int nrata, int nrigp);
bool rata_chiusa(int nriga, int nrata) const; bool rata_chiusa(int nriga, int nrata) const;
bool esiste(int nriga, int nrata = 0, int nrigp = 0) const; bool esiste(int nriga, int nrata = 0, int nrigp = 0) const;
bool esistono_abbuoni_diffcam(long nreg = 0) const; bool esistono_abbuoni_diffcam(long nreg = 0) const;
const TString& codice_valuta() const; const TString& codice_valuta() const;
bool in_valuta() const ; bool in_valuta() const ;
// assegna riga e figli ad altra partita // assegna riga e figli ad altra partita
void sposta_riga(int from_row, TPartita& part, int to_row); void sposta_riga(int from_row, TPartita& part, int to_row);
// de-assegna tutti i pagamenti di una riga e li distrugge // de-assegna tutti i pagamenti di una riga e li distrugge
void scollega_pagamenti(int riga, int rata = 1); void scollega_pagamenti(int riga, int rata = 1);
void allinea(char all = ' '); void allinea(char all = ' ');
int succ(int r) const { return _part.succ_row(r); } int succ(int r) const { return _part.succ_row(r); }
int pred(int r) const { return _part.pred_row(r); } int pred(int r) const { return _part.pred_row(r); }
int first() const { return _part.first_row(); } int first() const { return _part.first_row(); }
int last() const { return _part.last_row(); } int last() const { return _part.last_row(); }
bool reread(); bool reread();
bool read(const TBill& clifo, int anno, const char* num); bool read(const TBill& clifo, int anno, const char* num);
bool write(bool re = false) const; bool write(bool re = false) const;
bool rewrite() const { return write(true); } bool rewrite() const { return write(true); }
bool remove() const; bool remove() const;
bool is_on_file() const; bool is_on_file() const;
int mov2rig(long nreg, int rmov) const; int mov2rig(long nreg, int rmov) const;
int rig2mov(int rmov) const; int rig2mov(int rmov) const;
int prima_riga(long nreg = -1, tipo_movimento tipo = tm_nessuno) const; int prima_riga(long nreg = -1, tipo_movimento tipo = tm_nessuno) const;
int prima_fattura(long nreg = -1) const; int prima_fattura(long nreg = -1) const;
int primo_pagamento(long nreg = -1) const; int primo_pagamento(long nreg = -1) const;
bool utilizzata(int r) const; // Controlla se esistono pagamenti sommati alla riga r bool utilizzata(int r) const; // Controlla se esistono pagamenti sommati alla riga r
TRecord_array& unassigned() { return _unassigned; } TRecord_array& unassigned() { return _unassigned; }
bool chiusa(bool update = false) const; bool chiusa(bool update = false) const;
const TBill& conto() const { return _conto; } const TBill& conto() const { return _conto; }
int anno() const { return _anno; } int anno() const { return _anno; }
const TString& numero() const { return _num; } const TString& numero() const { return _num; }
const TString& descrizione() const; //const TString& descrizione() const;
const char* build_key(TString& key) const; const char* build_key(TString& key) const;
TImporto importo_speso(long numreg, int numrig, bool valuta, int mode = 0xF) const; TImporto importo_speso(long numreg, int numrig, bool valuta, int mode = 0xF) const;
void update_reg(long nreg, const TRectype& mov, TPartite_array& pa); void update_reg(long nreg, const TRectype& mov, TPartite_array& pa);
void calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp) const; void calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp) const;
TImporto calcola_saldo(bool valuta) const; TImporto calcola_saldo(bool valuta) const;
TImporto calcola_pagato_al(bool valuta,const TDate& al, const TDate & data_scaduto, const TDate& data_rischio) const; TImporto calcola_pagato_al(bool valuta,const TDate& al, const TDate & data_scaduto, const TDate& data_rischio) const;
TImporto calcola_saldo_al(bool valuta, const TDate& al, const TDate& data_scaduto, const TDate& data_rischio) const; TImporto calcola_saldo_al(bool valuta, const TDate& al, const TDate& data_scaduto, const TDate& data_rischio) const;
real calcola_scaduto_al(bool valuta, const TDate& al = botime) const; real calcola_scaduto_al(bool valuta, const TDate& al = botime) const;
TImporto importo_pagato_unassigned(bool val, int mode = 0xF) const; TImporto importo_pagato_unassigned(bool val, int mode = 0xF) const;
bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta, bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta,
char& old_ap, TImporto& old_abb, TImporto& old_diffcam, char& old_ap, TImporto& old_abb, TImporto& old_diffcam,
char& new_ap, TImporto& new_abb, TImporto& new_diffcam, char& new_ap, TImporto& new_abb, TImporto& new_diffcam,
bool update); bool update);
bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta, bool update); bool modifica_pagamento(const TRectype& new_pag, const TValuta& valuta, bool update);
bool elimina_pagamento(int nriga, int nrata, int nrigp); bool elimina_pagamento(int nriga, int nrata, int nrigp);
static void carica_allineamento(); static void carica_allineamento();
static char allineamento_richiesto(char tipocf); static char allineamento_richiesto(char tipocf);
static int read_saldo(TRectype& riga, TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp); static int read_saldo(TRectype& riga, TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp);
static bool rileva_sempre_differenze_cambi(); static bool rileva_sempre_differenze_cambi();
int tipopag2causale(int tipo) const; int tipopag2causale(int tipo) const;
TPartita(const TBill& clifo, int anno, const char* num); TPartita(const TBill& clifo, int anno, const char* num);
TPartita(const TRectype& part); TPartita(const TRectype& part);
virtual ~TPartita(); virtual ~TPartita();
}; };
class TPartite_array : private TAssoc_array class TPartite_array : private TAssoc_array
{ {
TString _key; // Work string TString _key; // Work string
long _numreg; // Last registration loaded long _numreg; // Last registration loaded
protected: protected:
const TString& key(const TBill& clifo, int anno, const char* num); // Build key for TAssoc_array const TString& key(const TBill& clifo, int anno, const char* num); // Build key for TAssoc_array
TPartita* find(const TBill& clifo, int anno, const char* numero, bool create); TPartita* find(const TBill& clifo, int anno, const char* numero, bool create);
TPartita* find(const TRectype& part, bool create); TPartita* find(const TRectype& part, bool create);
public: // TAssoc_array public: // TAssoc_array
virtual void destroy(); virtual void destroy();
public: public:
TPartita& partita(const TBill& clifo, int anno, const char* numero); TPartita& partita(const TBill& clifo, int anno, const char* numero);
TPartita& partita(const TRectype& r); TPartita& partita(const TRectype& r);
TPartita* exist(const TBill& clifo, int anno, const char* numero) const TPartita* exist(const TBill& clifo, int anno, const char* numero) const
{ return ((TPartite_array*)this)->find(clifo, anno, numero, false); } { return ((TPartite_array*)this)->find(clifo, anno, numero, false); }
TPartita* exist(const TRectype& part) const TPartita* exist(const TRectype& part) const
{ return ((TPartite_array*)this)->find(part, false); } { return ((TPartite_array*)this)->find(part, false); }
bool insert(TPartita* p); bool insert(TPartita* p);
bool destroy(const TBill& clifo, int anno, const char* num); bool destroy(const TBill& clifo, int anno, const char* num);
bool destroy(TPartita& game); bool destroy(TPartita& game);
bool write(bool re = false); bool write(bool re = false);
bool rewrite() { return write(true); } bool rewrite() { return write(true); }
int add_numreg(long numreg); // Carica tutte le partite relative alla registrazione numreg int add_numreg(long numreg); // Carica tutte le partite relative alla registrazione numreg
TImporto importo_speso(long numreg, int numrig, bool valuta = false, int mode = 0xF); TImporto importo_speso(long numreg, int numrig, bool valuta = false, int mode = 0xF);
void update_reg(const TRectype& mov, long old_reg = 0); void update_reg(const TRectype& mov, long old_reg = 0);
// Controlla se esistono righe di pagamento relative alla riga numrig // Controlla se esistono righe di pagamento relative alla riga numrig
bool utilizzata(long numreg, int numrig); bool utilizzata(long numreg, int numrig);
// Cerca la riga della partita relativa alla registrazione numreg // Cerca la riga della partita relativa alla registrazione numreg
TRiga_partite* mov2rig(long numreg, int numrig); TRiga_partite* mov2rig(long numreg, int numrig);
int items() const { return TAssoc_array::items(); } int items() const { return TAssoc_array::items(); }
TPartita* first() { restart(); return next(); } TPartita* first() { restart(); return next(); }
TPartita* next() { return (TPartita*)get(); } TPartita* next() { return (TPartita*)get(); }
TPartite_array() : _numreg(0) {} TPartite_array() : _numreg(0) {}
virtual ~TPartite_array() {} virtual ~TPartite_array() {}
}; };
#endif #endif

View File

@ -1,267 +1,267 @@
#include "ef0101.h" #include "ef0101.h"
////////////////////////////////////////////////// //////////////////////////////////////////////////
// Definizione dei metodi della classe TEffetto // // Definizione dei metodi della classe TEffetto //
////////////////////////////////////////////////// //////////////////////////////////////////////////
// costruttore di default // costruttore di default
TEffetto::TEffetto() TEffetto::TEffetto()
: TRectype(LF_EFFETTI), _righe(LF_REFFETTI, REFF_NRIGATR), _cess(LF_CESS, CES_NRIGA) : TRectype(LF_EFFETTI), _righe(LF_REFFETTI, REFF_NRIGATR), _cess(LF_CESS, CES_NRIGA)
{ {
} }
// costuisce l'effetto con il record passato // costuisce l'effetto con il record passato
TEffetto::TEffetto(const TRectype& rec) TEffetto::TEffetto(const TRectype& rec)
: TRectype(LF_EFFETTI), _righe(LF_REFFETTI, REFF_NRIGATR), _cess(LF_CESS, CES_NRIGA) : TRectype(LF_EFFETTI), _righe(LF_REFFETTI, REFF_NRIGATR), _cess(LF_CESS, CES_NRIGA)
{ {
TLocalisamfile f(LF_EFFETTI); TLocalisamfile f(LF_EFFETTI);
read(f,rec); read(f,rec);
} }
TEffetto::TEffetto(const TEffetto& eff) TEffetto::TEffetto(const TEffetto& eff)
: TRectype(eff), _righe(eff._righe), _cess(eff._cess) : TRectype(eff), _righe(eff._righe), _cess(eff._cess)
{ {
} }
TObject* TEffetto::dup() const TObject* TEffetto::dup() const
{ {
TEffetto* e = new TEffetto((const TEffetto&)*this); TEffetto* e = new TEffetto((const TEffetto&)*this);
return e; return e;
} }
// setta i campi per la prima chiave (nprogtr) // setta i campi per la prima chiave (nprogtr)
void TEffetto::put_key(TRectype& rec, long numeff) const void TEffetto::put_key(TRectype& rec, long numeff) const
{ {
CHECKD(numeff >= 0, "Numero effetto non valido ", numeff); CHECKD(numeff >= 0, "Numero effetto non valido ", numeff);
rec.put(EFF_NPROGTR, numeff); rec.put(EFF_NPROGTR, numeff);
} }
// setta i campi per la quarta chiave (tipodist+ndist+nrigadist) // setta i campi per la quarta chiave (tipodist+ndist+nrigadist)
void TEffetto::put_key(TRectype& rec,char tipodist, long ndist, int nrigadist) void TEffetto::put_key(TRectype& rec,char tipodist, long ndist, int nrigadist)
{ {
CHECK(tipodist == 'I' || tipodist == 'S' || tipodist == 'B' || tipodist == 0, "Tipo distinta"); CHECK(tipodist == 'I' || tipodist == 'S' || tipodist == 'B' || tipodist == 0, "Tipo distinta");
CHECKD(ndist >= 0, "Numero distinta non valido ", ndist); CHECKD(ndist >= 0, "Numero distinta non valido ", ndist);
CHECKD(nrigadist >= 0, "Numero riga distinta non valido ", nrigadist); CHECKD(nrigadist >= 0, "Numero riga distinta non valido ", nrigadist);
rec.put(EFF_TIPODIST, tipodist); rec.put(EFF_TIPODIST, tipodist);
rec.put(EFF_NDIST, ndist); rec.put(EFF_NDIST, ndist);
rec.put(EFF_NRIGADIST, nrigadist); rec.put(EFF_NRIGADIST, nrigadist);
} }
// ritorna la prossima chiave utilizzabile // ritorna la prossima chiave utilizzabile
long TEffetto::get_next_key(const long /* codcf */) const long TEffetto::get_next_key(const long /* codcf */) const
{ {
long n = 1; long n = 1;
TLocalisamfile eff(LF_EFFETTI); TLocalisamfile eff(LF_EFFETTI);
int err = eff.last(); int err = eff.last();
if (err == NOERR) if (err == NOERR)
n += eff.get_long(EFF_NPROGTR); n += eff.get_long(EFF_NPROGTR);
return n; return n;
} }
// rinumera la chiave 1 (nprogtr) // rinumera la chiave 1 (nprogtr)
long TEffetto::renum(long numeff) long TEffetto::renum(long numeff)
{ {
if (numeff <= 0) if (numeff <= 0)
{ {
long codcf = codicec(); long codcf = codicec();
numeff = get_next_key(codcf); numeff = get_next_key(codcf);
} }
TString8 num; num << numeff; TString8 num; num << numeff;
renum_key(EFF_NPROGTR, num); // aggiorna testata renum_key(EFF_NPROGTR, num); // aggiorna testata
_righe.renum_key(EFF_NPROGTR, num); // aggiorna righe ok _righe.renum_key(EFF_NPROGTR, num); // aggiorna righe ok
_cess.renum_key(EFF_NPROGTR, num); // aggiorna cessionari ok _cess.renum_key(EFF_NPROGTR, num); // aggiorna cessionari ok
return numeff; return numeff;
} }
// restituisce il prossimo effetto // restituisce il prossimo effetto
int TEffetto::next(TBaseisamfile& f) int TEffetto::next(TBaseisamfile& f)
{ {
const int err = f.next(); const int err = f.next();
*this = f.curr(); *this = f.curr();
return err; return err;
} }
// permette di leggere il record passato nel file passato, comune alla // permette di leggere il record passato nel file passato, comune alla
// lettura per chiave 1 e per chiave 4 // lettura per chiave 1 e per chiave 4
int TEffetto::leggi(TLocalisamfile &f, const TRectype& r, word lockop) int TEffetto::leggi(TLocalisamfile &f, const TRectype& r, word lockop)
{ {
//int err = TRectype::read(f); //int err = TRectype::read(f);
int err = f.read(*this, _isequal, lockop); int err = f.read(*this, _isequal, lockop);
const long nu = numero(); const long nu = numero();
// necessari per poter andare a leggere i due record array // necessari per poter andare a leggere i due record array
// cessionari e righe effetto // cessionari e righe effetto
TRectype *k_reff = new TRectype(LF_REFFETTI), TRectype *k_reff = new TRectype(LF_REFFETTI),
*k_cess = new TRectype(LF_CESS); *k_cess = new TRectype(LF_CESS);
// setto la chiave per poter leggere dai due record array // setto la chiave per poter leggere dai due record array
put_key(*k_reff, nu); put_key(*k_reff, nu);
put_key(*k_cess, nu); put_key(*k_cess, nu);
if (err == NOERR) if (err == NOERR)
{ // leggo dai record array { // leggo dai record array
_righe.read(k_reff); _righe.read(k_reff);
_cess.read(k_cess); _cess.read(k_cess);
} }
else // se ho trovato un errore else // se ho trovato un errore
{ {
head() = r; head() = r;
if (nu !=0) if (nu !=0)
{ {
destroy_rows_r(); destroy_rows_r();
destroy_rows_c(); destroy_rows_c();
_cess.set_key(k_cess); _cess.set_key(k_cess);
_righe.set_key(k_reff); _righe.set_key(k_reff);
} }
} }
return err; return err;
} }
// legge il record passato, con chiave 1 // legge il record passato, con chiave 1
int TEffetto::read(TLocalisamfile& f, const TRectype& rec, word lockop) int TEffetto::read(TLocalisamfile& f, const TRectype& rec, word lockop)
{ {
head() = rec; head() = rec;
return leggi(f, rec, lockop); return leggi(f, rec, lockop);
} }
// legge l'effetto usando la chiave 4 // legge l'effetto usando la chiave 4
int TEffetto::read(TLocalisamfile& f, char tipodist, long ndist, int nrigadist, word lockop) int TEffetto::read(TLocalisamfile& f, char tipodist, long ndist, int nrigadist, word lockop)
{ {
f.setkey(4); f.setkey(4);
TRectype& rec = head(); TRectype& rec = head();
put_key(rec, tipodist, ndist, nrigadist); put_key(rec, tipodist, ndist, nrigadist);
return leggi(f, rec); // c'era lockop ??? return leggi(f, rec); // c'era lockop ???
} }
// scrive l'effetto, usando la chiave 1 // scrive l'effetto, usando la chiave 1
int TEffetto::write(TLocalisamfile& f, bool force) int TEffetto::write(TLocalisamfile& f, bool force)
{ {
const bool nuovo = numero() <= 0; // E' nuovo! const bool nuovo = numero() <= 0; // E' nuovo!
if (nuovo && force) // quindi ... if (nuovo && force) // quindi ...
force = FALSE; // ... non fare la rewrite force = FALSE; // ... non fare la rewrite
f.setkey(1); f.setkey(1);
int err = NOERR; int err = NOERR;
if (force) if (force)
{ {
err=_righe.write(force); err=_righe.write(force);
if (err == NOERR) if (err == NOERR)
err= _cess.write(force); err= _cess.write(force);
if (err == NOERR) if (err == NOERR)
{ {
err = TRectype::rewrite(f); err = TRectype::rewrite(f);
if (err != NOERR) if (err != NOERR)
err = TRectype::write(f); err = TRectype::write(f);
} }
} }
else else
{ {
if (nuovo) if (nuovo)
{ {
TEffetto& myself = *(TEffetto*)this; TEffetto& myself = *(TEffetto*)this;
if (numero() <= 0) if (numero() <= 0)
myself.renum(); myself.renum();
do do
{ {
err = TRectype::write(f); err = TRectype::write(f);
if (err == _isreinsert) if (err == _isreinsert)
myself.renum(); myself.renum();
} while (err == _isreinsert); } while (err == _isreinsert);
} }
else else
{ {
err = TRectype::write(f); err = TRectype::write(f);
if (err != NOERR) if (err != NOERR)
err = TRectype::rewrite(f); err = TRectype::rewrite(f);
} }
if (err == NOERR) if (err == NOERR)
{ {
err=_righe.write(force); err=_righe.write(force);
if (err == NOERR) if (err == NOERR)
err=_cess.write(force); err=_cess.write(force);
} }
} }
return err; return err;
} }
// rimuove l'effetto // rimuove l'effetto
int TEffetto::remove(TLocalisamfile& f)const int TEffetto::remove(TLocalisamfile& f)const
{ {
int err = _righe.remove(); int err = _righe.remove();
if (err == NOERR) if (err == NOERR)
err = _cess.remove(); err = _cess.remove();
if (err == NOERR) if (err == NOERR)
err = TRectype::remove(f); err = TRectype::remove(f);
return err; return err;
} }
// restituisce true se l'effetto si riferisce ad una sola fattura // restituisce true se l'effetto si riferisce ad una sola fattura
// ovvero se l'effetto non è raggruppato // ovvero se l'effetto non è raggruppato
bool TEffetto::fatt(long num) bool TEffetto::fatt() const
{ {
TLocalisamfile righe_eff(LF_REFFETTI); /* Codice inutile: rimosso il 14/03/2012
righe_eff.put(REFF_NPROGTR, num); TLocalisamfile righe_eff(LF_REFFETTI);
righe_eff.read(); righe_eff.put(REFF_NPROGTR, num);
// prende il numero delle righe dell'effetto righe_eff.read();
// ovvero di fatture a cui fa riferimento */
int items = rows_r(); // prende il numero delle righe dell'effetto
bool condition = (items == 1); // ovvero di fatture a cui fa riferimento
return condition; return rows_r() == 1;
} }
// restituisce i dati relativi alle fatture a cui si riferisce l'effetto // restituisce i dati relativi alle fatture a cui si riferisce l'effetto
// costruendo una TToken_string del tipo // costruendo una TToken_string del tipo
// "num_fatt0|data_fatt0|imp_fatt0|num_fatt1|data_fatt1|imp_fatt1|..." // "num_fatt0|data_fatt0|imp_fatt0|num_fatt1|data_fatt1|imp_fatt1|..."
TToken_string& TEffetto::dati_fatt(long num, const bool valuta, TToken_string& dati) TToken_string& TEffetto::dati_fatt(long num, const bool valuta, TToken_string& dati)
{ {
dati.cut(0); dati.cut(0);
TLocalisamfile righe_eff(LF_REFFETTI); TLocalisamfile righe_eff(LF_REFFETTI);
righe_eff.put(REFF_NPROGTR, num); righe_eff.put(REFF_NPROGTR, num);
righe_eff.read(); righe_eff.read();
const int items = rows_r(); // prende il numero delle righe dell'effetto const int items = rows_r(); // prende il numero delle righe dell'effetto
for (int i = 1; i <= items; i++) // le legge tutte for (int i = 1; i <= items; i++) // le legge tutte
{ {
dati.add(righe_eff.get(REFF_NFATT));//prende il numero dati.add(righe_eff.get(REFF_NFATT));//prende il numero
dati.add(righe_eff.get(REFF_DATAFATT));//prende la data dati.add(righe_eff.get(REFF_DATAFATT));//prende la data
dati.add(righe_eff.get(valuta ? REFF_IMPFATTVAL : REFF_IMPFATT));//prende l'importo dati.add(righe_eff.get(valuta ? REFF_IMPFATTVAL : REFF_IMPFATT));//prende l'importo
righe_eff.next();// passa alla riga successiva righe_eff.next();// passa alla riga successiva
} }
return dati; return dati;
} }
// restituisce i dati relativi alle fatture a cui si riferisce l'effetto // restituisce i dati relativi alle fatture a cui si riferisce l'effetto
// costruendo una TToken_string del tipo // costruendo una TToken_string del tipo
// "codnum_fatt0|num_fatt0|anno_fatt0|codnum_fatt1|num_fatt1|anno_fatt1|..." // "codnum_fatt0|num_fatt0|anno_fatt0|codnum_fatt1|num_fatt1|anno_fatt1|..."
TToken_string& TEffetto::altridati_fatt(long num, TToken_string& dati) TToken_string& TEffetto::altridati_fatt(long num, TToken_string& dati)
{ {
dati.cut(0); dati.cut(0);
TLocalisamfile righe_eff(LF_REFFETTI); TLocalisamfile righe_eff(LF_REFFETTI);
righe_eff.put(REFF_NPROGTR, num); righe_eff.put(REFF_NPROGTR, num);
righe_eff.read(); righe_eff.read();
const int items = rows_r(); // prende il numero delle righe dell'effetto const int items = rows_r(); // prende il numero delle righe dell'effetto
TString16 str; TString16 str;
for (int i = 1; i <= items; i++)// le legge tutte for (int i = 1; i <= items; i++)// le legge tutte
{ {
str = righe_eff.get(REFF_CODNUM); str.trim(); str = righe_eff.get(REFF_CODNUM); str.trim();
dati.add(str);//prende il codice numerazione dati.add(str);//prende il codice numerazione
str = righe_eff.get(REFF_NFATT); str.trim(); str = righe_eff.get(REFF_NFATT); str.trim();
dati.add(str);//prende il numero dati.add(str);//prende il numero
str = righe_eff.get(REFF_ANNODOC); str.trim(); str = righe_eff.get(REFF_ANNODOC); str.trim();
dati.add(str);//prende il numero dati.add(str);//prende il numero
righe_eff.next();// passa alla riga successiva righe_eff.next();// passa alla riga successiva
} }
return dati; return dati;
} }
const bool TEffetto::in_valuta() const const bool TEffetto::in_valuta() const
{ {
const TString16 val = get(EFF_CODVAL); const TString16 val = get(EFF_CODVAL);
return val.not_empty() && val != TCurrency::get_firm_val(); return val.not_empty() && val != TCurrency::get_firm_val();
} }
const char TEffetto::get_tipo() const const char TEffetto::get_tipo() const
{ {
const char tipo = get_char(EFF_TIPOCF); const char tipo = get_char(EFF_TIPOCF);
return tipo == '\0' ? 'C' : tipo; return tipo == '\0' ? 'C' : tipo;
} }

View File

@ -1,104 +1,104 @@
#ifndef __EF0101_H #ifndef __EF0101_H
#define __EF0101_H #define __EF0101_H
#ifndef __RECARRAY_H #ifndef __RECARRAY_H
#include <recarray.h> #include <recarray.h>
#endif #endif
#include <effetti.h> #include <effetti.h>
#include <reffetti.h> #include <reffetti.h>
#include <cession.h> #include <cession.h>
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
// Definizione dell'oggetto Effetto con la classe TEffetto// // Definizione dell'oggetto Effetto con la classe TEffetto//
//////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////
class TEffetto:public TRectype class TEffetto:public TRectype
{ {
TRecord_array _righe;// righe dell'effetto TRecord_array _righe;// righe dell'effetto
TRecord_array _cess;// cessionari dell'effetto TRecord_array _cess;// cessionari dell'effetto
protected: protected:
// ritorna la prossima chiave // ritorna la prossima chiave
long get_next_key(const long codcf) const; long get_next_key(const long codcf) const;
// permette di leggere il record passato nel file passato // permette di leggere il record passato nel file passato
int leggi(TLocalisamfile& f, const TRectype& rec, word lockop = _nolock); int leggi(TLocalisamfile& f, const TRectype& rec, word lockop = _nolock);
public: public:
// Duplica l'effetto // Duplica l'effetto
virtual TObject* dup() const; virtual TObject* dup() const;
// rinumera la chiave 1 // rinumera la chiave 1
long renum(long numeff = 0); long renum(long numeff = 0);
// ritorna un riferimento alla testata dell'effetto // ritorna un riferimento alla testata dell'effetto
const TRectype& head() const { return *this; } const TRectype& head() const { return *this; }
// ritorna un riferimento alla testata dell'effetto // ritorna un riferimento alla testata dell'effetto
TRectype& head() { return *this; } TRectype& head() { return *this; }
// ritorna un riferimento alle righe dell'effetto // ritorna un riferimento alle righe dell'effetto
TRecord_array& righe() {return _righe;} TRecord_array& righe() {return _righe;}
// ritorna un riferimento ai cessionari dell'effetto // ritorna un riferimento ai cessionari dell'effetto
TRecord_array& cess() {return _cess;} TRecord_array& cess() {return _cess;}
// ritorna la riga i_esima dei cessionari // ritorna la riga i_esima dei cessionari
TRectype& row_c(int i, bool create=FALSE) { return _cess.row(i,create); } TRectype& row_c(int i, bool create=FALSE) { return _cess.row(i,create); }
// ritorna la riga i delle righe // ritorna la riga i delle righe
TRectype& row_r(int i, bool create=FALSE) { return _righe.row(i,create); } TRectype& row_r(int i, bool create=FALSE) { return _righe.row(i,create); }
// ritorna la riga i delle righe // ritorna la riga i delle righe
const TRectype& row_r(int i) const { return _righe.row(i); } const TRectype& row_r(int i) const { return _righe.row(i); }
// ritorna il numero delle righe presenti nelle righe effetto // ritorna il numero delle righe presenti nelle righe effetto
int rows_r() const { return _righe.rows(); } int rows_r() const { return _righe.rows(); }
// ritorna il numero delle righe presenti nei cessionari // ritorna il numero delle righe presenti nei cessionari
int rows_c() const { return _cess.rows(); } int rows_c() const { return _cess.rows(); }
// elimina l'elemento riga nella posizione n nelle righe effetto // elimina l'elemento riga nella posizione n nelle righe effetto
bool destroy_row_r(int n, bool pack = FALSE) { return _righe.destroy_row(n, pack); } bool destroy_row_r(int n, bool pack = FALSE) { return _righe.destroy_row(n, pack); }
// elimina tutti gli elementi riga nelle righe effetto // elimina tutti gli elementi riga nelle righe effetto
void destroy_rows_r() { _righe.destroy_rows(); } void destroy_rows_r() { _righe.destroy_rows(); }
// elimina l'elemento riga nella posizione n nei cessionari // elimina l'elemento riga nella posizione n nei cessionari
bool destroy_row_c(int n, bool pack = FALSE) { return _cess.destroy_row(n, pack); } bool destroy_row_c(int n, bool pack = FALSE) { return _cess.destroy_row(n, pack); }
// elimina tutti gli elementi riga nei cessionari // elimina tutti gli elementi riga nei cessionari
void destroy_rows_c() { _cess.destroy_rows(); } void destroy_rows_c() { _cess.destroy_rows(); }
// restituisce il prossimo effetto // restituisce il prossimo effetto
int next(TBaseisamfile& f); int next(TBaseisamfile& f);
// legge il record passato, con chiave 1 // legge il record passato, con chiave 1
int read(TLocalisamfile& f, const TRectype& rec, word lockop = _nolock); int read(TLocalisamfile& f, const TRectype& rec, word lockop = _nolock);
// legge il record passato, con chiave 4 // legge il record passato, con chiave 4
int read(TLocalisamfile& f, char tipodist, long ndist, int nrigadist, word lockop = _nolock); int read(TLocalisamfile& f, char tipodist, long ndist, int nrigadist, word lockop = _nolock);
// scrive l'effetto, sempre usando la chiave 1 // scrive l'effetto, sempre usando la chiave 1
int write(TLocalisamfile& f, bool force = FALSE); int write(TLocalisamfile& f, bool force = FALSE);
// riscrive l'effetto // riscrive l'effetto
int rewrite(TLocalisamfile& f) { return write(f, TRUE); } int rewrite(TLocalisamfile& f) { return write(f, TRUE); }
// rimuove l'effetto // rimuove l'effetto
int remove(TLocalisamfile& f) const; int remove(TLocalisamfile& f) const;
// restituisce il numero progressivo dell'effetto estraendolo dal record // restituisce il numero progressivo dell'effetto estraendolo dal record
long numero() const { return get_long(EFF_NPROGTR); } long numero() const { return get_long(EFF_NPROGTR); }
// restituisce il codice del cliente intestatario dell'effetto estraendolo dal record // restituisce il codice del cliente intestatario dell'effetto estraendolo dal record
long codicec() const { return get_long(EFF_CODCF); } long codicec() const { return get_long(EFF_CODCF); }
// restituisce la data di scadenza dell'effetto estraendola dal record // restituisce la data di scadenza dell'effetto estraendola dal record
TDate datasc() const { return get_date(EFF_DATASCAD); } TDate datasc() const { return get_date(EFF_DATASCAD); }
// restituisce il tipo di distinta a cui appartiene l'effetto estraendolo dal record // restituisce il tipo di distinta a cui appartiene l'effetto estraendolo dal record
char tipodist() const { return get_char(EFF_TIPODIST); } char tipodist() const { return get_char(EFF_TIPODIST); }
// restituisce il numero della distinta a cui appartiene l'effetto estraendolo dal record // restituisce il numero della distinta a cui appartiene l'effetto estraendolo dal record
long ndist() const { return get_long(EFF_NDIST); } long ndist() const { return get_long(EFF_NDIST); }
// restituisce il numero della riga distinta a cui appartiene l'effetto estraendolo dal record // restituisce il numero della riga distinta a cui appartiene l'effetto estraendolo dal record
int nrgdist() const { return get_int(EFF_NRIGADIST); } int nrgdist() const { return get_int(EFF_NRIGADIST); }
// restituisce l'importo dell'effetto // restituisce l'importo dell'effetto
real importo(const bool valuta = FALSE) const { return get_real(valuta ? EFF_IMPORTOVAL : EFF_IMPORTO); } real importo(const bool valuta = FALSE) const { return get_real(valuta ? EFF_IMPORTOVAL : EFF_IMPORTO); }
const bool in_valuta() const; const bool in_valuta() const;
const char get_tipo() const ; const char get_tipo() const ;
// setta i campi per la quarta chiave del file // setta i campi per la quarta chiave del file
void put_key(TRectype& rec,char tipodist, long ndist, int nrigadist = 0); void put_key(TRectype& rec,char tipodist, long ndist, int nrigadist = 0);
// setta i campi per la prima chiave del file // setta i campi per la prima chiave del file
void put_key(TRectype& rec,long numeff) const; void put_key(TRectype& rec,long numeff) const;
// restituisce true se l'effetto si riferisce ad una sola fattura // restituisce true se l'effetto si riferisce ad una sola fattura
bool fatt(long num); bool fatt() const;
// restituisce i dati relativi alle fatture a cui si riferisce l'effetto // restituisce i dati relativi alle fatture a cui si riferisce l'effetto
TToken_string& dati_fatt(long num, const bool valuta, TToken_string& dati); TToken_string& dati_fatt(long num, const bool valuta, TToken_string& dati);
// restituisce i dati codnum, ndoc, anno relativi alle fatture a cui si riferisce l'effetto // restituisce i dati codnum, ndoc, anno relativi alle fatture a cui si riferisce l'effetto
TToken_string& altridati_fatt(long num, TToken_string& dati); TToken_string& altridati_fatt(long num, TToken_string& dati);
// costruttore di default // costruttore di default
TEffetto(); TEffetto();
// costuisce l'effetto con il record passato // costuisce l'effetto con il record passato
TEffetto(const TRectype& rec); TEffetto(const TRectype& rec);
// costuttore di copia // costuttore di copia
TEffetto(const TEffetto& eff); TEffetto(const TEffetto& eff);
// distruttore di default // distruttore di default
virtual ~TEffetto() {} virtual ~TEffetto() {}
}; };
#endif//__EF0101_H #endif//__EF0101_H

File diff suppressed because it is too large Load Diff

View File

@ -1,222 +1,243 @@
#include <applicat.h> #include <applicat.h>
#include <msksheet.h> #include <msksheet.h>
#include <relation.h> #include <progind.h>
#include <recset.h>
#include "ef0.h" #include <relation.h>
#include "ef0101.h"
#include "ef0400.h" #include "ef0.h"
#include "ef0101.h"
///////////////////////////////////////////////////////////////////////////// #include "ef0400.h"
//Classe per l'eliminazione di effetti di effetti con selezione per gruppi //
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
class TEliminazione_effetti: public TSkeleton_application //Classe per l'eliminazione di effetti di effetti con selezione per gruppi //
{ /////////////////////////////////////////////////////////////////////////////
TMask *_msk; class TEliminazione_effetti: public TSkeleton_application
TRelation *_rel; {
TRectype *_from, *_to; TMask *_msk;
virtual bool create() ; TRelation *_rel;
virtual bool destroy() ; TRectype *_from, *_to;
virtual void main_loop(); virtual bool create() ;
protected: virtual bool destroy() ;
static bool from_numero_handler(TMask_field& f, KEY k); virtual void main_loop();
static bool to_numero_handler(TMask_field& f, KEY k); protected:
static bool from_data_handler(TMask_field& f, KEY k); static bool from_numero_handler(TMask_field& f, KEY k);
static bool to_data_handler(TMask_field& f, KEY k); static bool to_numero_handler(TMask_field& f, KEY k);
static bool conferma_handler(TMask_field& f, KEY k); static bool from_data_handler(TMask_field& f, KEY k);
static bool annulla_handler(TMask_field& f, KEY k); static bool to_data_handler(TMask_field& f, KEY k);
static void elimina(); static bool conferma_handler(TMask_field& f, KEY k);
public: static bool annulla_handler(TMask_field& f, KEY k);
TEliminazione_effetti() {}; static void elimina();
virtual ~TEliminazione_effetti() {}; static void elimina_orfani(const TRectype* from);
}; };
// restituisce un riferimento all' applicazione // restituisce un riferimento all' applicazione
inline TEliminazione_effetti& app(){return (TEliminazione_effetti&)main_app();} inline TEliminazione_effetti& app(){return (TEliminazione_effetti&)main_app();}
// crea l'applicazione // crea l'applicazione
bool TEliminazione_effetti::create() bool TEliminazione_effetti::create()
{ {
_msk = new TMask("ef0400a"); _msk = new TMask("ef0400a");
_rel = new TRelation(LF_EFFETTI); _rel = new TRelation(LF_EFFETTI);
_rel->first(); _rel->first();
_from = new TRectype(_rel->lfile().curr()); _from = new TRectype(_rel->lfile().curr());
_rel->last(); _rel->last();
_to = new TRectype(_rel->lfile().curr()); _to = new TRectype(_rel->lfile().curr());
_msk->set_handler(F_DA_RIBA, from_numero_handler); _msk->set_handler(F_DA_RIBA, from_numero_handler);
_msk->set_handler(F_A_RIBA, to_numero_handler); _msk->set_handler(F_A_RIBA, to_numero_handler);
_msk->set_handler(F_DA_DATA, from_data_handler); _msk->set_handler(F_DA_DATA, from_data_handler);
_msk->set_handler(F_A_DATA, to_data_handler); _msk->set_handler(F_A_DATA, to_data_handler);
_msk->set_handler(DLG_OK, conferma_handler); _msk->set_handler(DLG_OK, conferma_handler);
_msk->set_handler(DLG_CANCEL, annulla_handler); _msk->set_handler(DLG_CANCEL, annulla_handler);
return TSkeleton_application::create(); return TSkeleton_application::create();
} }
// distrugge l'applicazione // distrugge l'applicazione
bool TEliminazione_effetti::destroy() bool TEliminazione_effetti::destroy()
{ {
delete _msk; delete _msk;
delete _rel; delete _rel;
delete _from; delete _from;
delete _to; delete _to;
return TRUE; return TRUE;
} }
//Carica maschera eliminazione effetti //Carica maschera eliminazione effetti
void TEliminazione_effetti::main_loop() void TEliminazione_effetti::main_loop()
{ {
KEY key = K_ENTER; KEY key = K_ENTER;
while (key != K_QUIT)//finchè non si chiude la maschera while (key != K_QUIT)//finchè non si chiude la maschera
{ {
_msk->reset(); _msk->reset();
key = _msk->run(); key = _msk->run();
} }
} }
//Handler per la gestione della prima chiave (from) del cursore per numero //Handler per la gestione della prima chiave (from) del cursore per numero
bool TEliminazione_effetti::from_numero_handler(TMask_field& f, KEY k) bool TEliminazione_effetti::from_numero_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); TMask &m = f.mask();
if (k == K_TAB) if (k == K_TAB)
{ {
if (!f.get().empty())// se il campo non è vuoto if (!f.get().empty())// se il campo non è vuoto
{ {
TRectype* from = app()._from; TRectype* from = app()._from;
long num = m.get_long(F_DA_RIBA); long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num); from->put(EFF_NPROGTR, num);
} }
} }
return TRUE; return TRUE;
} }
//Handler per la gestione della seconda chiave (to) del cursore per numero //Handler per la gestione della seconda chiave (to) del cursore per numero
bool TEliminazione_effetti::to_numero_handler(TMask_field& f, KEY k) bool TEliminazione_effetti::to_numero_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); TMask &m = f.mask();
if (k == K_TAB) if (k == K_TAB)
{ {
if (!f.get().empty())// se il campo non è vuoto if (!f.get().empty())// se il campo non è vuoto
{ {
TRectype* to = app()._to; TRectype* to = app()._to;
long num = m.get_long(F_A_RIBA); long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num); to->put(EFF_NPROGTR, num);
} }
} }
return TRUE; return TRUE;
} }
//Handler per la gestione della prima chiave (from) del cursore per data //Handler per la gestione della prima chiave (from) del cursore per data
bool TEliminazione_effetti::from_data_handler(TMask_field& f, KEY k) bool TEliminazione_effetti::from_data_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); TMask &m = f.mask();
if (k == K_TAB) if (k == K_TAB)
{ {
if (!f.get().empty())// se il campo non è vuoto if (!f.get().empty())// se il campo non è vuoto
{ {
TRectype* from = app()._from; TRectype* from = app()._from;
TDate data = m.get(F_DA_DATA); TDate data = m.get(F_DA_DATA);
long num = m.get_long(F_DA_RIBA); long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num); from->put(EFF_NPROGTR, num);
from->put(EFF_DATASCAD, data); from->put(EFF_DATASCAD, data);
} }
} }
return TRUE; return TRUE;
} }
//Handler per la gestione della seconda chiave (to) del cursore per numero //Handler per la gestione della seconda chiave (to) del cursore per numero
bool TEliminazione_effetti::to_data_handler(TMask_field& f, KEY k) bool TEliminazione_effetti::to_data_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); TMask &m = f.mask();
if (k == K_TAB) if (k == K_TAB)
{ {
if (!f.get().empty())// se il campo non è vuoto if (!f.get().empty())// se il campo non è vuoto
{ {
TRectype* to = app()._to; TRectype* to = app()._to;
TDate data = m.get(F_A_DATA); TDate data = m.get(F_A_DATA);
long num = m.get_long(F_A_RIBA); long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num); to->put(EFF_NPROGTR, num);
to->put(EFF_DATASCAD, data); to->put(EFF_DATASCAD, data);
} }
} }
return TRUE; return TRUE;
} }
// Si effettua l'istanziazione del cursore e si eliminano gli effetti che vi void TEliminazione_effetti::elimina_orfani(const TRectype* from)
// appartengono {
void TEliminazione_effetti::elimina() TString query = "USE REFFETTI SELECT 31.NPROGTR=0\nJOIN 31 INTO NPROGTR==NPROGTR\n";
{ if (from && !from->empty())
const TRectype *from = app()._from; query << "\nFROM NPROGTR=" << from->get("NPROGTR");
const TRectype *to = app()._to; TISAM_recordset orfani(query);
TMask *m = app()._msk; TLocalisamfile& f = orfani.cursor()->file();
TRelation *rel = app()._rel; for (bool ok = orfani.move_first(); ok; ok = orfani.move_next())
TString filter; f.remove();
}
int key;
char op1 = m->get(F_TIPOSEL)[0]; // Si effettua l'istanziazione del cursore e si eliminano gli effetti che vi
char op2 = m->get(F_TIPODIST)[0]; // appartengono
char op3 = m->get(F_TIPOCANC)[0]; void TEliminazione_effetti::elimina()
switch (op1) //scelgo la chiave per il cursore {
{ const TRectype *from = app()._from;
case 'N': //selezione effetti per numero const TRectype *to = app()._to;
key = 1; TMask *m = app()._msk;
break; TRelation *rel = app()._rel;
case 'D': //selezione effetti per data TString filter;
key = 3;
break; int key;
} char op1 = m->get(F_TIPOSEL)[0];
//scelgo il filtro per il cursore char op2 = m->get(F_TIPODIST)[0];
filter << "(TIPOCF=\"" << op2 << "\")"; char op3 = m->get(F_TIPOCANC)[0];
if (op2 == 'C') switch (op1) //scelgo la chiave per il cursore
filter << "||(TIPOCF=\"\")"; {
switch (op3) case 'N': //selezione effetti per numero
{ key = 1;
case 'S': //cancello effetti stampati break;
filter << "&&(EFFSTAMP=\"X\")"; case 'D': //selezione effetti per data
break; key = 3;
case 'C': //cancello effetti contabilizzati break;
filter << "&&(EFFCONT=\"X\")"; }
break; //scelgo il filtro per il cursore
default : //cancello tutti gli effetti filter << "(TIPOCF=\"" << op2 << "\")";
break; if (op2 == 'C')
} filter << "||(TIPOCF=\"\")";
TCursor cur(rel,filter,key,from,to); // istanzio il cursore switch (op3)
TLocalisamfile& delfile = cur.file();// prendo un riferimento al file {
long n = cur.items();// prendo il numero di elementi del cursore case 'S': //cancello effetti stampati
cur.freeze();// congelo lo stato del cursore filter << "&&(EFFSTAMP=\"X\")";
for (cur=0; cur.pos() < n; ++cur)// scandisco tutti gli elementi del cursore break;
{ case 'C': //cancello effetti contabilizzati
TEffetto eff(delfile.curr());// istanzio un effetto filter << "&&(EFFCONT=\"X\")";
eff.remove(delfile); // e lo cancello break;
} default : //cancello tutti gli effetti
} break;
}
//Handler per gestire la conferma della cancellazione degli effetti
bool TEliminazione_effetti::conferma_handler(TMask_field& f, KEY k) TCursor cur(rel,filter,key,from,to); // istanzio il cursore
{ const long n = cur.items();// prendo il numero di elementi del cursore
TMask &m = f.mask();
if (k == K_SPACE) if (n > 0)
{ {
if (yesno_box(TR("Si desidera veramente eliminare gli effetti selezionati"))) if (noyes_box(TR("Si desidera veramente eliminare %ld effetti?"), n))
elimina(); {
} TLocalisamfile& delfile = cur.file();// prendo un riferimento al file
return TRUE; cur.freeze();// congelo lo stato del cursore
} TProgind pi(n, main_app().title());
for (cur=0; cur.pos() < n; ++cur)// scandisco tutti gli elementi del cursore
// Handler per gestire la conferma dell'annullamento dei dati {
// inseriti nella maschera if (!pi.addstatus(1))
bool TEliminazione_effetti::annulla_handler(TMask_field& f, KEY k) break;
{ TEffetto eff(delfile.curr());// istanzio un effetto
TMask &m = f.mask(); eff.remove(delfile); // e lo cancello
if (k == K_SPACE) }
{ elimina_orfani(from);
if (yesno_box(TR("Si desidera veramente annullare i dati inseriti"))) }
m.reset(); }
} else
return TRUE; warning_box(TR("Non sono stati selezionati effetti da eliminare"));
} }
int ef0400(int argc, char* argv[]) //Handler per gestire la conferma della cancellazione degli effetti
{ bool TEliminazione_effetti::conferma_handler(TMask_field& f, KEY k)
TEliminazione_effetti a ; {
a.run(argc, argv, TR("Eliminazione Effetti")); if (k == K_SPACE)
return 0; elimina();
} return true;
}
// Handler per gestire la conferma dell'annullamento dei dati
// inseriti nella maschera
bool TEliminazione_effetti::annulla_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_SPACE)
{
if (yesno_box(TR("Si desidera veramente annullare i dati inseriti")))
m.reset();
}
return TRUE;
}
int ef0400(int argc, char* argv[])
{
TEliminazione_effetti a;
a.run(argc, argv, TR("Eliminazione Effetti"));
return 0;
}

View File

@ -1,121 +1,121 @@
// DEFINIZIONE MASCHERA PER LA ELIMINAZIONE DEGLI EFFETTI // DEFINIZIONE MASCHERA PER LA ELIMINAZIONE DEGLI EFFETTI
#include "ef0400.h" #include "ef0400.h"
TOOLBAR "topbar" 0 0 0 2 TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_OK 9 2 BUTTON DLG_OK 9 2
BEGIN BEGIN
PROMPT -13 -1 "" PROMPT -13 -1 ""
END END
BUTTON DLG_CANCEL 9 2 BUTTON DLG_CANCEL 9 2
BEGIN BEGIN
PROMPT -23 -1 "" PROMPT -23 -1 ""
END END
#include <helpbar.h> #include <helpbar.h>
ENDPAGE ENDPAGE
PAGE "Eliminazione Effetti" 0 2 0 0 PAGE "Eliminazione Effetti" 0 2 0 0
LIST F_TIPOSEL 20 LIST F_TIPOSEL 20
BEGIN BEGIN
PROMPT 2 1 "Tipo Selezione " PROMPT 2 1 "Tipo Selezione "
ITEM "N|Numero progressivo" ITEM "N|Numero progressivo"
MESSAGE DISABLE,2@ MESSAGE DISABLE,2@
MESSAGE ENABLE,1@ MESSAGE ENABLE,1@
ITEM "D|Data scadenza" ITEM "D|Data scadenza"
MESSAGE DISABLE,1@ MESSAGE DISABLE,1@
MESSAGE ENABLE,2@ MESSAGE ENABLE,2@
END END
LIST F_TIPODIST 20 LIST F_TIPODIST 20
BEGIN BEGIN
PROMPT 2 2 "Tipo Effetti " PROMPT 2 2 "Tipo Effetti "
ITEM "C|Attivi" ITEM "C|Attivi"
ITEM "F|Passivi" ITEM "F|Passivi"
END END
LIST F_TIPOCANC 20 LIST F_TIPOCANC 20
BEGIN BEGIN
PROMPT 2 3 "Tipo Cancellazione " PROMPT 2 3 "Tipo Cancellazione "
ITEM "T|Tutti" ITEM "T|Tutti"
ITEM "S|Stampati" ITEM "S|Stampati"
ITEM "C|Contabilizzati" ITEM "C|Contabilizzati"
END END
GROUPBOX DLG_NULL 55 3 GROUPBOX DLG_NULL 55 3
BEGIN BEGIN
PROMPT 1 5 "Selezione effetti per numero progressivo" PROMPT 1 5 "Selezione effetti per numero progressivo"
GROUP 1 GROUP 1
END END
NUMBER F_DA_RIBA 7 0 NUMBER F_DA_RIBA 7 0
BEGIN BEGIN
PROMPT 2 6 "Dalla Riba " PROMPT 2 6 "Dalla Riba "
GROUP 1 GROUP 1
FIELD LF_EFFETTI->NPROGTR FIELD LF_EFFETTI->NPROGTR
USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C")) USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT NPROGTR F_DA_RIBA INPUT NPROGTR F_DA_RIBA
DISPLAY "Nr. progressivo" NPROGTR DISPLAY "Nr. progressivo" NPROGTR
DISPLAY "Data scadenza" DATASCAD DISPLAY "Data scadenza" DATASCAD
OUTPUT F_DA_RIBA NPROGTR OUTPUT F_DA_RIBA NPROGTR
// CHECKTYPE NORMAL // CHECKTYPE NORMAL
END END
NUMBER F_A_RIBA 7 0 NUMBER F_A_RIBA 7 0
BEGIN BEGIN
PROMPT 30 6 "Alla Riba " PROMPT 30 6 "Alla Riba "
GROUP 1 GROUP 1
FIELD LF_EFFETTI->NPROGTR FIELD LF_EFFETTI->NPROGTR
USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C")) USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT NPROGTR F_A_RIBA INPUT NPROGTR F_A_RIBA
DISPLAY "Nr. progressivo" NPROGTR DISPLAY "Nr. progressivo" NPROGTR
DISPLAY "Data scadenza" DATASCAD DISPLAY "Data scadenza" DATASCAD
OUTPUT F_A_RIBA NPROGTR OUTPUT F_A_RIBA NPROGTR
// CHECKTYPE NORMAL // CHECKTYPE NORMAL
NUM_EXPR {#THIS_FIELD>=#F_DA_RIBA} NUM_EXPR (#THIS_FIELD==0)||(#THIS_FIELD>=#F_DA_RIBA)
WARNING "Limite superiore non valido" WARNING "Limite superiore non valido"
END END
GROUPBOX DLG_NULL 55 3 GROUPBOX DLG_NULL 55 3
BEGIN BEGIN
PROMPT 1 9 "Selezione effetti per data scadenza" PROMPT 1 9 "Selezione effetti per data scadenza"
GROUP 2 GROUP 2
END END
DATA F_DA_DATA DATA F_DA_DATA
BEGIN BEGIN
PROMPT 2 10 "Dalla Data " PROMPT 2 10 "Dalla Data "
GROUP 2 GROUP 2
FIELD LF_EFFETTI->DATASCAD FIELD LF_EFFETTI->DATASCAD
USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C")) USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT DATASCAD F_DA_DATA INPUT DATASCAD F_DA_DATA
DISPLAY "Data scadenza" DATASCAD DISPLAY "Data scadenza" DATASCAD
DISPLAY "Nr. progressivo" NPROGTR DISPLAY "Nr. progressivo" NPROGTR
OUTPUT F_DA_DATA DATASCAD OUTPUT F_DA_DATA DATASCAD
OUTPUT F_DA_RIBA NPROGTR OUTPUT F_DA_RIBA NPROGTR
//CHECKTYPE NORMAL //CHECKTYPE NORMAL
END END
DATA F_A_DATA DATA F_A_DATA
BEGIN BEGIN
PROMPT 30 10 "Alla Data " PROMPT 30 10 "Alla Data "
GROUP 2 GROUP 2
FIELD LF_EFFETTI->DATASCAD FIELD LF_EFFETTI->DATASCAD
USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C")) USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT DATASCAD F_A_DATA INPUT DATASCAD F_A_DATA
DISPLAY "Data scadenza" DATASCAD DISPLAY "Data scadenza" DATASCAD
DISPLAY "Nr. progressivo" NPROGTR DISPLAY "Nr. progressivo" NPROGTR
OUTPUT F_A_DATA DATASCAD OUTPUT F_A_DATA DATASCAD
OUTPUT F_A_RIBA NPROGTR OUTPUT F_A_RIBA NPROGTR
//CHECKTYPE NORMAL //CHECKTYPE NORMAL
VALIDATE DATE_CMP_FUNC >= F_DA_DATA VALIDATE DATE_CMP_FUNC >= F_DA_DATA
WARNING "Data limite superiore non valida" WARNING "Data limite superiore non valida"
END END
ENDPAGE ENDPAGE
ENDMASK ENDMASK

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,105 +1,105 @@
#ifndef __DOC_H #ifndef __DOC_H
#define __DOC_H #define __DOC_H
#define DOC_CODNUM "CODNUM" #define DOC_CODNUM "CODNUM"
#define DOC_ANNO "ANNO" #define DOC_ANNO "ANNO"
#define DOC_PROVV "PROVV" #define DOC_PROVV "PROVV"
#define DOC_NDOC "NDOC" #define DOC_NDOC "NDOC"
#define DOC_TIPODOC "TIPODOC" #define DOC_TIPODOC "TIPODOC"
#define DOC_STATO "STATO" #define DOC_STATO "STATO"
#define DOC_DATADOC "DATADOC" #define DOC_DATADOC "DATADOC"
#define DOC_TIPOCF "TIPOCF" #define DOC_TIPOCF "TIPOCF"
#define DOC_CODCF "CODCF" #define DOC_CODCF "CODCF"
#define DOC_OCFPI "OCFPI" #define DOC_OCFPI "OCFPI"
#define DOC_OCCAS "OCCAS" #define DOC_OCCAS "OCCAS"
#define DOC_CODVAL "CODVAL" #define DOC_CODVAL "CODVAL"
#define DOC_CONTROEURO "CONTROEURO" #define DOC_CONTROEURO "CONTROEURO"
#define DOC_CAMBIO "CAMBIO" #define DOC_CAMBIO "CAMBIO"
#define DOC_DATACAMBIO "DATACAMBIO" #define DOC_DATACAMBIO "DATACAMBIO"
#define DOC_CODLIN "CODLIN" #define DOC_CODLIN "CODLIN"
#define DOC_RAGGR "RAGGR" #define DOC_RAGGR "RAGGR"
#define DOC_CODPAG "CODPAG" #define DOC_CODPAG "CODPAG"
#define DOC_DATAINSC "DATAINSC" #define DOC_DATAINSC "DATAINSC"
#define DOC_CODABIA "CODABIA" #define DOC_CODABIA "CODABIA"
#define DOC_CODCABA "CODCABA" #define DOC_CODCABA "CODCABA"
#define DOC_IBAN "IBAN" #define DOC_IBAN "IBAN"
#define DOC_CODABIP "CODABIP" #define DOC_CODABIP "CODABIP"
#define DOC_CODCABP "CODCABP" #define DOC_CODCABP "CODCABP"
#define DOC_PROGBNP "PROGBNP" #define DOC_PROGBNP "PROGBNP"
#define DOC_CATVEN "CATVEN" #define DOC_CATVEN "CATVEN"
#define DOC_CODLIST "CODLIST" #define DOC_CODLIST "CODLIST"
#define DOC_CODCONT "CODCONT" #define DOC_CODCONT "CODCONT"
#define DOC_CODCAMP "CODCAMP" #define DOC_CODCAMP "CODCAMP"
#define DOC_SCONTOPERC "SCONTOPERC" #define DOC_SCONTOPERC "SCONTOPERC"
#define DOC_CODINDSP "CODINDSP" #define DOC_CODINDSP "CODINDSP"
#define DOC_DATADOCRIF "DATADOCRIF" #define DOC_DATADOCRIF "DATADOCRIF"
#define DOC_NUMDOCRIF "NUMDOCRIF" #define DOC_NUMDOCRIF "NUMDOCRIF"
#define DOC_ZONA "ZONA" #define DOC_ZONA "ZONA"
#define DOC_CODAG "CODAG" #define DOC_CODAG "CODAG"
#define DOC_CODAGVIS "CODAGVIS" #define DOC_CODAGVIS "CODAGVIS"
#define DOC_CODSPMEZZO "CODSPMEZZO" #define DOC_CODSPMEZZO "CODSPMEZZO"
#define DOC_CODPORTO "CODPORTO" #define DOC_CODPORTO "CODPORTO"
#define DOC_CODNOTESP1 "CODNOTESP1" #define DOC_CODNOTESP1 "CODNOTESP1"
#define DOC_CODNOTESP2 "CODNOTESP2" #define DOC_CODNOTESP2 "CODNOTESP2"
#define DOC_CAUSTRASP "CAUSTRASP" #define DOC_CAUSTRASP "CAUSTRASP"
#define DOC_CODVETT1 "CODVETT1" #define DOC_CODVETT1 "CODVETT1"
#define DOC_CODVETT2 "CODVETT2" #define DOC_CODVETT2 "CODVETT2"
#define DOC_CODVETT3 "CODVETT3" #define DOC_CODVETT3 "CODVETT3"
#define DOC_NCOPIE "NCOPIE" #define DOC_NCOPIE "NCOPIE"
#define DOC_DATAPART "DATAPART" #define DOC_DATAPART "DATAPART"
#define DOC_ORAPART "ORAPART" #define DOC_ORAPART "ORAPART"
#define DOC_IMPPAGATO "IMPPAGATO" #define DOC_IMPPAGATO "IMPPAGATO"
#define DOC_ACCSALDO "ACCSALDO" #define DOC_ACCSALDO "ACCSALDO"
#define DOC_DOC1 "DOC1" #define DOC_DOC1 "DOC1"
#define DOC_DOC2 "DOC2" #define DOC_DOC2 "DOC2"
#define DOC_DOC3 "DOC3" #define DOC_DOC3 "DOC3"
#define DOC_DATACONS "DATACONS" #define DOC_DATACONS "DATACONS"
#define DOC_ASPBENI1 "ASPBENI1" #define DOC_ASPBENI1 "ASPBENI1"
#define DOC_ASPBENI2 "ASPBENI2" #define DOC_ASPBENI2 "ASPBENI2"
#define DOC_IMPNETTI "IMPNETTI" #define DOC_IMPNETTI "IMPNETTI"
#define DOC_RAGGREFF "RAGGREFF" #define DOC_RAGGREFF "RAGGREFF"
#define DOC_PERCSPINC "PERCSPINC" #define DOC_PERCSPINC "PERCSPINC"
#define DOC_ADDBOLLI "ADDBOLLI" #define DOC_ADDBOLLI "ADDBOLLI"
#define DOC_UMTARA "UMTARA" #define DOC_UMTARA "UMTARA"
#define DOC_TARA "TARA" #define DOC_TARA "TARA"
#define DOC_UMPNETTO "UMPNETTO" #define DOC_UMPNETTO "UMPNETTO"
#define DOC_PNETTO "PNETTO" #define DOC_PNETTO "PNETTO"
#define DOC_NCOLLI "NCOLLI" #define DOC_NCOLLI "NCOLLI"
#define DOC_CAUSMAG "CAUSMAG" #define DOC_CAUSMAG "CAUSMAG"
#define DOC_MOVMAG "MOVMAG" #define DOC_MOVMAG "MOVMAG"
#define DOC_CODNOTE "CODNOTE" #define DOC_CODNOTE "CODNOTE"
#define DOC_NOTE "NOTE" #define DOC_NOTE "NOTE"
#define DOC_G1 "G1" #define DOC_G1 "G1"
#define DOC_DATAAGG "DATAAGG" #define DOC_DATAAGG "DATAAGG"
#define DOC_UTENTE "UTENTE" #define DOC_UTENTE "UTENTE"
#define DOC_DOCEVASO "DOCEVASO" #define DOC_DOCEVASO "DOCEVASO"
#define DOC_CONTROEURO "CONTROEURO" #define DOC_CONTROEURO "CONTROEURO"
#define DOC_CODCMS "CODCMS" #define DOC_CODCMS "CODCMS"
#define DOC_FASCMS "FASCMS" #define DOC_FASCMS "FASCMS"
#define DOC_CODCOSTO "CODCOSTO" #define DOC_CODCOSTO "CODCOSTO"
#define DOC_NUMREG "NUMREG" #define DOC_NUMREG "NUMREG"
#define DOC_NUMANT "NUMANT" #define DOC_NUMANT "NUMANT"
#define DOC_NUMREGCA "NUMREGCA" #define DOC_NUMREGCA "NUMREGCA"
#define DOC_TIPOCFFATT "TIPOCFFATT" #define DOC_TIPOCFFATT "TIPOCFFATT"
#define DOC_CODCFFATT "CODCFFATT" #define DOC_CODCFFATT "CODCFFATT"
#define DOC_LIQDIFF "LIQDIFF" #define DOC_LIQDIFF "LIQDIFF"
#define DOC_DATACOMP "DATACOMP" #define DOC_DATACOMP "DATACOMP"
#define DOC_DATAFCOMP "DATAFCOMP" #define DOC_DATAFCOMP "DATAFCOMP"
#define DOC_CUP "CUP" #define DOC_CUP "CUP"
#define DOC_CIG "CIG" #define DOC_CIG "CIG"
#define DOC_CONTRATTO "CONTRATTO" #define DOC_CONTRATTO "CONTRATTO"
#define DOC_MODPAG "MODPAG" #define DOC_MODPAG "MODPAG"
#define DOC_CONTSEP "CONTSEP" #define DOC_CONTSEP "CONTSEP"
#define DOC_CONTRATTO "CONTRATTO" #define DOC_CONTRATTO "CONTRATTO"
#define DOC_MODPAG "MODPAG" #define DOC_MODPAG "MODPAG"
// Virtuali // Virtuali
// modulo pe // modulo pe
#define DOC_SPESEUPD "SPESEUPD" #define DOC_SPESEUPD "SPESEUPD"
#define DOC_USEK "USEK" #define DOC_USEK "USEK"
#define DOC_K "K" #define DOC_K "K"
#endif #endif

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,294 +1,358 @@
#include "sc0300a.h" #include "sc0300a.h"
#include "../cg/cgsalda3.h" #include "../cg/cgsalda3.h"
#include <applicat.h> #include <applicat.h>
#include <automask.h> #include <automask.h>
#include <recset.h> #include <progind.h>
#include <relation.h> #include <recset.h>
#include <treectrl.h> #include <relation.h>
#include <treectrl.h>
class TPareggio_tree : public TObject_tree
{ #include <mov.h>
protected:
virtual TFieldtypes get_var(const TString& name, TVariant& var) const; class TPareggio_tree : public TObject_tree
virtual bool marked() const { return rand() % 2 != 0; } {
TPartite_array _games;
public:
bool init(const TBill& bill, const TString& valuta, bool nc, int stato); // Stato- 1=aperte; 2=chiuse; 0 o 3 = tutte protected:
}; virtual TFieldtypes get_var(const TString& name, TVariant& var) const;
virtual bool marked() const { return rand() % 2 != 0; }
TFieldtypes TPareggio_tree::get_var(const TString& name, TVariant& var) const const TPartita& partita(const TRectype& rec) const;
{
TFieldtypes ft = _nullfld; public:
const TObject* obj = curr_node(); bool init(const TBill& bill, const TString& valuta, bool nc, int stato); // Stato- 1=aperte; 2=chiuse; 0 o 3 = tutte
if (obj != NULL) };
{
if (obj->is_kind_of(CLASS_RECTYPE)) const TPartita& TPareggio_tree::partita(const TRectype& rec) const
{ {
const TRectype& rec = *(const TRectype*)obj; return ((TPartite_array&)_games).partita(rec);
ft = rec.type(name); }
if (ft != _nullfld)
{ TFieldtypes TPareggio_tree::get_var(const TString& name, TVariant& var) const
if (ft == _realfld) {
{ TFieldtypes ft = _nullfld;
var = rec.get_real(name).stringa(0, 2); const TObject* obj = curr_node();
ft = _alfafld; if (obj != NULL)
} {
else if (obj->is_kind_of(CLASS_RECTYPE))
var = rec.get(name); {
} const TRectype& rec = *(const TRectype*)obj;
else ft = rec.type(name);
{ if (ft != _nullfld)
if (name == PART_DATADOC) {
{ if (ft == _realfld)
if (rec.num() == LF_SCADENZE) {
{ var = rec.get_real(name).stringa(0, 2);
var = rec.get_date(SCAD_DATASCAD); ft = _alfafld;
ft = _datefld; }
} else
} else var = rec.get(name);
if (name == "RESIDUO") }
{ else
TImporto saldo; {
switch (rec.num()) if (name.starts_with("PART.", true))
{ {
case LF_SCADENZE: const TString& fld = name.after(".");
if (!rec.get_bool(SCAD_PAGATA)) if (rec.num() == LF_SCADENZE)
{ {
const TPartita game(rec); const int nriga = rec.get_int(SCAD_NRIGA);
const TRiga_scadenze& s = game.rata(rec.get_int(SCAD_NRIGA), rec.get_int(SCAD_NRATA)); const TPartita& game = partita(rec);
saldo = s.residuo(true); var = game.riga(nriga).get(fld);
} ft = _alfafld;
break; }
case LF_PARTITE: else
if (!rec.get_bool(PART_CHIUSA)) {
{ var = rec.get(fld);
const TPartita game(rec); ft = _alfafld;
saldo = game.calcola_saldo(true); }
} } else
break; if (name == "RESIDUO")
default: {
break; TImporto saldo;
} switch (rec.num())
var = saldo.valore().stringa(0, 2); {
ft = _alfafld; case LF_SCADENZE:
} if (!rec.get_bool(SCAD_PAGATA))
} {
} const TPartita& game = partita(rec);
else const TRiga_scadenze& s = game.rata(rec.get_int(SCAD_NRIGA), rec.get_int(SCAD_NRATA));
{ saldo = s.residuo(true);
if (name == PART_NUMPART) }
{ break;
const real& year = *(real*)obj; case LF_PARTITE:
var = year.integer(); if (!rec.get_bool(PART_CHIUSA))
ft = _intfld; {
} const TPartita& game = partita(rec);
} saldo = game.calcola_saldo(true);
} }
return ft; break;
} default:
break;
}
bool TPareggio_tree::init(const TBill& bill, const TString& valuta, bool nc, int stato) var = saldo.valore().stringa(0, 2);
{ ft = _alfafld;
goto_root(); }
kill_node(); }
}
TString filter; else
if (bill.tipo() > ' ') {
filter << PART_TIPOCF << '=' << bill.tipo(); if (name == PART_NUMPART)
else {
{ const real& year = *(real*)obj;
filter << PART_GRUPPO << '=' << bill.gruppo() << ' '; var = year.integer();
filter << PART_CONTO << '=' << bill.conto(); ft = _intfld;
} }
filter << ' ' << PART_SOTTOCONTO << '=' << bill.sottoconto(); }
}
TString query; return ft;
query << "USE PART SELECT (NRIGA<9999)&&(TIPOMOV<=" << (nc ? tm_nota_credito : tm_fattura) << ')' }
<< "\nFROM " << filter << "\nTO " << filter;
TISAM_recordset games(query);
const TRectype& rec = games.cursor()->curr(); bool TPareggio_tree::init(const TBill& bill, const TString& valuta, bool nc, int stato)
{
int last_year = 0; goto_root();
TString80 id_year, id_rec; kill_node();
for (bool ok = games.move_first(); ok; ok = games.move_next()) TString filter;
{ if (bill.tipo() > ' ')
const TString& codval = rec.get(PART_CODVAL); filter << PART_TIPOCF << '=' << bill.tipo();
if (!same_values(codval, valuta)) else
continue; {
filter << PART_GRUPPO << '=' << bill.gruppo() << ' ';
const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV); filter << PART_CONTO << '=' << bill.conto();
bool add_riga = true; }
if (nc) filter << ' ' << PART_SOTTOCONTO << '=' << bill.sottoconto();
{
add_riga = !rec.get_bool(PART_CHIUSA); TString query;
// Se filtro le note di credito cerco di riconoscere le fatture negative query << "USE PART SELECT (NRIGA<9999)&&(TIPOMOV<=" << (nc ? tm_nota_credito : tm_fattura) << ')'
if (add_riga && tm == tm_fattura) << "\nFROM " << filter << "\nTO " << filter;
{ TISAM_recordset games(query);
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A'; const TRectype& rec = games.cursor()->curr();
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
importo.normalize(); int last_year = 0;
if (sezione_positiva == importo.sezione()) // Controlla se fattura positiva o negativa TString80 id_year, id_rec;
add_riga = false; // Ignora fattura positiva
} TProgind pi(games.items(), nc ? TR("Caricamento note di credito") : TR("Caricamento fatture"));
} for (bool ok = games.move_first(); ok; ok = games.move_next())
else {
{ if (!pi.addstatus(1))
if (stato == 1 || stato == 2) break;
{
const bool chiusa = rec.get_bool(PART_CHIUSA); const TString& codval = rec.get(PART_CODVAL);
if (chiusa) if (!same_values(codval, valuta))
add_riga = stato == 2; continue;
else
add_riga = stato == 1; const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV);
} bool add_riga = true;
} if (nc)
{
if (!add_riga) add_riga = !rec.get_bool(PART_CHIUSA);
continue; if (add_riga)
{
const int year = rec.get_int(PART_ANNO); // Se filtro le note di credito cerco di riconoscere le fatture negative
if (year != last_year) if (tm == tm_fattura)
{ {
goto_root(); const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
while(goto_rbrother()); TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
add_rbrother(real(year)); importo.normalize();
add_riga = sezione_positiva != importo.sezione(); // Ignora fattura positiva
last_year = year; }
curr_id(id_year); else
id_rec.cut(0); {
} const int nriga = rec.get_int(PART_NRIGA);
const TPartita& game = partita(rec);
if (nc) add_riga = ((TPartita&)game).unassigned().exist(nriga);
{ }
if (id_rec.full()) }
{ }
goto_node(id_rec); else
add_rbrother(rec); {
} if (stato == 1 || stato == 2)
else {
add_son(rec); const bool chiusa = rec.get_bool(PART_CHIUSA);
curr_id(id_rec); if (chiusa)
} add_riga = stato == 2;
else else
{ add_riga = stato == 1;
TPartita game(rec); }
const TRiga_partite& riga = game.riga(rec.get_int(PART_NRIGA)); if (add_riga)
for (int rata = 1; rata <= riga.rate(); rata++) {
{ const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
const TRiga_scadenze& s = riga.rata(rata); TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
bool add_rata = true; importo.normalize();
if (stato == 1 || stato == 2) add_riga = sezione_positiva == importo.sezione(); // Ignora fattura negativa
{ }
const bool chiusa = s.get_bool(SCAD_PAGATA); }
if (chiusa)
add_rata = stato == 2; if (!add_riga)
else continue;
add_rata = stato == 1;
} const int year = rec.get_int(PART_ANNO);
if (add_rata) if (year != last_year)
{ {
if (id_rec.full()) goto_root();
add_rbrother(s); while(goto_rbrother());
else add_rbrother(real(year));
add_son(s);
curr_id(id_rec); last_year = year;
} curr_id(id_year);
} id_rec.cut(0);
} }
}
if (nc)
if (goto_node(id_year)) {
expand(); if (id_rec.full())
{
return goto_root(); goto_node(id_rec);
} add_rbrother(rec);
}
/////////////////////////////////////////////////////////// else
// TPareggio_mask add_son(rec);
/////////////////////////////////////////////////////////// curr_id(id_rec);
}
class TPareggio_mask : public TAutomask else
{ {
TPareggio_tree _nc, _ft; TPartita game(rec);
const TRiga_partite& riga = game.riga(rec.get_int(PART_NRIGA));
private: for (int rata = 1; rata <= riga.rate(); rata++)
{
protected: const TRiga_scadenze& s = riga.rata(rata);
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); bool add_rata = true;
if (stato == 1 || stato == 2)
public: {
TPareggio_mask(); const bool chiusa = s.get_bool(SCAD_PAGATA);
}; if (chiusa)
add_rata = stato == 2;
bool TPareggio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) else
{ add_rata = stato == 1;
switch (o.dlg()) }
{ if (add_rata)
//case F_SOTTOCONTO: {
case F_CLIENTE: if (id_rec.full())
case F_FORNITORE: add_rbrother(s);
case F_CODVAL: else
case F_TUTTE: add_son(s);
if (e == fe_modify) curr_id(id_rec);
{ }
TWait_cursor hourglass; }
const short id = efield(F_FORNITORE).active() ? F_FORNITORE : }
(efield(F_SOTTOCONTO).active() ? F_SOTTOCONTO : F_CLIENTE); }
TBill bill; bill.get(*this, F_GRUPPO, F_CONTO, id, F_TIPO);
const int tipo = get_int(F_TUTTE); if (goto_node(id_year))
const TString& codval = get(F_CODVAL); expand();
_nc.init(bill, codval, true, 1); // Solo aperte
_ft.init(bill, codval, false, tipo); return goto_root();
}
tfield(F_NC_TREE).set_tree(&_nc);
tfield(F_FT_TREE).set_tree(&_ft); ///////////////////////////////////////////////////////////
} // TPareggio_mask
break; ///////////////////////////////////////////////////////////
default: break;
} class TPareggio_mask : public TAutomask
return true; {
} TPareggio_tree _nc, _ft;
long _numreg;
TPareggio_mask::TPareggio_mask() : TAutomask("sc0300a")
{ protected:
RCT rct_nc; field(F_NC_TREE).get_rect(rct_nc); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
RCT rct_ft; field(F_FT_TREE).get_rect(rct_ft);
public:
rct_nc.right = rct_ft.left-8; TPareggio_mask();
rct_ft.right = rct_ft.left + rct_nc.right - rct_nc.left; };
field(F_NC_TREE).set_rect(rct_nc); bool TPareggio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
field(F_FT_TREE).set_rect(rct_ft); {
} switch (o.dlg())
{
/////////////////////////////////////////////////////////// //case F_SOTTOCONTO:
// TPareggio_partite case F_CLIENTE:
/////////////////////////////////////////////////////////// case F_FORNITORE:
case F_CODVAL:
class TPareggio_partite : public TSkeleton_application case F_TUTTE:
{ if (e == fe_modify)
protected: {
virtual void main_loop(); TWait_cursor hourglass;
const short id = efield(F_FORNITORE).active() ? F_FORNITORE :
public: (efield(F_SOTTOCONTO).active() ? F_SOTTOCONTO : F_CLIENTE);
}; TBill bill; bill.get(*this, F_GRUPPO, F_CONTO, id, F_TIPO);
const int tipo = get_int(F_TUTTE);
void TPareggio_partite::main_loop() const TString& codval = get(F_CODVAL);
{ _nc.init(bill, codval, true, 1); // Solo aperte
TPareggio_mask pm; _ft.init(bill, codval, false, tipo);
pm.run();
} tfield(F_NC_TREE).set_tree(&_nc);
tfield(F_FT_TREE).set_tree(&_ft);
/////////////////////////////////////////////////////////// _numreg = 0;
// Main disable(DLG_LINK);
/////////////////////////////////////////////////////////// }
break;
int sc0300(int argc, char* argv[]) case F_NC_TREE:
{ case F_FT_TREE:
TPareggio_partite pp; if (e == fe_button || e == fe_modify)
pp.run(argc, argv, TR("Pareggio Partite")); {
return 0; TTree_field& tf = (TTree_field&)o;
} TVariant var;
if (tf.tree()->get_var("PART.NREG", var))
_numreg = var.as_int();
else
_numreg = 0L;
enable(DLG_LINK, _numreg > 0);
}
break;
case DLG_LINK:
if (_numreg > 0)
{
TRectype mov(LF_MOV); mov.put(MOV_NUMREG, _numreg);
if (mov.edit())
send_key(K_SPACE, F_TUTTE, &o);
}
break;
default: break;
}
return true;
}
TPareggio_mask::TPareggio_mask() : TAutomask("sc0300a"), _numreg(0L)
{
RCT rct_nc; field(F_NC_TREE).get_rect(rct_nc);
RCT rct_ft; field(F_FT_TREE).get_rect(rct_ft);
rct_nc.right = rct_ft.left-8;
rct_ft.right = rct_ft.left + rct_nc.right - rct_nc.left;
field(F_NC_TREE).set_rect(rct_nc);
field(F_FT_TREE).set_rect(rct_ft);
}
///////////////////////////////////////////////////////////
// TPareggio_partite
///////////////////////////////////////////////////////////
class TPareggio_partite : public TSkeleton_application
{
protected:
virtual void main_loop();
};
void TPareggio_partite::main_loop()
{
const int anno = xvt_vobj_get_attr(NULL_WIN, ATTR_APPL_VERSION_YEAR);
if (anno > 2101)
{
TPareggio_mask pm;
pm.run();
}
else
error_box(TR("Versione non supportata: %d"), anno);
}
///////////////////////////////////////////////////////////
// Main
///////////////////////////////////////////////////////////
int sc0300(int argc, char* argv[])
{
TPareggio_partite pp;
pp.run(argc, argv, TR("Pareggio Partite"));
return 0;
}

View File

@ -1,194 +1,196 @@
#include "sc0300a.h" #include "sc0300a.h"
TOOLBAR "" 0 0 0 2 TOOLBAR "" 0 0 0 2
BUTTON DLG_EDIT 2 2 BUTTON DLG_EDIT 2 2
BEGIN BEGIN
PROMPT 1 1 "Modifica" PROMPT 1 1 "Modifica"
PICTURE TOOL_EDIT PICTURE TOOL_EDIT
END END
BUTTON DLG_NEWREC 2 2 BUTTON DLG_LINK 2 2
BEGIN BEGIN
PROMPT 2 1 "Nuovo" PROMPT 2 1 "Collega"
PICTURE TOOL_NEWREC PICTURE TOOL_LINK
END END
#include <helpbar.h> #include <helpbar.h>
ENDPAGE ENDPAGE
PAGE "Pareggio Partite" 0 0 0 0 PAGE "Pareggio Partite" 0 0 0 0
LIST F_TIPO 1 10 LIST F_TIPO 1 10
BEGIN BEGIN
PROMPT 1 0 "Tipo conto " PROMPT 1 0 "Tipo conto "
// ITEM "|Conto" MESSAGE SHOW,1@|HIDE,2@|HIDE,3@ // ITEM "|Conto" MESSAGE SHOW,1@|HIDE,2@|HIDE,3@
ITEM "C|Cliente" MESSAGE HIDE,1@|SHOW,2@|HIDE,3@ ITEM "C|Cliente" MESSAGE HIDE,1@|SHOW,2@|HIDE,3@
ITEM "F|Fornitore" MESSAGE HIDE,1@|HIDE,2@|SHOW,3@ ITEM "F|Fornitore" MESSAGE HIDE,1@|HIDE,2@|SHOW,3@
END END
NUMBER F_GRUPPO 3 NUMBER F_GRUPPO 3
BEGIN BEGIN
PROMPT 28 0 "Gruppo " PROMPT 28 0 "Gruppo "
FLAGS "D" FLAGS "D"
END END
NUMBER F_CONTO 3 NUMBER F_CONTO 3
BEGIN BEGIN
PROMPT 43 0 "Conto " PROMPT 43 0 "Conto "
FLAGS "D" FLAGS "D"
END END
NUMBER F_SOTTOCONTO 6 NUMBER F_SOTTOCONTO 6
BEGIN BEGIN
PROMPT 58 0 "Sottoconto " PROMPT 58 0 "Sottoconto "
USE LF_PCON SELECT SOTTOCONTO!="" USE LF_PCON SELECT SOTTOCONTO!=""
INPUT GRUPPO F_GRUPPO INPUT GRUPPO F_GRUPPO
INPUT CONTO F_CONTO INPUT CONTO F_CONTO
INPUT SOTTOCONTO F_SOTTOCONTO INPUT SOTTOCONTO F_SOTTOCONTO
DISPLAY "Gruppo" GRUPPO DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO DISPLAY "Conto" CONTO
DISPLAY "Sottoconto" SOTTOCONTO DISPLAY "Sottoconto" SOTTOCONTO
DISPLAY "Descrizione@50" DESCR DISPLAY "Descrizione@50" DESCR
OUTPUT F_GRUPPO GRUPPO OUTPUT F_GRUPPO GRUPPO
OUTPUT F_CONTO CONTO OUTPUT F_CONTO CONTO
OUTPUT F_SOTTOCONTO SOTTOCONTO OUTPUT F_SOTTOCONTO SOTTOCONTO
OUTPUT F_DESCR DESCR OUTPUT F_DESCR DESCR
GROUP 1 GROUP 1
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
NUMBER F_CLIENTE 6 NUMBER F_CLIENTE 6
BEGIN BEGIN
PROMPT 58 0 "Cliente " PROMPT 58 0 "Cliente "
USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="") USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "C" INPUT TIPOCF "C"
INPUT CODCF F_CLIENTE INPUT CODCF F_CLIENTE
DISPLAY "Cliente" CODCF DISPLAY "Cliente" CODCF
DISPLAY "Descrizione@50" RAGSOC DISPLAY "Descrizione@50" RAGSOC
DISPLAY "Partita IVA" PAIV DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_CLIENTE CODCF OUTPUT F_CLIENTE CODCF
OUTPUT F_DESCRCLI RAGSOC OUTPUT F_DESCRCLI RAGSOC
ADD RUN cg0 -1 C ADD RUN cg0 -1 C
GROUP 2 GROUP 2
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
NUMBER F_FORNITORE 6 NUMBER F_FORNITORE 6
BEGIN BEGIN
PROMPT 58 0 "Fornitore " PROMPT 58 0 "Fornitore "
USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="") USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "F" INPUT TIPOCF "F"
INPUT CODCF F_FORNITORE INPUT CODCF F_FORNITORE
DISPLAY "Fornitore" CODCF DISPLAY "Fornitore" CODCF
DISPLAY "Descrizione@50" RAGSOC DISPLAY "Descrizione@50" RAGSOC
DISPLAY "Partita IVA" PAIV DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_FORNITORE CODCF OUTPUT F_FORNITORE CODCF
OUTPUT F_DESCRFOR RAGSOC OUTPUT F_DESCRFOR RAGSOC
ADD RUN cg0 -1 F ADD RUN cg0 -1 F
GROUP 3 GROUP 3
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
STRING F_DESCR 50 58 STRING F_DESCR 50 58
BEGIN BEGIN
PROMPT 1 1 "Descrizione " PROMPT 1 1 "Descrizione "
GROUP 1 GROUP 1
CHECKTYPE NORMAL CHECKTYPE NORMAL
END END
STRING F_DESCRCLI 50 58 STRING F_DESCRCLI 50 58
BEGIN BEGIN
PROMPT 1 1 "Ragione sociale " PROMPT 1 1 "Ragione sociale "
USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="") USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC="C" SOTTOCONTO==CODCF JOIN LF_PARTITE INTO TIPOC="C" SOTTOCONTO==CODCF
INPUT TIPOCF "C" INPUT TIPOCF "C"
INPUT RAGSOC F_DESCRCLI INPUT RAGSOC F_DESCRCLI
DISPLAY "Ragione Sociale@50" RAGSOC DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Cliente" CODCF DISPLAY "Cliente" CODCF
DISPLAY "Partita IVA" PAIV DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_CLIENTE CODCF OUTPUT F_CLIENTE CODCF
OUTPUT F_DESCRCLI RAGSOC OUTPUT F_DESCRCLI RAGSOC
CHECKTYPE NORMAL CHECKTYPE NORMAL
ADD RUN cg0 -1 F ADD RUN cg0 -1 F
GROUP 2 GROUP 2
END END
STRING F_DESCRFOR 50 58 STRING F_DESCRFOR 50 58
BEGIN BEGIN
PROMPT 1 1 "Ragione sociale " PROMPT 1 1 "Ragione sociale "
USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="") USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "F" INPUT TIPOCF "F"
INPUT RAGSOC F_DESCRFOR INPUT RAGSOC F_DESCRFOR
DISPLAY "Ragione Sociale@50" RAGSOC DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Fornitore" CODCF DISPLAY "Fornitore" CODCF
DISPLAY "Partita IVA" PAIV DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_FORNITORE CODCF OUTPUT F_FORNITORE CODCF
OUTPUT F_DESCRFOR RAGSOC OUTPUT F_DESCRFOR RAGSOC
CHECKTYPE NORMAL CHECKTYPE NORMAL
ADD RUN cg0 -1 F ADD RUN cg0 -1 F
GROUP 3 GROUP 3
END END
RADIOBUTTON F_TUTTE 1 38 RADIOBUTTON F_TUTTE 1 38
BEGIN BEGIN
PROMPT 1 2 "Mostra fatture" PROMPT 1 2 "Mostra fatture"
ITEM "1|Aperte" ITEM "1|Aperte"
ITEM "2|Chiuse" ITEM "2|Chiuse"
ITEM "3|Tutte" ITEM "3|Tutte"
FLAGS "Z" FLAGS "Z"
END END
STRING F_CODVAL 3 STRING F_CODVAL 3
BEGIN BEGIN
PROMPT 61 3 "Valuta " PROMPT 61 3 "Valuta "
USE %VAL USE %VAL
INPUT CODTAB F_CODVAL INPUT CODTAB F_CODVAL
DISPLAY "Codice" CODTAB DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@50" S0 DISPLAY "Descrizione@50" S0
OUTPUT F_CODVAL CODTAB OUTPUT F_CODVAL CODTAB
FLAGS "U" FLAGS "U"
CHECKTYPE NORMAL CHECKTYPE NORMAL
END END
TLIST F_NC_TREE 35 -1 TLIST F_NC_TREE 35 -1
BEGIN BEGIN
PROMPT 0 5 "" PROMPT 0 5 ""
DISPLAY "Partita@12" NUMPART DISPLAY "Partita@12" NUMPART
DISPLAY "Riga@4R" NRIGA DISPLAY "Riga@4R" NRIGA
DISPLAY "Importo@10R" IMPORTO DISPLAY "Data@8" DATADOC
DISPLAY "Residuo@10R" RESIDUO DISPLAY "Importo@10R" IMPORTO
DISPLAY "Descrizione Nota di Credito@35" DESCR DISPLAY "Residuo@10R" RESIDUO
DISPLAY "P.N.@6R" NREG DISPLAY "Descrizione Nota di Credito@35" PART.DESCR
END DISPLAY "P.N.@6R" NREG
END
TLIST F_FT_TREE 35 -1
BEGIN TLIST F_FT_TREE 35 -1
PROMPT 40 5 "" BEGIN
DISPLAY "Partita@12" NUMPART PROMPT 40 5 ""
DISPLAY "Riga@4R" NRIGA DISPLAY "Partita@12" NUMPART
DISPLAY "Rata@4R" NRATA DISPLAY "Riga@4R" NRIGA
DISPLAY "Data@8" DATADOC DISPLAY "Rata@4R" NRATA
DISPLAY "Importo@10R" IMPORTO DISPLAY "Scadenza@8" DATASCAD
DISPLAY "Residuo@10R" RESIDUO DISPLAY "Importo@10R" IMPORTO
DISPLAY "Descrizione Fattura@35" DESCR DISPLAY "Residuo@10R" RESIDUO
DISPLAY "P.N.@6R" NREG DISPLAY "Descrizione Fattura@35" PART.DESCR
END DISPLAY "P.N.@6R" PART.NREG
FLAGS "M"
ENDMASK END
ENDMASK

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,111 +1,125 @@
#ifndef __DONGLE_H #ifndef __DONGLE_H
#define __DONGLE_H #define __DONGLE_H
#ifndef _WX_DATETIME_H #ifndef _WX_DATETIME_H
#include <wx/datetime.h> #include <wx/datetime.h>
#endif #endif
enum TDongleHardware { _dongle_unknown, _dongle_hardlock, _dongle_eutron, _dongle_xsec }; enum TDongleHardware { _dongle_unknown, _dongle_hardlock, _dongle_eutron, _dongle_ssa };
enum TDongleType { _no_dongle, _user_dongle, _developer_dongle, _aga_dongle, _prassi_dongle }; enum TDongleType { _no_dongle, _user_dongle, _developer_dongle, _aga_dongle, _sirio_dongle };
enum { MAX_DONGLE_ASSIST = 8 }; enum { MAX_DONGLE_ASSIST = 8 };
class TBit_array : public wxObject class TBit_array : public wxObject
{ {
unsigned char* _bit; unsigned char* _bit;
size_t _size; size_t _size;
protected: protected:
virtual bool ok() const; virtual bool ok() const;
void resize(size_t size); void resize(size_t size);
void copy(const TBit_array& ba); void copy(const TBit_array& ba);
size_t index(size_t n) const size_t index(size_t n) const
{ return size_t(n / 8); } { return size_t(n / 8); }
unsigned long mask(size_t n) const unsigned long mask(size_t n) const
{ return (unsigned long)(1 << (n & 0x7)); } { return (unsigned long)(1 << (n & 0x7)); }
public: public:
TBit_array(size_t size = 0); TBit_array(size_t size = 0);
TBit_array(const TBit_array& ba); TBit_array(const TBit_array& ba);
virtual ~TBit_array(); virtual ~TBit_array();
TBit_array& operator=(const TBit_array& ba); TBit_array& operator=(const TBit_array& ba);
bool operator[] (size_t n) const; bool operator[] (size_t n) const;
TBit_array& operator |=(const TBit_array& b); TBit_array& operator |=(const TBit_array& b);
size_t items() const { return 8 * _size; } size_t items() const { return 8 * _size; }
long first_one() const; long first_one() const;
long last_one() const; long last_one() const;
size_t ones() const; size_t ones() const;
void set(size_t n); void set(size_t n);
void reset(size_t n); void reset(size_t n);
void neg(size_t n); void neg(size_t n);
void set(size_t n, bool on) { on ? set(n) : reset(n); } void set(size_t n, bool on) { on ? set(n) : reset(n); }
void set(); void set();
void reset(); void reset();
}; };
class TDongle : public wxObject class TDongle : public wxObject
{ {
TDongleHardware _hardware; TDongleHardware _hardware;
TDongleType _type; TDongleType _type;
wxString _admin, _admpwd; wxString _admin, _admpwd;
unsigned short _serno, _max_users, _year_assist; unsigned short _serno, _max_users, _year_assist;
unsigned short _eprom[64]; unsigned short _eprom[64];
wxDateTime _last_update; wxDateTime _last_update;
TBit_array _module; TBit_array _module;
bool _dirty; bool _dirty;
protected: // Module codes and descriptions
bool already_programmed() const; wxArrayString _code, _desc;
unsigned short _user[64];
bool hardlock_login(bool test_all_dongles);
bool eutron_login(bool test_all_dongles); wxString GetSessionId() const; // host:session
unsigned short ComputeMaxUsers(size_t module) const;
bool burn_hardlock(); bool OpenModule(size_t module);
bool burn_eutron();
protected:
public: bool already_programmed() const;
bool Ok() const
{ return _hardware != _dongle_unknown && _type != _no_dongle && _serno != 0xFFFF; } bool hardlock_login(bool test_all_dongles);
bool eutron_login(bool test_all_dongles);
public:
bool Login(bool test_all_dongles = false); bool ssa_login(bool test_all_dongles);
bool Logout(); bool ssa_logout();
bool Connected();
bool burn_hardlock();
unsigned short Number() const { return _serno; } bool burn_eutron();
unsigned short MaxUsers() const { return _max_users; }
unsigned short YearAssist() const { return _year_assist; } public:
bool Ok() const
void garble(unsigned short* data) const; { return _hardware != _dongle_unknown && _type != _no_dongle && _serno != 0xFFFF; }
// Solo per un po' di tempo, poi diverranno protected (servono a ba1500 old style) public:
bool read_words(unsigned short reg, unsigned short len, unsigned short *data) const; bool Login(bool test_all_dongles = false);
bool write_words(unsigned short reg, unsigned short len, unsigned short *data) const; bool Logout();
bool Connected();
TDongleType type() const { return _type; }
unsigned short Number() const { return _serno; }
bool Active(size_t module) const { return _module[module]; } unsigned short YearAssist() const { return _year_assist; }
void Activate(size_t module, bool on = true) { _module.set(module, on); _dirty = true; } unsigned short MaxUsers(size_t module = 0) const;
void Deactivate(size_t module) { Activate(module, false); }
void set_max_users(unsigned short u) { _max_users = u; _dirty = true; } void garble(unsigned short* data) const;
void set_year_assist(unsigned short y) { _year_assist = y; _dirty = true; } bool read_words(unsigned short reg, unsigned short len, unsigned short *data) const;
const wxDateTime& last_update() const { return _last_update; } bool write_words(unsigned short reg, unsigned short len, unsigned short *data) const;
bool dirty() const { return _dirty; } TDongleType type() const { return _type; }
bool Burn();
bool Active(size_t module) const { return _module[module]; }
TDongleHardware hardware() const { return _hardware; } void Activate(size_t module, bool on = true) { _module.set(module, on); _dirty = true; }
void Deactivate(size_t module) { Activate(module, false); }
TDongle(); void set_max_users(unsigned short u) { _max_users = u; _dirty = true; }
virtual ~TDongle(); void set_year_assist(unsigned short y) { _year_assist = y; _dirty = true; }
}; const wxDateTime& last_update() const { return _last_update; }
long date2julian(const wxDateTime& date); bool IsDirty() const { return _dirty; }
bool Burn();
#endif
TDongleHardware hardware() const { return _hardware; }
size_t Modules() const { return _code.GetCount(); }
wxString ModuleNumberToCode(size_t module) const;
size_t ModuleCodeToNumber(const wxChar* code) const;
wxString ModuleDescription(size_t module) const;
TDongle();
virtual ~TDongle();
};
long date2julian(const wxDateTime& date);
#endif

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,21 +1,21 @@
#include <xvt.h> #include <xvt.h>
#include "ve6.h" // dichiarazioni delle procedure #include "ve6.h" // dichiarazioni delle procedure
int main( int argc, char** argv ) int main( int argc, char** argv )
{ {
const int r = (argc > 1) ? argv[1][1]-'0' : -1; const int r = (argc > 1) ? argv[1][1]-'0' : -1;
switch (r) switch (r)
{ {
case 2: ve6200(argc, argv); break; // creazione fatture partendo da bolle case 2: ve6200(argc, argv); break; // fatturazione bolle
case 3: ve6300(argc, argv); break; // generazione effetti case 3: ve6300(argc, argv); break; // generazione effetti
case 4: ve6400(argc, argv); break; // generazione scontrini case 4: ve6400(argc, argv); break; // generazione scontrini
case 5: ve6500(argc, argv); break; // generazione righe da penna ottica case 5: ve6500(argc, argv); break; // generazione righe da penna ottica
case 6: ve6600(argc, argv); break; // collegamento contabilita' industriosa case 6: ve6600(argc, argv); break; // collegamento contabilita' industriosa
case 7: ve6700(argc, argv); break; // copia documenti interattiva da ditta a ditta case 7: ve6700(argc, argv); break; // copia documenti interattiva da ditta a ditta
case 8: ve6800(argc, argv); break; // contabilizzazione analitica documenti case 8: ve6800(argc, argv); break; // contabilizzazione analitica documenti
default: ve6100(argc, argv); break; // contabilizzazione documenti default: ve6100(argc, argv); break; // contabilizzazione documenti
} }
return 0; return 0;
} }

View File

@ -1,367 +1,359 @@
// ve6100.cpp: programma di contabilizzazione documenti // ve6100.cpp: programma di contabilizzazione documenti
// Orgiastica visione... // Orgiastica visione...
// L'anatra del dubbio dalle labbra di Vermouth. // L'anatra del dubbio dalle labbra di Vermouth.
//****************************************************************************** //******************************************************************************
// \\\\\\\\ e * // \\\\\\\\ e *
// b \\\\\\\\ b * // b \\\\\\\\ b *
// \\\\\\\\ e r d l * // \\\\\\\\ e r d l *
// \\\\\\\\ * // \\\\\\\\ *
// \\\\\\\\ i V o e h * // \\\\\\\\ i V o e h *
// L \\\\\\\\ * // L \\\\\\\\ *
// \\\\\\\\ b d * // \\\\\\\\ b d *
// o \\\\\\\\ m a * // o \\\\\\\\ m a *
// +++++++++++++++++++++++++ b t * // +++++++++++++++++++++++++ b t *
// ++++++++++++++++++++++++++--------------------------------------------------| // ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++++--------------------------------------------------| // ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++ |---------------------------------------| // ++++++++++++++++++++++++ |---------------------------------------|
// u //////// u |---------------------------------------| // u //////// u |---------------------------------------|
// ' //////// a | /\ /\ | // ' //////// a | /\ /\ |
// //////// i | r / \ r / \ | // //////// i | r / \ r / \ |
// a //////// \|/ / \ / \ l | // a //////// \|/ / \ / \ l |
// ////////-----------------*---\ a / t \ / a \ /| // ////////-----------------*---\ a / t \ / a \ /|
// //////// /|\ \ / \ / \ / | // //////// /|\ \ / \ / \ / |
// d //////// n | \ / \ / \ / | // d //////// n | \ / \ / \ / |
// //////// l d | \/ a \/ l \/ | // //////// l d | \/ a \/ l \/ |
//-----------------------------------------------------------------------------| //-----------------------------------------------------------------------------|
// //
// Scared uh? // Scared uh?
#include <applicat.h> #include <applicat.h>
#include <mask.h> #include <mask.h>
#include <progind.h> #include <progind.h>
#include <relation.h> #include <relation.h>
#include <sheet.h> #include <sheet.h>
#include <tabutil.h> #include <tabutil.h>
#include <urldefid.h> #include <urldefid.h>
#include "velib04.h" #include "velib04.h"
#include "../cg/cgsaldac.h" #include "../cg/cgsaldac.h"
#include "ve6100a.h" #include "ve6100a.h"
// TContabilizzazione_app // TContabilizzazione_app
// Applicazione di contabilizzazione documenti // Applicazione di contabilizzazione documenti
class TContabilizzazione_app : public TApplication class TContabilizzazione_app : public TApplication
{ {
TString16 _cod_el; // codice elaborazione immesso TString16 _cod_el; // codice elaborazione immesso
TDate _data_reg; // data di registrazione immessa TDate _data_reg; // data di registrazione immessa
TDate _data_ini; // data di inizio intervallo TDate _data_ini; // data di inizio intervallo
TDate _data_fine; // data di fine intervallo TDate _data_fine; // data di fine intervallo
bool _auto_data; // se TRUE prende in automatico la data di registrazione dalla data documento bool _auto_data; // se true prende in automatico la data di registrazione dalla data documento
TMask *_msk; // maschera di selezione dati TMask *_msk; // maschera di selezione dati
TArray_sheet *_num_sheet; // Array sheet selezionabile dei codici numerazione TArray_sheet *_num_sheet; // Array sheet selezionabile dei codici numerazione
TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare
virtual const char * extra_modules() const {return "dt";} virtual const char * extra_modules() const {return "dt";}
protected: // TApplication protected: // TApplication
// Contabilizza i documenti // Contabilizza i documenti
void contabilize(); void contabilize();
// Le 4 seguenti non hanno bisogno di commenti // Le 4 seguenti non hanno bisogno di commenti
virtual bool menu(MENU_TAG mt); virtual bool menu(MENU_TAG mt);
virtual bool create(); virtual bool create();
virtual bool destroy(); virtual bool destroy();
virtual void on_config_change(); virtual void on_config_change();
// Handler del codice elaborazione differita // Handler del codice elaborazione differita
static bool handle_cod_eld(TMask_field& f, KEY k); static bool handle_cod_eld(TMask_field& f, KEY k);
// Handler dell'intervallo di date // Handler dell'intervallo di date
static bool handle_data_range(TMask_field& f, KEY k); static bool handle_data_range(TMask_field& f, KEY k);
// Handler della data di registrazione // Handler della data di registrazione
static bool handle_data_reg(TMask_field& f, KEY k); static bool handle_data_reg(TMask_field& f, KEY k);
// Handler del pulsante di selezione codici numerazione // Handler del pulsante di selezione codici numerazione
static bool handle_select(TMask_field& f, KEY k); static bool handle_select(TMask_field& f, KEY k);
// Ritorna il TArray_sheet contenente le selezioni sui codici numerazione // Ritorna il TArray_sheet contenente le selezioni sui codici numerazione
// Costruisce lo sheet dei codici numerazione // Costruisce lo sheet dei codici numerazione
void build_num_sheet(); void build_num_sheet();
TArray_sheet* get_num_sheet() const { return _num_sheet; } TArray_sheet* get_num_sheet() const { return _num_sheet; }
// Coontrolla se lo stato ed il tipo del documento sono validi e rispettano la selezione // Coontrolla se lo stato ed il tipo del documento sono validi e rispettano la selezione
bool doc_tipo_stato_ok(const TRectype& doc); bool doc_tipo_stato_ok(const TRectype& doc);
public: public:
TContabilizzazione_app() {_msk = NULL; _num_sheet = NULL;} TContabilizzazione_app() {_msk = NULL; _num_sheet = NULL;}
virtual ~TContabilizzazione_app() { } virtual ~TContabilizzazione_app() { }
}; };
inline TContabilizzazione_app& app() { return (TContabilizzazione_app&) main_app(); } inline TContabilizzazione_app& app() { return (TContabilizzazione_app&) main_app(); }
bool TContabilizzazione_app::handle_data_range(TMask_field& f, KEY k) bool TContabilizzazione_app::handle_data_range(TMask_field& f, KEY k)
{ {
if (k==K_ENTER && f.dirty()) if (k==K_ENTER && f.dirty())
{ {
TMask& m = f.mask(); TMask& m = f.mask();
if (m.get_bool(F_DATA_AUTO)) if (m.get_bool(F_DATA_AUTO))
return TRUE; // Skip controls if data is automatic return true; // Skip controls if data is automatic
TDate da(m.get_date(F_DATA_INI)); TDate da(m.get_date(F_DATA_INI));
TDate a(m.get_date(F_DATA_FIN)); TDate a(m.get_date(F_DATA_FIN));
m.field(F_DATA_REG).set_dirty(); m.field(F_DATA_REG).set_dirty();
if ((a - da) > 15) if ((a - da) > 15)
{ return f.error_box(TR("L'intervallo tra le date non puo' eccedere i 15 giorni."));
f.error_box(TR("L'intervallo tra le date non puo' eccedere i 15 giorni.")); if (f.dlg() == F_DATA_FIN)
return FALSE; m.set(F_DATA_REG,f.get());
} }
if (f.dlg() == F_DATA_FIN) if (f.focusdirty())
m.set(F_DATA_REG,f.get()); {
} TMask& m = f.mask();
if (f.focusdirty()) if (!m.get_bool(F_DATA_AUTO) && f.dlg() == F_DATA_FIN)
{ m.set(F_DATA_REG,f.get());
TMask& m = f.mask(); }
if (!m.get_bool(F_DATA_AUTO) && f.dlg() == F_DATA_FIN) return true;
m.set(F_DATA_REG,f.get()); }
}
return TRUE; bool TContabilizzazione_app::handle_data_reg(TMask_field& f, KEY k)
} {
if (k==K_ENTER && f.dirty())
bool TContabilizzazione_app::handle_data_reg(TMask_field& f, KEY k) {
{ TMask& m = f.mask();
if (k==K_ENTER && f.dirty())
{ TDate data_reg(f.get());
TMask& m = f.mask(); if (data_reg == botime)
return true;
TDate data_reg(f.get()); TDate da(m.get_date(F_DATA_INI));
if (data_reg == botime) return TRUE; if ((data_reg - da) > 15)
TDate da(m.get_date(F_DATA_INI)); return f.error_box(TR("L'intervallo tra la data di registrazione e la data di inizio non puo' eccedere i 15 giorni."));
if ((data_reg - da) > 15) if (data_reg < da)
{ return f.error_box(TR("La data di registrazione non puo' essere minore della data di inizio."));
f.error_box(TR("L'intervallo tra la data di registrazione e la data di inizio non puo' eccedere i 15 giorni.")); }
return FALSE; return true;
} }
if (data_reg < da)
{ bool TContabilizzazione_app::handle_cod_eld(TMask_field& f, KEY k)
f.error_box(TR("La data di registrazione non puo' essere minore della data di inizio.")); {
return FALSE; if (f.to_check(k) && k == K_TAB) // se e' cambiato ricostruisce anche lo sheet dei codici numerazione
} {
} app()._cod_el = f.get(); // aggiorna il codice elaborazione per la build_num_sheet()
return TRUE; f.mask().disable(DLG_OK);
} app().build_num_sheet();
}
bool TContabilizzazione_app::handle_cod_eld(TMask_field& f, KEY k) return true;
{ }
if (f.to_check(k) && k == K_TAB) // se e' cambiato ricostruisce anche lo sheet dei codici numerazione
{ bool TContabilizzazione_app::handle_select(TMask_field& f, KEY k)
app()._cod_el = f.get(); // aggiorna il codice elaborazione per la build_num_sheet() {
f.mask().disable(DLG_OK); if (k == K_SPACE)
app().build_num_sheet(); {
} TMask& m = f.mask();
return TRUE; TArray_sheet* s = app().get_num_sheet();
} if (s->run())
{
bool TContabilizzazione_app::handle_select(TMask_field& f, KEY k) if (s->checked() != 0) // Hai selezionato qualcosa ?
{ m.enable(DLG_OK); // allora abilita il pulsante di conferma
if (k == K_SPACE) else
{ m.disable(DLG_OK);
TMask& m = f.mask(); }
TArray_sheet* s = app().get_num_sheet(); }
if (s->run()) return true;
{ }
if (s->checked() != 0) // Hai selezionato qualcosa ?
m.enable(DLG_OK); // allora abilita il pulsante di conferma void TContabilizzazione_app::build_num_sheet()
else {
m.disable(DLG_OK); _num_sheet->destroy();
} _tipi_doc.destroy();
}
return TRUE; TTable num("%NUM");
} TString s1,s2,s3;
void TContabilizzazione_app::build_num_sheet() TContabilizzazione* cont = new TContabilizzazione(_cod_el);
{ if (!cont->empty())
_num_sheet->destroy(); {
_tipi_doc.destroy(); TToken_string t;
TString16 tipo;
TTable num("%NUM"); for (int i=0;i<TElaborazione::_max_tipi_doc_elab;i++)
TString s1,s2,s3; {
tipo = cont->tipo_iniziale(i);
TContabilizzazione* cont = new TContabilizzazione(_cod_el); if (tipo.not_empty())
if (!cont->empty()) {
{ t = tipo;
TToken_string t; t.add(cont->stato_iniziale(i)); // Stato iniziale
TString16 tipo; _tipi_doc.add(t); // Aggiunge questo tipo documento alla lista
for (int i=0;i<TElaborazione::_max_tipi_doc_elab;i++) }
{ }
tipo = cont->tipo_iniziale(i);
if (tipo.not_empty()) long pos=0l;
{
t = tipo; for (num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
t.add(cont->stato_iniziale(i)); // Stato iniziale {
_tipi_doc.add(t); // Aggiunge questo tipo documento alla lista TToken_string t,z;
} t.add(" ");
} t.add(num.get("CODTAB"));
t.add(num.get("S0"));
long pos=0l; _num_sheet->add(t);
s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
for (num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
{ for (int x = 0; x <= s2.len(); x += 4)
TToken_string t,z; z.add(s2.mid(x,4));
t.add(" ");
t.add(num.get("CODTAB")); bool found = FALSE;
t.add(num.get("S0")); for (int i = _tipi_doc.last(); !found && i >= 0; i--)
_num_sheet->add(t); found |= (s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0);
s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione if (found)
_num_sheet->enable_row(pos);
for (int x = 0; x <= s2.len(); x += 4) else
z.add(s2.mid(x,4)); _num_sheet->disable_row(pos);
}
bool found = FALSE; }
for (int i = _tipi_doc.last(); !found && i >= 0; i--) delete cont;
found |= (s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0); }
if (found)
_num_sheet->enable_row(pos); bool TContabilizzazione_app::doc_tipo_stato_ok(const TRectype& doc)
else // Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
_num_sheet->disable_row(pos); // differita selezionata
} {
} bool found = FALSE;
delete cont; const TString16 tipo = doc.get(DOC_TIPODOC);
} const char stato = doc.get_char(DOC_STATO);
const int items = _tipi_doc.items();
bool TContabilizzazione_app::doc_tipo_stato_ok(const TRectype& doc) for (int i=0;i<items && !found;i++)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione {
// differita selezionata TToken_string& t = _tipi_doc.row(i);
{ const TString16 tipox(t.get(0));
bool found = FALSE; const char statox = t.get(1)[0];
const TString16 tipo = doc.get(DOC_TIPODOC); if (tipo == tipox && stato == statox)
const char stato = doc.get_char(DOC_STATO); found = true;
const int items = _tipi_doc.items(); }
for (int i=0;i<items && !found;i++) return found;
{ }
TToken_string& t = _tipi_doc.row(i);
const TString16 tipox(t.get(0)); void TContabilizzazione_app::on_config_change()
const char statox = t.get(1)[0]; {
if (tipo == tipox && stato == statox) TPartita::carica_allineamento();
found = TRUE; }
}
return found; bool TContabilizzazione_app::create()
} {
TApplication::create();
void TContabilizzazione_app::on_config_change() open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN,
{ LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_PROVV, LF_MOV,
TPartita::carica_allineamento(); LF_PCON, LF_CONDV, LF_SVRIEP, LF_AGENTI, LF_PERCPROV, LF_ATTIV, LF_CAUSALI, 0);
} _msk = new TMask("ve6100a");
_msk->set_handler(F_CODICE_ELAB,handle_cod_eld);
bool TContabilizzazione_app::create() _msk->set_handler(F_DATA_INI,handle_data_range);
{ _msk->set_handler(F_DATA_FIN,handle_data_range);
TApplication::create(); //_msk->set_handler(F_DATA_REG,handle_data_reg);
open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN, _msk->set_handler(DLG_USER,handle_select);
LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_PROVV, LF_MOV, _num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione",
LF_PCON, LF_CONDV, LF_SVRIEP, LF_AGENTI, LF_PERCPROV, LF_ATTIV, LF_CAUSALI, 0); "@1|Cod. numerazione|Descrizione@50");
_msk = new TMask("ve6100a"); dispatch_e_menu(BAR_ITEM_ID(1));
_msk->set_handler(F_CODICE_ELAB,handle_cod_eld); return true;
_msk->set_handler(F_DATA_INI,handle_data_range); }
_msk->set_handler(F_DATA_FIN,handle_data_range);
//_msk->set_handler(F_DATA_REG,handle_data_reg); bool TContabilizzazione_app::destroy()
_msk->set_handler(DLG_USER,handle_select); {
_num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione", if (_msk) delete _msk;
"@1|Cod. numerazione|Descrizione@50"); if (_num_sheet) delete _num_sheet;
dispatch_e_menu(BAR_ITEM_ID(1)); return TApplication::destroy();
return TRUE; }
}
bool TContabilizzazione_app::menu(MENU_TAG mt)
bool TContabilizzazione_app::destroy() {
{ while (_msk->run() == K_ENTER)
if (_msk) delete _msk; {
if (_num_sheet) delete _num_sheet; _cod_el = _msk->get(F_CODICE_ELAB);
return TApplication::destroy(); _data_ini = _msk->get_date(F_DATA_INI);
} _data_fine = _msk->get_date(F_DATA_FIN);
_data_reg = _msk->get_date(F_DATA_REG);
bool TContabilizzazione_app::menu(MENU_TAG mt) _auto_data = _msk->get_bool(F_DATA_AUTO);
{ contabilize();
while (_msk->run() == K_ENTER) }
{ return FALSE;
_cod_el = _msk->get(F_CODICE_ELAB); }
_data_ini = _msk->get_date(F_DATA_INI);
_data_fine = _msk->get_date(F_DATA_FIN); void TContabilizzazione_app::contabilize()
_data_reg = _msk->get_date(F_DATA_REG); {
_auto_data = _msk->get_bool(F_DATA_AUTO); TRelation doc_rel(LF_DOC);
contabilize(); TRectype da(LF_DOC);
} TRectype a(LF_DOC);
return FALSE; const long items = _num_sheet->items();
} int year_from = _data_ini.year();
int year_to = _data_fine.year();
void TContabilizzazione_app::contabilize() TString4 codnum;
{ TString msg,filt_expr;
TRelation doc_rel(LF_DOC); TToken_string nums;
TRectype da(LF_DOC); TContabilizzazione cont(_cod_el);
TRectype a(LF_DOC); // Compone la lista dei documenti da elaborare
const long items = _num_sheet->items();
int year_from = _data_ini.year(); cont.set_auto(_auto_data); // Setta il flag per il settaggio automatico della data di registrazione del movimento
int year_to = _data_fine.year();
TString16 codnum; for (long i=0L; i<items;i++) // Scorre per tutte le numerazioni dello sheet
TString msg,filt_expr; {
TToken_string nums; if (_num_sheet->checked(i)) // Costruisce una espressione sul codice numerazione: "CODNUM="x0" || CODNUM="x1" || ..."
TContabilizzazione cont(_cod_el); {
// Compone la lista dei documenti da elaborare codnum = _num_sheet->row(i).get(1);
filt_expr << "(CODNUM=\"";
cont.set_auto(_auto_data); // Setta il flag per il settaggio automatico della data di registrazione del movimento filt_expr << codnum << "\")||";
nums.add(codnum);
for (long i=0L; i<items;i++) // Scorre per tutte le numerazioni dello sheet }
{ }
if (_num_sheet->checked(i)) // Costruisce una espressione sul codice numerazione: "CODNUM="x0" || CODNUM="x1" || ..." filt_expr.rtrim(2);
{
codnum = _num_sheet->row(i).get(1); da.put(DOC_DATADOC,_data_ini);
filt_expr << "(CODNUM=\""; da.put(DOC_PROVV,"D");
filt_expr << codnum << "\")||"; da.put(DOC_ANNO,year_from);
nums.add(codnum); a.put(DOC_DATADOC,_data_fine);
} a.put(DOC_PROVV,"D");
} a.put(DOC_ANNO,year_to);
filt_expr.rtrim(2);
// Se ho una sola numerazione ottimizzo la setregion!
da.put(DOC_DATADOC,_data_ini); if (nums.items() == 1)
da.put(DOC_PROVV,"D"); {
da.put(DOC_ANNO,year_from); da.put(DOC_CODNUM, nums);
a.put(DOC_DATADOC,_data_fine); a.put(DOC_CODNUM, nums);
a.put(DOC_PROVV,"D"); filt_expr.cut(0); // Il filtro diventa inutile
a.put(DOC_ANNO,year_to); }
// Se ho una sola numerazione ottimizzo la setregion! // Cursore complessivo con limiti di data (chiave 3). Viene sfruttata l'ottimizzazione
if (nums.items() == 1) // sulla costruzione dei cursori nel caso i campi presenti nell'espressione siano campi
{ // chiave, nel nostro caso CODNUM soddisfa i requisiti.
da.put(DOC_CODNUM, nums); TCursor doc_cur(&doc_rel,filt_expr,3,&da,&a);
a.put(DOC_CODNUM, nums); const TRecnotype cur_items = doc_cur.items();
filt_expr.cut(0); // Il filtro diventa inutile if (cur_items > 0)
} {
TLista_documenti lista_in,lista_out;
// Cursore complessivo con limiti di data (chiave 3). Viene sfruttata l'ottimizzazione
// sulla costruzione dei cursori nel caso i campi presenti nell'espressione siano campi doc_cur.freeze();
// chiave, nel nostro caso CODNUM soddisfa i requisiti. msg = TR("Selezione documenti dal ");
TCursor doc_cur(&doc_rel,filt_expr,3,&da,&a); msg << _data_ini.string() << TR(" al ");
const TRecnotype cur_items = doc_cur.items(); msg << _data_fine.string();
if (cur_items > 0) TProgind p(cur_items,msg,FALSE,true);
{ const TRectype& cur_rec = doc_cur.curr();
TLista_documenti lista_in,lista_out;
// Scorre tutti i documenti che rientrano nell'intervallo selezionato
doc_cur.freeze(); for (doc_cur = 0; doc_cur.pos() < cur_items; ++doc_cur)
msg = "Selezione documenti dal "; {
msg << _data_ini.string() << " al "; p.addstatus(1);
msg << _data_fine.string(); // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
TProgind p(cur_items,msg,FALSE,TRUE); if (nums.get_pos(cur_rec.get("CODNUM")) >= 0 && doc_tipo_stato_ok(cur_rec))
const TRectype& cur_rec = doc_cur.curr(); {
TDocumento* doc = new TDocumento;
// Scorre tutti i documenti che rientrano nell'intervallo selezionato if (doc->read(doc_cur.curr()) == NOERR) // legge il documento
for (doc_cur = 0; doc_cur.pos() < cur_items; ++doc_cur) lista_in.add(doc); // Viene aggiunto alla lista dei documenti
{ else
p.addstatus(1); delete doc;
// controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata }
if (nums.get_pos(cur_rec.get("CODNUM")) >= 0 && doc_tipo_stato_ok(cur_rec)) }
{ cont.elabora(lista_in,lista_out,_data_reg);
TDocumento* doc = new TDocumento; if (cont.processed_docs() > 0L)
if (doc->read(doc_cur.curr()) == NOERR) // legge il documento message_box(FR("Totale documenti contabilizzati: %ld"), cont.processed_docs());
lista_in.add(doc); // Viene aggiunto alla lista dei documenti }
else else
delete doc; warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate."));
}
} xvtil_statbar_set("");
cont.elabora(lista_in,lista_out,_data_reg); }
if (cont.processed_docs() > 0L)
message_box(FR("Totale documenti contabilizzati: %ld"), cont.processed_docs()); int ve6100 (int argc, char **argv)
} {
else TContabilizzazione_app a;
warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate.")); a.run(argc,argv,"Contabilizzazione documenti");
return true;
xvtil_statbar_set(""); }
}
int ve6100 (int argc, char **argv)
{
TContabilizzazione_app a;
a.run(argc,argv,"Contabilizzazione documenti");
return TRUE;
}

View File

@ -1,400 +1,399 @@
//#include <progind.h> //#include <progind.h>
#include <recset.h> #include <recset.h>
#include "velib04.h" #include "velib04.h"
#include "ve6200.h" #include "ve6200.h"
#include "ve6200a.h" #include "ve6200a.h"
#include <doc.h> #include <doc.h>
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// TFatturazione_bolle_app // TFatturazione_bolle_app
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
bool TFatturazione_bolle_app::create() bool TFatturazione_bolle_app::create()
{ {
open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN, open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN,
LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_CONDV, LF_SVRIEP, LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_CONDV, LF_SVRIEP,
LF_AGENTI, LF_PERCPROV, LF_CAUSALI, 0); LF_AGENTI, LF_PERCPROV, LF_CAUSALI, 0);
TConfig cfg(CONFIG_DITTA, "ve"); _default_selection = ini_get_string(CONFIG_DITTA, "ve", "FATBOLSEL");
_default_selection = cfg.get("FATBOLSEL");
return TSkeleton_application::create();
return TSkeleton_application::create(); }
}
bool TFatturazione_bolle_app::process(TIndwin& iw, TElaborazione & eld,
bool TFatturazione_bolle_app::process(TIndwin& iw, TElaborazione & eld, TLista_documenti& din, const TDate& data_elab)
TLista_documenti& din, const TDate& data_elab) {
{ // Crea documenti di output
// Crea documenti di output TLista_documenti dout;
TLista_documenti dout; bool ok = true;
bool ok = true; if (eld.elabora(din, dout, data_elab))
if (eld.elabora(din, dout, data_elab)) {
{ TString msg;
TString msg; msg << din.items() << TR(" documenti raggruppati in ") << dout.items();
msg << din.items() << TR(" documenti raggruppati in ") << dout.items(); iw.set_text(msg); // Messaggio sul cliente
iw.set_text(msg); // Messaggio sul cliente do_events(); // Attende visualizzazione
do_events(); // Attende visualizzazione
int err = dout.write(); // Scrive documenti di output
int err = dout.write(); // Scrive documenti di output if (err == NOERR)
if (err == NOERR) {
{ err = din.rewrite(); // Aggiorna stato dei documenti di input
err = din.rewrite(); // Aggiorna stato dei documenti di input if (err != NOERR)
if (err != NOERR) ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err);
ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err); }
} else
else ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err);
ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err); }
} return ok;
return ok; }
}
void TFatturazione_bolle_app::process_by_cli(const TMask& m)
void TFatturazione_bolle_app::process_by_cli(const TMask& m) {
{ TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const TDate data_elab = m.get_date(F_DATA_ELAB); const int anno = data_elab.year();
const int anno = data_elab.year();
const long dc = m.get_long(F_CODICE_CLIFO_DA);
const long dc = m.get_long(F_CODICE_CLIFO_DA); const long ac = m.get_long(F_CODICE_CLIFO_A);
const long ac = m.get_long(F_CODICE_CLIFO_A); const int da = m.get_int(F_CODICE_AGENTE_DA);
const int da = m.get_int(F_CODICE_AGENTE_DA); const int aa = m.get_int(F_CODICE_AGENTE_A);
const int aa = m.get_int(F_CODICE_AGENTE_A); const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 dz(m.get(F_CODICE_ZONA_DA)); const TString16 az(m.get(F_CODICE_ZONA_A));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA); TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab; const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE); const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA); const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione * e = elab(m.get(F_CODICE_ELAB)); TElaborazione & eld = *e;
TElaborazione & eld = *e; TToken_string tipidoc(24), statidoc(10);
TToken_string tipidoc(24), statidoc(10); eld.tipi_stati_iniziali(tipidoc, statidoc);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
TTipo_documento t(eld.tipo_iniziale(0)); char tipocf(t.tipocf());
char tipocf(t.tipocf()); TLista_cf clienti(tipocf);
TLista_cf clienti(tipocf); const int tot_cli = clienti.leggi(dc, ac, da, aa, dz, az);
const int tot_cli = clienti.leggi(dc, ac, da, aa, dz, az);
TString msg(80);
TString msg(80); for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++) {
{ const long codcli = clienti[c]; // Codice cliente in esame
const long codcli = clienti[c]; // Codice cliente in esame msg = "Elaborazione dei documenti del cliente ";
msg = "Elaborazione dei documenti del cliente "; msg << codcli << " ...";
msg << codcli << " ..."; iw.set_text(msg); // Messaggio sul cliente
iw.set_text(msg); // Messaggio sul cliente do_events(); // Attende visualizzazione
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
TLista_documenti din; // Legge tutti i documenti di input din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an); if (din.items() > 0 && !iw.iscancelled())
if (din.items() > 0 && !iw.iscancelled()) {
{ bool ok = process(iw, eld, din, data_elab);
bool ok = process(iw, eld, din, data_elab); if (!ok) // In caso di errore termina qui l'elaborazione.
if (!ok) // In caso di errore termina qui l'elaborazione. break;
break; }
} }
} delete e;
delete e; }
}
void TFatturazione_bolle_app::process_by_ragsoc(const TMask& m)
void TFatturazione_bolle_app::process_by_ragsoc(const TMask& m) {
{ TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const TDate data_elab = m.get_date(F_DATA_ELAB); const int anno = data_elab.year();
const int anno = data_elab.year();
const TString dr = m.get(F_RAGSOC_CLIFO_DA);
const TString dr = m.get(F_RAGSOC_CLIFO_DA); const TString ar = m.get(F_RAGSOC_CLIFO_A);
const TString ar = m.get(F_RAGSOC_CLIFO_A); const int da = m.get_int(F_CODICE_AGENTE_DA);
const int da = m.get_int(F_CODICE_AGENTE_DA); const int aa = m.get_int(F_CODICE_AGENTE_A);
const int aa = m.get_int(F_CODICE_AGENTE_A); const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 dz(m.get(F_CODICE_ZONA_DA)); const TString16 az(m.get(F_CODICE_ZONA_A));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA); TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab; const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE); const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA); const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione * e = elab(m.get(F_CODICE_ELAB)); TElaborazione & eld = *e;
TElaborazione & eld = *e; TToken_string tipidoc(24), statidoc(10);
TToken_string tipidoc(24), statidoc(10); eld.tipi_stati_iniziali(tipidoc, statidoc);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
TTipo_documento t(eld.tipo_iniziale(0)); char tipocf(t.tipocf());
char tipocf(t.tipocf()); TLista_cf clienti(tipocf);
TLista_cf clienti(tipocf); const int tot_cli = clienti.leggi_ragsoc(dr, ar, da, aa, dz, az);
const int tot_cli = clienti.leggi_ragsoc(dr, ar, da, aa, dz, az);
TString msg(80);
TString msg(80); for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++) {
{ const long codcli = clienti[c]; // Codice cliente in esame
const long codcli = clienti[c]; // Codice cliente in esame msg = "Elaborazione dei documenti del cliente ";
msg = "Elaborazione dei documenti del cliente "; msg << codcli << " ...";
msg << codcli << " ..."; iw.set_text(msg); // Messaggio sul cliente
iw.set_text(msg); // Messaggio sul cliente do_events(); // Attende visualizzazione
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
TLista_documenti din; // Legge tutti i documenti di input din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an); if (din.items() > 0 && !iw.iscancelled())
if (din.items() > 0 && !iw.iscancelled()) {
{ bool ok = process(iw, eld, din, data_elab);
bool ok = process(iw, eld, din, data_elab); if (!ok) // In caso di errore termina qui l'elaborazione.
if (!ok) // In caso di errore termina qui l'elaborazione. break;
break; }
} }
} delete e;
delete e;
}
}
void TFatturazione_bolle_app::process_by_doc(const TMask& m)
void TFatturazione_bolle_app::process_by_doc(const TMask& m) {
{ TIndwin iw(0, TR("Inizializzazione...\n "), TRUE, FALSE, 60);
TIndwin iw(0, TR("Inizializzazione...\n "), TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const TDate data_elab = m.get_date(F_DATA_ELAB); const int anno = data_elab.year();
const int anno = data_elab.year(); long dc = m.get_long(F_CODICE_CLIFO_DA);
long dc = m.get_long(F_CODICE_CLIFO_DA); long ac = m.get_long(F_CODICE_CLIFO_A);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int da = m.get_int(F_CODICE_AGENTE_DA); const int aa = m.get_int(F_CODICE_AGENTE_A);
const int aa = m.get_int(F_CODICE_AGENTE_A); const TString8 dz(m.get(F_CODICE_ZONA_DA));
const TString8 dz(m.get(F_CODICE_ZONA_DA)); const TString8 az(m.get(F_CODICE_ZONA_A));
const TString8 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA); TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A); if (!ad.ok()) ad = data_elab;
if (!ad.ok()) ad = data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE); const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA); const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione * e = elab(m.get(F_CODICE_ELAB)); TElaborazione & eld = *e;
TElaborazione & eld = *e; TToken_string tipidoc(24), statidoc(10);
TToken_string tipidoc(24), statidoc(10); eld.tipi_stati_iniziali(tipidoc, statidoc);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
TTipo_documento t(eld.tipo_iniziale(0)); char tipocf(t.tipocf());
char tipocf(t.tipocf()); TLista_cf clienti(tipocf);
TLista_cf clienti(tipocf); const int tot_cli = clienti.leggi(dc, ac);
const int tot_cli = clienti.leggi(dc, ac); TLista_documenti din, dout; // Legge tutti i documenti di input
TLista_documenti din, dout; // Legge tutti i documenti di input
TString msg(80);
TString msg(80); for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++) {
{ const long codcli = clienti[c]; // Codice cliente in esame
const long codcli = clienti[c]; // Codice cliente in esame msg = TR("Elaborazione dei documenti del cliente");
msg = TR("Elaborazione dei documenti del cliente"); msg << ' ' << codcli << "...";
msg << ' ' << codcli << "..."; iw.set_text(msg); // Messaggio sul cliente
iw.set_text(msg); // Messaggio sul cliente do_events(); // Attende visualizzazione
do_events(); // Attende visualizzazione
if (codcli == 203726)
if (codcli == 203726) int cazzone = 1;
int cazzone = 1;
TLista_documenti list;
TLista_documenti list;
list.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
list.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
for (int i = list.items()-1; i >= 0; i--)
for (int i = list.items()-1; i >= 0; i--) {
{ const TDocumento& doc = list[i];
const TDocumento& doc = list[i];
bool to_del = FALSE;
bool to_del = FALSE; const int agente = doc.get_int(DOC_CODAG);
const int agente = doc.get_int(DOC_CODAG); if (agente > 0)
if (agente > 0) {
{ if (da > 0 && agente < da) to_del = true;
if (da > 0 && agente < da) to_del = true; if (aa > 0 && agente > aa) to_del = true;
if (aa > 0 && agente > aa) to_del = true; }
} const TString8 zona = doc.get(DOC_ZONA);
const TString8 zona = doc.get(DOC_ZONA); if (zona.full())
if (zona.full()) {
{ if (dz.not_empty() && zona < dz) to_del = true;
if (dz.not_empty() && zona < dz) to_del = true; if (az.not_empty() && zona > az) to_del = true;
if (az.not_empty() && zona > az) to_del = true; }
} if (to_del)
if (to_del) list.destroy(i);
list.destroy(i); }
} const int items = list.items();
const int items = list.items(); for (int j = 0; j < items; j++)
for (int j = 0; j < items; j++) din.add(list[j]);
din.add(list[j]); }
} if (din.items() > 0 && !iw.iscancelled())
if (din.items() > 0 && !iw.iscancelled()) bool ok = process(iw, eld, din, data_elab);
bool ok = process(iw, eld, din, data_elab); delete e;
delete e; }
}
void TFatturazione_bolle_app::process_by_fatt(const TMask& m)
void TFatturazione_bolle_app::process_by_fatt(const TMask& m) {
{ TWait_cursor hourglass;
TWait_cursor hourglass;
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TElaborazione* e = elab(m.get(F_CODICE_ELAB)); TElaborazione& eld = *e;
TElaborazione& eld = *e; TToken_string tipidoc(24), statidoc(10);
TToken_string tipidoc(24), statidoc(10); eld.tipi_stati_iniziali(tipidoc, statidoc);
eld.tipi_stati_iniziali(tipidoc, statidoc);
const TTipo_documento t(eld.tipo_iniziale(0));
const TTipo_documento t(eld.tipo_iniziale(0)); const char tipocffatt = t.tipocf() == 'C' ? 'F' : 'C';
const char tipocffatt = t.tipocf() == 'C' ? 'F' : 'C';
const TDate data_elab = m.get_date(F_DATA_ELAB);
const TDate data_elab = m.get_date(F_DATA_ELAB); const int anno = data_elab.year();
const int anno = data_elab.year(); long dc = m.get_long(F_CODICE_CLIFO_DA);
long dc = m.get_long(F_CODICE_CLIFO_DA); long ac = m.get_long(F_CODICE_CLIFO_A);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int da = m.get_int(F_CODICE_AGENTE_DA); const int aa = m.get_int(F_CODICE_AGENTE_A);
const int aa = m.get_int(F_CODICE_AGENTE_A); const TString& dz = m.get(F_CODICE_ZONA_DA);
const TString& dz = m.get(F_CODICE_ZONA_DA); const TString& az = m.get(F_CODICE_ZONA_A);
const TString& az = m.get(F_CODICE_ZONA_A);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE); const long dn = codnum.full() ? m.get_long(F_NUMERO_DOCUMENTO_DA) : 0;
const long dn = codnum.full() ? m.get_long(F_NUMERO_DOCUMENTO_DA) : 0; const long an = codnum.full() ? m.get_long(F_NUMERO_DOCUMENTO_A) : 0;
const long an = codnum.full() ? m.get_long(F_NUMERO_DOCUMENTO_A) : 0;
TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TDate dd = m.get_date(F_DATA_DOCUMENTO_DA); if (!dd.ok())
if (!dd.ok()) dd = TDate(1,1,anno);
dd = TDate(1,1,anno); TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A); if (!ad.ok())
if (!ad.ok()) ad = data_elab;
ad = data_elab;
const int nkey = (dn > 0 || an > 0) ? 1 : 3;
const int nkey = (dn > 0 || an > 0) ? 1 : 3; TString query;
TString query; query << "USE DOC KEY " << nkey << " SELECT (TIPOCFFATT=\"" << tipocffatt << "\")";
query << "USE DOC KEY " << nkey << " SELECT (TIPOCFFATT=\"" << tipocffatt << "\")";
if (dc > 0 || ac > 0)
if (dc > 0 || ac > 0) query << "&&(BETWEEN(CODCFFATT," << dc << ',' << ac << "))";
query << "&&(BETWEEN(CODCFFATT," << dc << ',' << ac << "))";
query << "&&(BETWEEN(DATADOC," << dd.date2ansi() << ',' << ad.date2ansi() << "))";
query << "&&(BETWEEN(DATADOC," << dd.date2ansi() << ',' << ad.date2ansi() << "))";
if (da > 0 || aa > 0)
if (da > 0 || aa > 0) query << "&&(BETWEEN(CODAG," << da << "," << aa << "))";
query << "&&(BETWEEN(CODAG," << da << "," << aa << "))";
if (dz.full() || az.full())
if (dz.full() || az.full()) query << "&&(BETWEEN(ZONA,\"" << dz << "\",\"" << az << "\"))";
query << "&&(BETWEEN(ZONA,\"" << dz << "\",\"" << az << "\"))";
if (nkey == 3 && codnum.full())
if (nkey == 3 && codnum.full()) query << "&&(CODNUM=\"" << codnum << "\")";
query << "&&(CODNUM=\"" << codnum << "\")";
query << "\nBY " << DOC_CODCFFATT;
query << "\nBY " << DOC_CODCFFATT; if (eld.usa_doc_rif())
if (eld.usa_doc_rif()) query << ' ' << DOC_DATADOCRIF;
query << ' ' << DOC_DATADOCRIF;
if (nkey == 1)
if (nkey == 1) {
{ query << "\nFROM PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << dn;
query << "\nFROM PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << dn; query << "\nTO PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << an;
query << "\nTO PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << an; }
} else
else {
{ query << "\nFROM DATADOC=" << dd.date2ansi();
query << "\nFROM DATADOC=" << dd.date2ansi(); query << "\nTO DATADOC=" << ad.date2ansi();
query << "\nTO DATADOC=" << ad.date2ansi(); }
}
TISAM_recordset docs(query);
TISAM_recordset docs(query); const TRectype& head = docs.cursor()->curr();
const TRectype& head = docs.cursor()->curr();
TProgind iw(docs.items(), "Elaborazione documenti da fatturare", true, true);
TProgind iw(docs.items(), "Elaborazione documenti da fatturare", true, true);
long last_clifo = 0; // Ultimo cliente elaborato
long last_clifo = 0; // Ultimo cliente elaborato TLista_documenti din; // Lista dei documenti dell'ultimo cliente
TLista_documenti din; // Lista dei documenti dell'ultimo cliente
for (bool ok = docs.move_first(); ok; ok = docs.move_next())
for (bool ok = docs.move_first(); ok; ok = docs.move_next()) {
{ const long clifo = docs.get(DOC_CODCFFATT).as_int();
const long clifo = docs.get(DOC_CODCFFATT).as_int(); if (clifo > 0 && clifo >= dc && (clifo <= ac || ac <= 0)) // Cliente da fatturare non nullo e valido
if (clifo > 0 && clifo >= dc && (clifo <= ac || ac <= 0)) // Cliente da fatturare non nullo e valido {
{ if (clifo != last_clifo) // Cambio cliente
if (clifo != last_clifo) // Cambio cliente {
{ if (din.items() > 0) // Ci sono documenti da elaborare?
if (din.items() > 0) // Ci sono documenti da elaborare? {
{ process(iw, eld, din, data_elab); // Elaborali ...
process(iw, eld, din, data_elab); // Elaborali ... din.destroy(-1); // ... e poi buttali
din.destroy(-1); // ... e poi buttali }
} last_clifo = clifo;
last_clifo = clifo; }
}
if (!iw.addstatus(1))
if (!iw.addstatus(1)) break;
break;
// Controlla se il documento e' in uno stato valido per l'elaborazione
// Controlla se il documento e' in uno stato valido per l'elaborazione const TString4 tipodoc = head.get(DOC_TIPODOC);
const TString4 tipodoc = head.get(DOC_TIPODOC); const TString4 statodoc = head.get(DOC_STATO);
const TString4 statodoc = head.get(DOC_STATO); for (int i = tipidoc.items()-1; i>=0; i--)
for (int i = tipidoc.items()-1; i>=0; i--) {
{ if (tipodoc == tipidoc.get(i) && statodoc == statidoc.get(i))
if (tipodoc == tipidoc.get(i) && statodoc == statidoc.get(i)) {
{ din.add(head);
din.add(head); break;
break; }
} }
} }
} }
}
// Termina l'elaborazione dei documenti dell'ultimo cliente
// Termina l'elaborazione dei documenti dell'ultimo cliente if (din.items() > 0 && !iw.iscancelled())
if (din.items() > 0 && !iw.iscancelled()) process(iw, eld, din, data_elab);
process(iw, eld, din, data_elab);
delete e;
delete e; }
}
bool TFatturazione_bolle_app::clifo_da_fatt(const TMask& m) const
bool TFatturazione_bolle_app::clifo_da_fatt(const TMask& m) const {
{ TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TElaborazione* e = elab(m.get(F_CODICE_ELAB)); TFatturazione_bolle& eld = *(TFatturazione_bolle*)e;
TFatturazione_bolle& eld = *(TFatturazione_bolle*)e;
const bool yes = eld.change_clifo();
const bool yes = eld.change_clifo();
delete e;
delete e;
return yes;
return yes; }
}
void TFatturazione_bolle_app::main_loop()
void TFatturazione_bolle_app::main_loop() {
{ TMask m("ve6200a");
TMask m("ve6200a"); m.set(F_SELEZIONE, _default_selection);
m.set(F_SELEZIONE, _default_selection);
while (m.run() == K_ENTER)
while (m.run() == K_ENTER) {
{ const TString& select_from = m.get(F_SELEZIONE);
const TString& select_from = m.get(F_SELEZIONE); if (select_from != _default_selection)
if (select_from != _default_selection) {
{ TConfig cfg(CONFIG_DITTA, "ve");
TConfig cfg(CONFIG_DITTA, "ve"); cfg.set("FATBOLSEL", _default_selection = select_from);
cfg.set("FATBOLSEL", _default_selection = select_from); }
}
if (m.get(F_ORDINAMENTO) == "R")
if (m.get(F_ORDINAMENTO) == "R") process_by_ragsoc(m);
process_by_ragsoc(m); else
else {
{ if (clifo_da_fatt(m))
if (clifo_da_fatt(m)) {
{ process_by_fatt(m);
process_by_fatt(m); }
} else
else {
{ if (select_from == "D")
if (select_from == "D") process_by_doc(m);
process_by_doc(m); else
else process_by_cli(m);
process_by_cli(m); }
} }
} }
} }
}
int ve6200 (int argc, char **argv)
int ve6200 (int argc, char **argv) {
{ TFatturazione_bolle_app a;
TFatturazione_bolle_app a; a.run (argc, argv, TR("Fatturazione Bolle"));
a.run (argc, argv, TR("Fatturazione Bolle")); return TRUE;
return TRUE; }
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,98 +1,102 @@
#include "wxinc.h" #include "wxinc.h"
#include "xvt.h" #include "xvt.h"
#include "../../ssa/h/ssadll.h"
#include "../../ssa/h/ssaerr.h" #include "../../ssa/h/ssadll.h"
#include "../../ssa/h/ssaerr.h"
//#define SSA_MOD_NOTFOUND -201
//#define SSA_NO_LOGIN -301 #include <errno.h>
static int _ssa_serial = SSA_UTENTE_NON_LOGGATO; static int _ssa_serial = SSA_UTENTE_NON_LOGGATO;
static wxString _ssa_module; static wxString _ssa_module;
static const char* xvt_dongle_sa_id() static const char* xvt_dongle_sa_id()
{ {
static char id[80]; static char id[80];
if (!*id) if (!*id)
{ {
char user[32], host[32]; char user[32], host[32];
const int sess = xvt_sys_get_session_id(); const int sess = xvt_sys_get_session_id();
xvt_sys_get_user_name(user, sizeof(user)); xvt_sys_get_user_name(user, sizeof(user));
xvt_sys_get_host_name(host, sizeof(host)); xvt_sys_get_host_name(host, sizeof(host));
sprintf(id, "%s@%s:%d", user, host, sess); sprintf(id, "%s@%s:%d", user, host, sess);
} }
return id; return id;
} }
int xvt_dongle_sa_login(const char* module) int xvt_dongle_sa_login(const char* module)
{ {
int err = _ssa_serial; int err = _ssa_serial;
if (_ssa_serial < 0) const int nAssYear = xvt_vobj_get_attr(NULL_WIN, ATTR_APPL_VERSION_YEAR);
{ if (nAssYear > 2091)
err = SSA_Login(xvt_dongle_sa_id(), "Campo"); {
if (err == 0) if (_ssa_serial < 0)
err = _ssa_serial = SSA_NumeroSerie("Campo"); {
} err = SSA_Login(xvt_dongle_sa_id(), "Campo");
if (err == 0)
if (_ssa_serial >= 0 && module && *module) err = _ssa_serial = SSA_NumeroSerie("Campo");
{ }
err = SSA_ApriModulo(xvt_dongle_sa_id(), module);
if (err == 0) if (_ssa_serial >= 0 && module && *module)
{ {
if (!_ssa_module.IsEmpty()) err = SSA_ApriModulo(xvt_dongle_sa_id(), module);
xvt_dongle_sa_logout(_ssa_module); if (err == 0)
_ssa_module = module; {
} if (!_ssa_module.IsEmpty())
} xvt_dongle_sa_logout(_ssa_module);
_ssa_module = module;
return err; }
} }
}
int xvt_dongle_sa_crypt(unsigned short* data)
{ return err;
if (_ssa_serial < 0) }
return SSA_UTENTE_NON_LOGGATO;
if (data == NULL) int xvt_dongle_sa_crypt(unsigned short* data)
return -ENOMEM; {
data[0] ^= 0xDEAD; if (_ssa_serial < 0)
data[1] ^= 0xBEEF; return SSA_UTENTE_NON_LOGGATO;
data[2] ^= 0xDEAD; if (data == NULL)
data[3] ^= 0xBEEF; return -EACCES;
return 0; data[0] ^= 0xDEAD;
} data[1] ^= 0xBEEF;
data[2] ^= 0xDEAD;
int xvt_dongle_sa_logout(const char* module) data[3] ^= 0xBEEF;
{ return 0;
int err = SSA_UTENTE_NON_LOGGATO; }
if (_ssa_serial >= 0)
{ int xvt_dongle_sa_logout(const char* module)
if (module && *module) {
{ int err = SSA_UTENTE_NON_LOGGATO;
if (_ssa_module == module) if (_ssa_serial >= 0)
{ {
err = SSA_ChiudiModulo(xvt_dongle_sa_id(), _ssa_module); if (module && *module)
_ssa_module.Empty(); {
} if (_ssa_module == module)
else {
err = SSA_MOD_NOTFOUND; err = SSA_ChiudiModulo(xvt_dongle_sa_id(), _ssa_module);
} _ssa_module.Empty();
else }
{ else
err = SSA_Logout(xvt_dongle_sa_id(), "Campo"); err = SSA_MOD_NOTFOUND;
if (err == 0) }
{ else
_ssa_serial = SSA_UTENTE_NON_LOGGATO; {
_ssa_module.Empty(); err = SSA_Logout(xvt_dongle_sa_id(), "Campo");
} if (err == 0)
} {
} _ssa_serial = SSA_UTENTE_NON_LOGGATO;
return err; _ssa_module.Empty();
} }
}
int xvt_dongle_sa_test(const char* module) }
{ return err;
int err = _ssa_serial; }
if (err >= 0 && module && *module)
err = SSA_VerificaModulo("Campo", module); int xvt_dongle_sa_test(const char* module)
return err; {
} int err = _ssa_serial;
if (err >= 0 && module && *module)
err = SSA_VerificaModulo("Campo", module);
return err;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff