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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

View File

@ -1,222 +1,243 @@
#include <applicat.h>
#include <msksheet.h>
#include <relation.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
{
TMask *_msk;
TRelation *_rel;
TRectype *_from, *_to;
virtual bool create() ;
virtual bool destroy() ;
virtual void main_loop();
protected:
static bool from_numero_handler(TMask_field& f, KEY k);
static bool to_numero_handler(TMask_field& f, KEY k);
static bool from_data_handler(TMask_field& f, KEY k);
static bool to_data_handler(TMask_field& f, KEY k);
static bool conferma_handler(TMask_field& f, KEY k);
static bool annulla_handler(TMask_field& f, KEY k);
static void elimina();
public:
TEliminazione_effetti() {};
virtual ~TEliminazione_effetti() {};
};
// restituisce un riferimento all' applicazione
inline TEliminazione_effetti& app(){return (TEliminazione_effetti&)main_app();}
// crea l'applicazione
bool TEliminazione_effetti::create()
{
_msk = new TMask("ef0400a");
_rel = new TRelation(LF_EFFETTI);
_rel->first();
_from = new TRectype(_rel->lfile().curr());
_rel->last();
_to = new TRectype(_rel->lfile().curr());
_msk->set_handler(F_DA_RIBA, from_numero_handler);
_msk->set_handler(F_A_RIBA, to_numero_handler);
_msk->set_handler(F_DA_DATA, from_data_handler);
_msk->set_handler(F_A_DATA, to_data_handler);
_msk->set_handler(DLG_OK, conferma_handler);
_msk->set_handler(DLG_CANCEL, annulla_handler);
return TSkeleton_application::create();
}
// distrugge l'applicazione
bool TEliminazione_effetti::destroy()
{
delete _msk;
delete _rel;
delete _from;
delete _to;
return TRUE;
}
//Carica maschera eliminazione effetti
void TEliminazione_effetti::main_loop()
{
KEY key = K_ENTER;
while (key != K_QUIT)//finchè non si chiude la maschera
{
_msk->reset();
key = _msk->run();
}
}
//Handler per la gestione della prima chiave (from) del cursore per numero
bool TEliminazione_effetti::from_numero_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* from = app()._from;
long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num);
}
}
return TRUE;
}
//Handler per la gestione della seconda chiave (to) del cursore per numero
bool TEliminazione_effetti::to_numero_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* to = app()._to;
long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num);
}
}
return TRUE;
}
//Handler per la gestione della prima chiave (from) del cursore per data
bool TEliminazione_effetti::from_data_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* from = app()._from;
TDate data = m.get(F_DA_DATA);
long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num);
from->put(EFF_DATASCAD, data);
}
}
return TRUE;
}
//Handler per la gestione della seconda chiave (to) del cursore per numero
bool TEliminazione_effetti::to_data_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* to = app()._to;
TDate data = m.get(F_A_DATA);
long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num);
to->put(EFF_DATASCAD, data);
}
}
return TRUE;
}
// Si effettua l'istanziazione del cursore e si eliminano gli effetti che vi
// appartengono
void TEliminazione_effetti::elimina()
{
const TRectype *from = app()._from;
const TRectype *to = app()._to;
TMask *m = app()._msk;
TRelation *rel = app()._rel;
TString filter;
int key;
char op1 = m->get(F_TIPOSEL)[0];
char op2 = m->get(F_TIPODIST)[0];
char op3 = m->get(F_TIPOCANC)[0];
switch (op1) //scelgo la chiave per il cursore
{
case 'N': //selezione effetti per numero
key = 1;
break;
case 'D': //selezione effetti per data
key = 3;
break;
}
//scelgo il filtro per il cursore
filter << "(TIPOCF=\"" << op2 << "\")";
if (op2 == 'C')
filter << "||(TIPOCF=\"\")";
switch (op3)
{
case 'S': //cancello effetti stampati
filter << "&&(EFFSTAMP=\"X\")";
break;
case 'C': //cancello effetti contabilizzati
filter << "&&(EFFCONT=\"X\")";
break;
default : //cancello tutti gli effetti
break;
}
TCursor cur(rel,filter,key,from,to); // istanzio il cursore
TLocalisamfile& delfile = cur.file();// prendo un riferimento al file
long n = cur.items();// prendo il numero di elementi del cursore
cur.freeze();// congelo lo stato del cursore
for (cur=0; cur.pos() < n; ++cur)// scandisco tutti gli elementi del cursore
{
TEffetto eff(delfile.curr());// istanzio un effetto
eff.remove(delfile); // e lo cancello
}
}
//Handler per gestire la conferma della cancellazione degli effetti
bool TEliminazione_effetti::conferma_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_SPACE)
{
if (yesno_box(TR("Si desidera veramente eliminare gli effetti selezionati")))
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;
}
#include <applicat.h>
#include <msksheet.h>
#include <progind.h>
#include <recset.h>
#include <relation.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
{
TMask *_msk;
TRelation *_rel;
TRectype *_from, *_to;
virtual bool create() ;
virtual bool destroy() ;
virtual void main_loop();
protected:
static bool from_numero_handler(TMask_field& f, KEY k);
static bool to_numero_handler(TMask_field& f, KEY k);
static bool from_data_handler(TMask_field& f, KEY k);
static bool to_data_handler(TMask_field& f, KEY k);
static bool conferma_handler(TMask_field& f, KEY k);
static bool annulla_handler(TMask_field& f, KEY k);
static void elimina();
static void elimina_orfani(const TRectype* from);
};
// restituisce un riferimento all' applicazione
inline TEliminazione_effetti& app(){return (TEliminazione_effetti&)main_app();}
// crea l'applicazione
bool TEliminazione_effetti::create()
{
_msk = new TMask("ef0400a");
_rel = new TRelation(LF_EFFETTI);
_rel->first();
_from = new TRectype(_rel->lfile().curr());
_rel->last();
_to = new TRectype(_rel->lfile().curr());
_msk->set_handler(F_DA_RIBA, from_numero_handler);
_msk->set_handler(F_A_RIBA, to_numero_handler);
_msk->set_handler(F_DA_DATA, from_data_handler);
_msk->set_handler(F_A_DATA, to_data_handler);
_msk->set_handler(DLG_OK, conferma_handler);
_msk->set_handler(DLG_CANCEL, annulla_handler);
return TSkeleton_application::create();
}
// distrugge l'applicazione
bool TEliminazione_effetti::destroy()
{
delete _msk;
delete _rel;
delete _from;
delete _to;
return TRUE;
}
//Carica maschera eliminazione effetti
void TEliminazione_effetti::main_loop()
{
KEY key = K_ENTER;
while (key != K_QUIT)//finchè non si chiude la maschera
{
_msk->reset();
key = _msk->run();
}
}
//Handler per la gestione della prima chiave (from) del cursore per numero
bool TEliminazione_effetti::from_numero_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* from = app()._from;
long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num);
}
}
return TRUE;
}
//Handler per la gestione della seconda chiave (to) del cursore per numero
bool TEliminazione_effetti::to_numero_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* to = app()._to;
long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num);
}
}
return TRUE;
}
//Handler per la gestione della prima chiave (from) del cursore per data
bool TEliminazione_effetti::from_data_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* from = app()._from;
TDate data = m.get(F_DA_DATA);
long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num);
from->put(EFF_DATASCAD, data);
}
}
return TRUE;
}
//Handler per la gestione della seconda chiave (to) del cursore per numero
bool TEliminazione_effetti::to_data_handler(TMask_field& f, KEY k)
{
TMask &m = f.mask();
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* to = app()._to;
TDate data = m.get(F_A_DATA);
long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num);
to->put(EFF_DATASCAD, data);
}
}
return TRUE;
}
void TEliminazione_effetti::elimina_orfani(const TRectype* from)
{
TString query = "USE REFFETTI SELECT 31.NPROGTR=0\nJOIN 31 INTO NPROGTR==NPROGTR\n";
if (from && !from->empty())
query << "\nFROM NPROGTR=" << from->get("NPROGTR");
TISAM_recordset orfani(query);
TLocalisamfile& f = orfani.cursor()->file();
for (bool ok = orfani.move_first(); ok; ok = orfani.move_next())
f.remove();
}
// Si effettua l'istanziazione del cursore e si eliminano gli effetti che vi
// appartengono
void TEliminazione_effetti::elimina()
{
const TRectype *from = app()._from;
const TRectype *to = app()._to;
TMask *m = app()._msk;
TRelation *rel = app()._rel;
TString filter;
int key;
char op1 = m->get(F_TIPOSEL)[0];
char op2 = m->get(F_TIPODIST)[0];
char op3 = m->get(F_TIPOCANC)[0];
switch (op1) //scelgo la chiave per il cursore
{
case 'N': //selezione effetti per numero
key = 1;
break;
case 'D': //selezione effetti per data
key = 3;
break;
}
//scelgo il filtro per il cursore
filter << "(TIPOCF=\"" << op2 << "\")";
if (op2 == 'C')
filter << "||(TIPOCF=\"\")";
switch (op3)
{
case 'S': //cancello effetti stampati
filter << "&&(EFFSTAMP=\"X\")";
break;
case 'C': //cancello effetti contabilizzati
filter << "&&(EFFCONT=\"X\")";
break;
default : //cancello tutti gli effetti
break;
}
TCursor cur(rel,filter,key,from,to); // istanzio il cursore
const long n = cur.items();// prendo il numero di elementi del cursore
if (n > 0)
{
if (noyes_box(TR("Si desidera veramente eliminare %ld effetti?"), n))
{
TLocalisamfile& delfile = cur.file();// prendo un riferimento al file
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
{
if (!pi.addstatus(1))
break;
TEffetto eff(delfile.curr());// istanzio un effetto
eff.remove(delfile); // e lo cancello
}
elimina_orfani(from);
}
}
else
warning_box(TR("Non sono stati selezionati effetti da eliminare"));
}
//Handler per gestire la conferma della cancellazione degli effetti
bool TEliminazione_effetti::conferma_handler(TMask_field& f, KEY k)
{
if (k == K_SPACE)
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
#include "ef0400.h"
TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_OK 9 2
BEGIN
PROMPT -13 -1 ""
END
BUTTON DLG_CANCEL 9 2
BEGIN
PROMPT -23 -1 ""
END
#include <helpbar.h>
ENDPAGE
PAGE "Eliminazione Effetti" 0 2 0 0
LIST F_TIPOSEL 20
BEGIN
PROMPT 2 1 "Tipo Selezione "
ITEM "N|Numero progressivo"
MESSAGE DISABLE,2@
MESSAGE ENABLE,1@
ITEM "D|Data scadenza"
MESSAGE DISABLE,1@
MESSAGE ENABLE,2@
END
LIST F_TIPODIST 20
BEGIN
PROMPT 2 2 "Tipo Effetti "
ITEM "C|Attivi"
ITEM "F|Passivi"
END
LIST F_TIPOCANC 20
BEGIN
PROMPT 2 3 "Tipo Cancellazione "
ITEM "T|Tutti"
ITEM "S|Stampati"
ITEM "C|Contabilizzati"
END
GROUPBOX DLG_NULL 55 3
BEGIN
PROMPT 1 5 "Selezione effetti per numero progressivo"
GROUP 1
END
NUMBER F_DA_RIBA 7 0
BEGIN
PROMPT 2 6 "Dalla Riba "
GROUP 1
FIELD LF_EFFETTI->NPROGTR
USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT NPROGTR F_DA_RIBA
DISPLAY "Nr. progressivo" NPROGTR
DISPLAY "Data scadenza" DATASCAD
OUTPUT F_DA_RIBA NPROGTR
// CHECKTYPE NORMAL
END
NUMBER F_A_RIBA 7 0
BEGIN
PROMPT 30 6 "Alla Riba "
GROUP 1
FIELD LF_EFFETTI->NPROGTR
USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT NPROGTR F_A_RIBA
DISPLAY "Nr. progressivo" NPROGTR
DISPLAY "Data scadenza" DATASCAD
OUTPUT F_A_RIBA NPROGTR
// CHECKTYPE NORMAL
NUM_EXPR {#THIS_FIELD>=#F_DA_RIBA}
WARNING "Limite superiore non valido"
END
GROUPBOX DLG_NULL 55 3
BEGIN
PROMPT 1 9 "Selezione effetti per data scadenza"
GROUP 2
END
DATA F_DA_DATA
BEGIN
PROMPT 2 10 "Dalla Data "
GROUP 2
FIELD LF_EFFETTI->DATASCAD
USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT DATASCAD F_DA_DATA
DISPLAY "Data scadenza" DATASCAD
DISPLAY "Nr. progressivo" NPROGTR
OUTPUT F_DA_DATA DATASCAD
OUTPUT F_DA_RIBA NPROGTR
//CHECKTYPE NORMAL
END
DATA F_A_DATA
BEGIN
PROMPT 30 10 "Alla Data "
GROUP 2
FIELD LF_EFFETTI->DATASCAD
USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT DATASCAD F_A_DATA
DISPLAY "Data scadenza" DATASCAD
DISPLAY "Nr. progressivo" NPROGTR
OUTPUT F_A_DATA DATASCAD
OUTPUT F_A_RIBA NPROGTR
//CHECKTYPE NORMAL
VALIDATE DATE_CMP_FUNC >= F_DA_DATA
WARNING "Data limite superiore non valida"
END
ENDPAGE
ENDMASK
// DEFINIZIONE MASCHERA PER LA ELIMINAZIONE DEGLI EFFETTI
#include "ef0400.h"
TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_OK 9 2
BEGIN
PROMPT -13 -1 ""
END
BUTTON DLG_CANCEL 9 2
BEGIN
PROMPT -23 -1 ""
END
#include <helpbar.h>
ENDPAGE
PAGE "Eliminazione Effetti" 0 2 0 0
LIST F_TIPOSEL 20
BEGIN
PROMPT 2 1 "Tipo Selezione "
ITEM "N|Numero progressivo"
MESSAGE DISABLE,2@
MESSAGE ENABLE,1@
ITEM "D|Data scadenza"
MESSAGE DISABLE,1@
MESSAGE ENABLE,2@
END
LIST F_TIPODIST 20
BEGIN
PROMPT 2 2 "Tipo Effetti "
ITEM "C|Attivi"
ITEM "F|Passivi"
END
LIST F_TIPOCANC 20
BEGIN
PROMPT 2 3 "Tipo Cancellazione "
ITEM "T|Tutti"
ITEM "S|Stampati"
ITEM "C|Contabilizzati"
END
GROUPBOX DLG_NULL 55 3
BEGIN
PROMPT 1 5 "Selezione effetti per numero progressivo"
GROUP 1
END
NUMBER F_DA_RIBA 7 0
BEGIN
PROMPT 2 6 "Dalla Riba "
GROUP 1
FIELD LF_EFFETTI->NPROGTR
USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT NPROGTR F_DA_RIBA
DISPLAY "Nr. progressivo" NPROGTR
DISPLAY "Data scadenza" DATASCAD
OUTPUT F_DA_RIBA NPROGTR
// CHECKTYPE NORMAL
END
NUMBER F_A_RIBA 7 0
BEGIN
PROMPT 30 6 "Alla Riba "
GROUP 1
FIELD LF_EFFETTI->NPROGTR
USE LF_EFFETTI SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT NPROGTR F_A_RIBA
DISPLAY "Nr. progressivo" NPROGTR
DISPLAY "Data scadenza" DATASCAD
OUTPUT F_A_RIBA NPROGTR
// CHECKTYPE NORMAL
NUM_EXPR (#THIS_FIELD==0)||(#THIS_FIELD>=#F_DA_RIBA)
WARNING "Limite superiore non valido"
END
GROUPBOX DLG_NULL 55 3
BEGIN
PROMPT 1 9 "Selezione effetti per data scadenza"
GROUP 2
END
DATA F_DA_DATA
BEGIN
PROMPT 2 10 "Dalla Data "
GROUP 2
FIELD LF_EFFETTI->DATASCAD
USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT DATASCAD F_DA_DATA
DISPLAY "Data scadenza" DATASCAD
DISPLAY "Nr. progressivo" NPROGTR
OUTPUT F_DA_DATA DATASCAD
OUTPUT F_DA_RIBA NPROGTR
//CHECKTYPE NORMAL
END
DATA F_A_DATA
BEGIN
PROMPT 30 10 "Alla Data "
GROUP 2
FIELD LF_EFFETTI->DATASCAD
USE LF_EFFETTI KEY 3 SELECT (TIPOCF=#F_TIPODIST)||((TIPOCF="")&&(#F_TIPODIST="C"))
INPUT DATASCAD F_A_DATA
DISPLAY "Data scadenza" DATASCAD
DISPLAY "Nr. progressivo" NPROGTR
OUTPUT F_A_DATA DATASCAD
OUTPUT F_A_RIBA NPROGTR
//CHECKTYPE NORMAL
VALIDATE DATE_CMP_FUNC >= F_DA_DATA
WARNING "Data limite superiore non valida"
END
ENDPAGE
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
#define __DOC_H
#define DOC_CODNUM "CODNUM"
#define DOC_ANNO "ANNO"
#define DOC_PROVV "PROVV"
#define DOC_NDOC "NDOC"
#define DOC_TIPODOC "TIPODOC"
#define DOC_STATO "STATO"
#define DOC_DATADOC "DATADOC"
#define DOC_TIPOCF "TIPOCF"
#define DOC_CODCF "CODCF"
#define DOC_OCFPI "OCFPI"
#define DOC_OCCAS "OCCAS"
#define DOC_CODVAL "CODVAL"
#define DOC_CONTROEURO "CONTROEURO"
#define DOC_CAMBIO "CAMBIO"
#define DOC_DATACAMBIO "DATACAMBIO"
#define DOC_CODLIN "CODLIN"
#define DOC_RAGGR "RAGGR"
#define DOC_CODPAG "CODPAG"
#define DOC_DATAINSC "DATAINSC"
#define DOC_CODABIA "CODABIA"
#define DOC_CODCABA "CODCABA"
#define DOC_IBAN "IBAN"
#define DOC_CODABIP "CODABIP"
#define DOC_CODCABP "CODCABP"
#define DOC_PROGBNP "PROGBNP"
#define DOC_CATVEN "CATVEN"
#define DOC_CODLIST "CODLIST"
#define DOC_CODCONT "CODCONT"
#define DOC_CODCAMP "CODCAMP"
#define DOC_SCONTOPERC "SCONTOPERC"
#define DOC_CODINDSP "CODINDSP"
#define DOC_DATADOCRIF "DATADOCRIF"
#define DOC_NUMDOCRIF "NUMDOCRIF"
#define DOC_ZONA "ZONA"
#define DOC_CODAG "CODAG"
#define DOC_CODAGVIS "CODAGVIS"
#define DOC_CODSPMEZZO "CODSPMEZZO"
#define DOC_CODPORTO "CODPORTO"
#define DOC_CODNOTESP1 "CODNOTESP1"
#define DOC_CODNOTESP2 "CODNOTESP2"
#define DOC_CAUSTRASP "CAUSTRASP"
#define DOC_CODVETT1 "CODVETT1"
#define DOC_CODVETT2 "CODVETT2"
#define DOC_CODVETT3 "CODVETT3"
#define DOC_NCOPIE "NCOPIE"
#define DOC_DATAPART "DATAPART"
#define DOC_ORAPART "ORAPART"
#define DOC_IMPPAGATO "IMPPAGATO"
#define DOC_ACCSALDO "ACCSALDO"
#define DOC_DOC1 "DOC1"
#define DOC_DOC2 "DOC2"
#define DOC_DOC3 "DOC3"
#define DOC_DATACONS "DATACONS"
#define DOC_ASPBENI1 "ASPBENI1"
#define DOC_ASPBENI2 "ASPBENI2"
#define DOC_IMPNETTI "IMPNETTI"
#define DOC_RAGGREFF "RAGGREFF"
#define DOC_PERCSPINC "PERCSPINC"
#define DOC_ADDBOLLI "ADDBOLLI"
#define DOC_UMTARA "UMTARA"
#define DOC_TARA "TARA"
#define DOC_UMPNETTO "UMPNETTO"
#define DOC_PNETTO "PNETTO"
#define DOC_NCOLLI "NCOLLI"
#define DOC_CAUSMAG "CAUSMAG"
#define DOC_MOVMAG "MOVMAG"
#define DOC_CODNOTE "CODNOTE"
#define DOC_NOTE "NOTE"
#define DOC_G1 "G1"
#define DOC_DATAAGG "DATAAGG"
#define DOC_UTENTE "UTENTE"
#define DOC_DOCEVASO "DOCEVASO"
#define DOC_CONTROEURO "CONTROEURO"
#define DOC_CODCMS "CODCMS"
#define DOC_FASCMS "FASCMS"
#define DOC_CODCOSTO "CODCOSTO"
#define DOC_NUMREG "NUMREG"
#define DOC_NUMANT "NUMANT"
#define DOC_NUMREGCA "NUMREGCA"
#define DOC_TIPOCFFATT "TIPOCFFATT"
#define DOC_CODCFFATT "CODCFFATT"
#define DOC_LIQDIFF "LIQDIFF"
#define DOC_DATACOMP "DATACOMP"
#define DOC_DATAFCOMP "DATAFCOMP"
#define DOC_CUP "CUP"
#define DOC_CIG "CIG"
#define DOC_CONTRATTO "CONTRATTO"
#define DOC_MODPAG "MODPAG"
#define DOC_CONTSEP "CONTSEP"
#define DOC_CONTRATTO "CONTRATTO"
#define DOC_MODPAG "MODPAG"
// Virtuali
// modulo pe
#define DOC_SPESEUPD "SPESEUPD"
#define DOC_USEK "USEK"
#define DOC_K "K"
#endif
#ifndef __DOC_H
#define __DOC_H
#define DOC_CODNUM "CODNUM"
#define DOC_ANNO "ANNO"
#define DOC_PROVV "PROVV"
#define DOC_NDOC "NDOC"
#define DOC_TIPODOC "TIPODOC"
#define DOC_STATO "STATO"
#define DOC_DATADOC "DATADOC"
#define DOC_TIPOCF "TIPOCF"
#define DOC_CODCF "CODCF"
#define DOC_OCFPI "OCFPI"
#define DOC_OCCAS "OCCAS"
#define DOC_CODVAL "CODVAL"
#define DOC_CONTROEURO "CONTROEURO"
#define DOC_CAMBIO "CAMBIO"
#define DOC_DATACAMBIO "DATACAMBIO"
#define DOC_CODLIN "CODLIN"
#define DOC_RAGGR "RAGGR"
#define DOC_CODPAG "CODPAG"
#define DOC_DATAINSC "DATAINSC"
#define DOC_CODABIA "CODABIA"
#define DOC_CODCABA "CODCABA"
#define DOC_IBAN "IBAN"
#define DOC_CODABIP "CODABIP"
#define DOC_CODCABP "CODCABP"
#define DOC_PROGBNP "PROGBNP"
#define DOC_CATVEN "CATVEN"
#define DOC_CODLIST "CODLIST"
#define DOC_CODCONT "CODCONT"
#define DOC_CODCAMP "CODCAMP"
#define DOC_SCONTOPERC "SCONTOPERC"
#define DOC_CODINDSP "CODINDSP"
#define DOC_DATADOCRIF "DATADOCRIF"
#define DOC_NUMDOCRIF "NUMDOCRIF"
#define DOC_ZONA "ZONA"
#define DOC_CODAG "CODAG"
#define DOC_CODAGVIS "CODAGVIS"
#define DOC_CODSPMEZZO "CODSPMEZZO"
#define DOC_CODPORTO "CODPORTO"
#define DOC_CODNOTESP1 "CODNOTESP1"
#define DOC_CODNOTESP2 "CODNOTESP2"
#define DOC_CAUSTRASP "CAUSTRASP"
#define DOC_CODVETT1 "CODVETT1"
#define DOC_CODVETT2 "CODVETT2"
#define DOC_CODVETT3 "CODVETT3"
#define DOC_NCOPIE "NCOPIE"
#define DOC_DATAPART "DATAPART"
#define DOC_ORAPART "ORAPART"
#define DOC_IMPPAGATO "IMPPAGATO"
#define DOC_ACCSALDO "ACCSALDO"
#define DOC_DOC1 "DOC1"
#define DOC_DOC2 "DOC2"
#define DOC_DOC3 "DOC3"
#define DOC_DATACONS "DATACONS"
#define DOC_ASPBENI1 "ASPBENI1"
#define DOC_ASPBENI2 "ASPBENI2"
#define DOC_IMPNETTI "IMPNETTI"
#define DOC_RAGGREFF "RAGGREFF"
#define DOC_PERCSPINC "PERCSPINC"
#define DOC_ADDBOLLI "ADDBOLLI"
#define DOC_UMTARA "UMTARA"
#define DOC_TARA "TARA"
#define DOC_UMPNETTO "UMPNETTO"
#define DOC_PNETTO "PNETTO"
#define DOC_NCOLLI "NCOLLI"
#define DOC_CAUSMAG "CAUSMAG"
#define DOC_MOVMAG "MOVMAG"
#define DOC_CODNOTE "CODNOTE"
#define DOC_NOTE "NOTE"
#define DOC_G1 "G1"
#define DOC_DATAAGG "DATAAGG"
#define DOC_UTENTE "UTENTE"
#define DOC_DOCEVASO "DOCEVASO"
#define DOC_CONTROEURO "CONTROEURO"
#define DOC_CODCMS "CODCMS"
#define DOC_FASCMS "FASCMS"
#define DOC_CODCOSTO "CODCOSTO"
#define DOC_NUMREG "NUMREG"
#define DOC_NUMANT "NUMANT"
#define DOC_NUMREGCA "NUMREGCA"
#define DOC_TIPOCFFATT "TIPOCFFATT"
#define DOC_CODCFFATT "CODCFFATT"
#define DOC_LIQDIFF "LIQDIFF"
#define DOC_DATACOMP "DATACOMP"
#define DOC_DATAFCOMP "DATAFCOMP"
#define DOC_CUP "CUP"
#define DOC_CIG "CIG"
#define DOC_CONTRATTO "CONTRATTO"
#define DOC_MODPAG "MODPAG"
#define DOC_CONTSEP "CONTSEP"
#define DOC_CONTRATTO "CONTRATTO"
#define DOC_MODPAG "MODPAG"
// Virtuali
// modulo pe
#define DOC_SPESEUPD "SPESEUPD"
#define DOC_USEK "USEK"
#define DOC_K "K"
#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 "../cg/cgsalda3.h"
#include <applicat.h>
#include <automask.h>
#include <recset.h>
#include <relation.h>
#include <treectrl.h>
class TPareggio_tree : public TObject_tree
{
protected:
virtual TFieldtypes get_var(const TString& name, TVariant& var) const;
virtual bool marked() const { return rand() % 2 != 0; }
public:
bool init(const TBill& bill, const TString& valuta, bool nc, int stato); // Stato- 1=aperte; 2=chiuse; 0 o 3 = tutte
};
TFieldtypes TPareggio_tree::get_var(const TString& name, TVariant& var) const
{
TFieldtypes ft = _nullfld;
const TObject* obj = curr_node();
if (obj != NULL)
{
if (obj->is_kind_of(CLASS_RECTYPE))
{
const TRectype& rec = *(const TRectype*)obj;
ft = rec.type(name);
if (ft != _nullfld)
{
if (ft == _realfld)
{
var = rec.get_real(name).stringa(0, 2);
ft = _alfafld;
}
else
var = rec.get(name);
}
else
{
if (name == PART_DATADOC)
{
if (rec.num() == LF_SCADENZE)
{
var = rec.get_date(SCAD_DATASCAD);
ft = _datefld;
}
} else
if (name == "RESIDUO")
{
TImporto saldo;
switch (rec.num())
{
case LF_SCADENZE:
if (!rec.get_bool(SCAD_PAGATA))
{
const TPartita game(rec);
const TRiga_scadenze& s = game.rata(rec.get_int(SCAD_NRIGA), rec.get_int(SCAD_NRATA));
saldo = s.residuo(true);
}
break;
case LF_PARTITE:
if (!rec.get_bool(PART_CHIUSA))
{
const TPartita game(rec);
saldo = game.calcola_saldo(true);
}
break;
default:
break;
}
var = saldo.valore().stringa(0, 2);
ft = _alfafld;
}
}
}
else
{
if (name == PART_NUMPART)
{
const real& year = *(real*)obj;
var = year.integer();
ft = _intfld;
}
}
}
return ft;
}
bool TPareggio_tree::init(const TBill& bill, const TString& valuta, bool nc, int stato)
{
goto_root();
kill_node();
TString filter;
if (bill.tipo() > ' ')
filter << PART_TIPOCF << '=' << bill.tipo();
else
{
filter << PART_GRUPPO << '=' << bill.gruppo() << ' ';
filter << PART_CONTO << '=' << bill.conto();
}
filter << ' ' << PART_SOTTOCONTO << '=' << bill.sottoconto();
TString query;
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();
int last_year = 0;
TString80 id_year, id_rec;
for (bool ok = games.move_first(); ok; ok = games.move_next())
{
const TString& codval = rec.get(PART_CODVAL);
if (!same_values(codval, valuta))
continue;
const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV);
bool add_riga = true;
if (nc)
{
add_riga = !rec.get_bool(PART_CHIUSA);
// Se filtro le note di credito cerco di riconoscere le fatture negative
if (add_riga && tm == tm_fattura)
{
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
importo.normalize();
if (sezione_positiva == importo.sezione()) // Controlla se fattura positiva o negativa
add_riga = false; // Ignora fattura positiva
}
}
else
{
if (stato == 1 || stato == 2)
{
const bool chiusa = rec.get_bool(PART_CHIUSA);
if (chiusa)
add_riga = stato == 2;
else
add_riga = stato == 1;
}
}
if (!add_riga)
continue;
const int year = rec.get_int(PART_ANNO);
if (year != last_year)
{
goto_root();
while(goto_rbrother());
add_rbrother(real(year));
last_year = year;
curr_id(id_year);
id_rec.cut(0);
}
if (nc)
{
if (id_rec.full())
{
goto_node(id_rec);
add_rbrother(rec);
}
else
add_son(rec);
curr_id(id_rec);
}
else
{
TPartita game(rec);
const TRiga_partite& riga = game.riga(rec.get_int(PART_NRIGA));
for (int rata = 1; rata <= riga.rate(); rata++)
{
const TRiga_scadenze& s = riga.rata(rata);
bool add_rata = true;
if (stato == 1 || stato == 2)
{
const bool chiusa = s.get_bool(SCAD_PAGATA);
if (chiusa)
add_rata = stato == 2;
else
add_rata = stato == 1;
}
if (add_rata)
{
if (id_rec.full())
add_rbrother(s);
else
add_son(s);
curr_id(id_rec);
}
}
}
}
if (goto_node(id_year))
expand();
return goto_root();
}
///////////////////////////////////////////////////////////
// TPareggio_mask
///////////////////////////////////////////////////////////
class TPareggio_mask : public TAutomask
{
TPareggio_tree _nc, _ft;
private:
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TPareggio_mask();
};
bool TPareggio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
//case F_SOTTOCONTO:
case F_CLIENTE:
case F_FORNITORE:
case F_CODVAL:
case F_TUTTE:
if (e == fe_modify)
{
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);
const TString& codval = get(F_CODVAL);
_nc.init(bill, codval, true, 1); // Solo aperte
_ft.init(bill, codval, false, tipo);
tfield(F_NC_TREE).set_tree(&_nc);
tfield(F_FT_TREE).set_tree(&_ft);
}
break;
default: break;
}
return true;
}
TPareggio_mask::TPareggio_mask() : TAutomask("sc0300a")
{
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();
public:
};
void TPareggio_partite::main_loop()
{
TPareggio_mask pm;
pm.run();
}
///////////////////////////////////////////////////////////
// Main
///////////////////////////////////////////////////////////
int sc0300(int argc, char* argv[])
{
TPareggio_partite pp;
pp.run(argc, argv, TR("Pareggio Partite"));
return 0;
}
#include "sc0300a.h"
#include "../cg/cgsalda3.h"
#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <recset.h>
#include <relation.h>
#include <treectrl.h>
#include <mov.h>
class TPareggio_tree : public TObject_tree
{
TPartite_array _games;
protected:
virtual TFieldtypes get_var(const TString& name, TVariant& var) const;
virtual bool marked() const { return rand() % 2 != 0; }
const TPartita& partita(const TRectype& rec) const;
public:
bool init(const TBill& bill, const TString& valuta, bool nc, int stato); // Stato- 1=aperte; 2=chiuse; 0 o 3 = tutte
};
const TPartita& TPareggio_tree::partita(const TRectype& rec) const
{
return ((TPartite_array&)_games).partita(rec);
}
TFieldtypes TPareggio_tree::get_var(const TString& name, TVariant& var) const
{
TFieldtypes ft = _nullfld;
const TObject* obj = curr_node();
if (obj != NULL)
{
if (obj->is_kind_of(CLASS_RECTYPE))
{
const TRectype& rec = *(const TRectype*)obj;
ft = rec.type(name);
if (ft != _nullfld)
{
if (ft == _realfld)
{
var = rec.get_real(name).stringa(0, 2);
ft = _alfafld;
}
else
var = rec.get(name);
}
else
{
if (name.starts_with("PART.", true))
{
const TString& fld = name.after(".");
if (rec.num() == LF_SCADENZE)
{
const int nriga = rec.get_int(SCAD_NRIGA);
const TPartita& game = partita(rec);
var = game.riga(nriga).get(fld);
ft = _alfafld;
}
else
{
var = rec.get(fld);
ft = _alfafld;
}
} else
if (name == "RESIDUO")
{
TImporto saldo;
switch (rec.num())
{
case LF_SCADENZE:
if (!rec.get_bool(SCAD_PAGATA))
{
const TPartita& game = partita(rec);
const TRiga_scadenze& s = game.rata(rec.get_int(SCAD_NRIGA), rec.get_int(SCAD_NRATA));
saldo = s.residuo(true);
}
break;
case LF_PARTITE:
if (!rec.get_bool(PART_CHIUSA))
{
const TPartita& game = partita(rec);
saldo = game.calcola_saldo(true);
}
break;
default:
break;
}
var = saldo.valore().stringa(0, 2);
ft = _alfafld;
}
}
}
else
{
if (name == PART_NUMPART)
{
const real& year = *(real*)obj;
var = year.integer();
ft = _intfld;
}
}
}
return ft;
}
bool TPareggio_tree::init(const TBill& bill, const TString& valuta, bool nc, int stato)
{
goto_root();
kill_node();
TString filter;
if (bill.tipo() > ' ')
filter << PART_TIPOCF << '=' << bill.tipo();
else
{
filter << PART_GRUPPO << '=' << bill.gruppo() << ' ';
filter << PART_CONTO << '=' << bill.conto();
}
filter << ' ' << PART_SOTTOCONTO << '=' << bill.sottoconto();
TString query;
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();
int last_year = 0;
TString80 id_year, id_rec;
TProgind pi(games.items(), nc ? TR("Caricamento note di credito") : TR("Caricamento fatture"));
for (bool ok = games.move_first(); ok; ok = games.move_next())
{
if (!pi.addstatus(1))
break;
const TString& codval = rec.get(PART_CODVAL);
if (!same_values(codval, valuta))
continue;
const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV);
bool add_riga = true;
if (nc)
{
add_riga = !rec.get_bool(PART_CHIUSA);
if (add_riga)
{
// Se filtro le note di credito cerco di riconoscere le fatture negative
if (tm == tm_fattura)
{
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
importo.normalize();
add_riga = sezione_positiva != importo.sezione(); // Ignora fattura positiva
}
else
{
const int nriga = rec.get_int(PART_NRIGA);
const TPartita& game = partita(rec);
add_riga = ((TPartita&)game).unassigned().exist(nriga);
}
}
}
else
{
if (stato == 1 || stato == 2)
{
const bool chiusa = rec.get_bool(PART_CHIUSA);
if (chiusa)
add_riga = stato == 2;
else
add_riga = stato == 1;
}
if (add_riga)
{
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
importo.normalize();
add_riga = sezione_positiva == importo.sezione(); // Ignora fattura negativa
}
}
if (!add_riga)
continue;
const int year = rec.get_int(PART_ANNO);
if (year != last_year)
{
goto_root();
while(goto_rbrother());
add_rbrother(real(year));
last_year = year;
curr_id(id_year);
id_rec.cut(0);
}
if (nc)
{
if (id_rec.full())
{
goto_node(id_rec);
add_rbrother(rec);
}
else
add_son(rec);
curr_id(id_rec);
}
else
{
TPartita game(rec);
const TRiga_partite& riga = game.riga(rec.get_int(PART_NRIGA));
for (int rata = 1; rata <= riga.rate(); rata++)
{
const TRiga_scadenze& s = riga.rata(rata);
bool add_rata = true;
if (stato == 1 || stato == 2)
{
const bool chiusa = s.get_bool(SCAD_PAGATA);
if (chiusa)
add_rata = stato == 2;
else
add_rata = stato == 1;
}
if (add_rata)
{
if (id_rec.full())
add_rbrother(s);
else
add_son(s);
curr_id(id_rec);
}
}
}
}
if (goto_node(id_year))
expand();
return goto_root();
}
///////////////////////////////////////////////////////////
// TPareggio_mask
///////////////////////////////////////////////////////////
class TPareggio_mask : public TAutomask
{
TPareggio_tree _nc, _ft;
long _numreg;
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TPareggio_mask();
};
bool TPareggio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
//case F_SOTTOCONTO:
case F_CLIENTE:
case F_FORNITORE:
case F_CODVAL:
case F_TUTTE:
if (e == fe_modify)
{
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);
const TString& codval = get(F_CODVAL);
_nc.init(bill, codval, true, 1); // Solo aperte
_ft.init(bill, codval, false, tipo);
tfield(F_NC_TREE).set_tree(&_nc);
tfield(F_FT_TREE).set_tree(&_ft);
_numreg = 0;
disable(DLG_LINK);
}
break;
case F_NC_TREE:
case F_FT_TREE:
if (e == fe_button || e == fe_modify)
{
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"
TOOLBAR "" 0 0 0 2
BUTTON DLG_EDIT 2 2
BEGIN
PROMPT 1 1 "Modifica"
PICTURE TOOL_EDIT
END
BUTTON DLG_NEWREC 2 2
BEGIN
PROMPT 2 1 "Nuovo"
PICTURE TOOL_NEWREC
END
#include <helpbar.h>
ENDPAGE
PAGE "Pareggio Partite" 0 0 0 0
LIST F_TIPO 1 10
BEGIN
PROMPT 1 0 "Tipo conto "
// ITEM "|Conto" MESSAGE SHOW,1@|HIDE,2@|HIDE,3@
ITEM "C|Cliente" MESSAGE HIDE,1@|SHOW,2@|HIDE,3@
ITEM "F|Fornitore" MESSAGE HIDE,1@|HIDE,2@|SHOW,3@
END
NUMBER F_GRUPPO 3
BEGIN
PROMPT 28 0 "Gruppo "
FLAGS "D"
END
NUMBER F_CONTO 3
BEGIN
PROMPT 43 0 "Conto "
FLAGS "D"
END
NUMBER F_SOTTOCONTO 6
BEGIN
PROMPT 58 0 "Sottoconto "
USE LF_PCON SELECT SOTTOCONTO!=""
INPUT GRUPPO F_GRUPPO
INPUT CONTO F_CONTO
INPUT SOTTOCONTO F_SOTTOCONTO
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Sottoconto" SOTTOCONTO
DISPLAY "Descrizione@50" DESCR
OUTPUT F_GRUPPO GRUPPO
OUTPUT F_CONTO CONTO
OUTPUT F_SOTTOCONTO SOTTOCONTO
OUTPUT F_DESCR DESCR
GROUP 1
CHECKTYPE REQUIRED
END
NUMBER F_CLIENTE 6
BEGIN
PROMPT 58 0 "Cliente "
USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "C"
INPUT CODCF F_CLIENTE
DISPLAY "Cliente" CODCF
DISPLAY "Descrizione@50" RAGSOC
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_CLIENTE CODCF
OUTPUT F_DESCRCLI RAGSOC
ADD RUN cg0 -1 C
GROUP 2
CHECKTYPE REQUIRED
END
NUMBER F_FORNITORE 6
BEGIN
PROMPT 58 0 "Fornitore "
USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "F"
INPUT CODCF F_FORNITORE
DISPLAY "Fornitore" CODCF
DISPLAY "Descrizione@50" RAGSOC
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_FORNITORE CODCF
OUTPUT F_DESCRFOR RAGSOC
ADD RUN cg0 -1 F
GROUP 3
CHECKTYPE REQUIRED
END
STRING F_DESCR 50 58
BEGIN
PROMPT 1 1 "Descrizione "
GROUP 1
CHECKTYPE NORMAL
END
STRING F_DESCRCLI 50 58
BEGIN
PROMPT 1 1 "Ragione sociale "
USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC="C" SOTTOCONTO==CODCF
INPUT TIPOCF "C"
INPUT RAGSOC F_DESCRCLI
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Cliente" CODCF
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_CLIENTE CODCF
OUTPUT F_DESCRCLI RAGSOC
CHECKTYPE NORMAL
ADD RUN cg0 -1 F
GROUP 2
END
STRING F_DESCRFOR 50 58
BEGIN
PROMPT 1 1 "Ragione sociale "
USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "F"
INPUT RAGSOC F_DESCRFOR
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Fornitore" CODCF
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_FORNITORE CODCF
OUTPUT F_DESCRFOR RAGSOC
CHECKTYPE NORMAL
ADD RUN cg0 -1 F
GROUP 3
END
RADIOBUTTON F_TUTTE 1 38
BEGIN
PROMPT 1 2 "Mostra fatture"
ITEM "1|Aperte"
ITEM "2|Chiuse"
ITEM "3|Tutte"
FLAGS "Z"
END
STRING F_CODVAL 3
BEGIN
PROMPT 61 3 "Valuta "
USE %VAL
INPUT CODTAB F_CODVAL
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@50" S0
OUTPUT F_CODVAL CODTAB
FLAGS "U"
CHECKTYPE NORMAL
END
TLIST F_NC_TREE 35 -1
BEGIN
PROMPT 0 5 ""
DISPLAY "Partita@12" NUMPART
DISPLAY "Riga@4R" NRIGA
DISPLAY "Importo@10R" IMPORTO
DISPLAY "Residuo@10R" RESIDUO
DISPLAY "Descrizione Nota di Credito@35" DESCR
DISPLAY "P.N.@6R" NREG
END
TLIST F_FT_TREE 35 -1
BEGIN
PROMPT 40 5 ""
DISPLAY "Partita@12" NUMPART
DISPLAY "Riga@4R" NRIGA
DISPLAY "Rata@4R" NRATA
DISPLAY "Data@8" DATADOC
DISPLAY "Importo@10R" IMPORTO
DISPLAY "Residuo@10R" RESIDUO
DISPLAY "Descrizione Fattura@35" DESCR
DISPLAY "P.N.@6R" NREG
END
ENDMASK
#include "sc0300a.h"
TOOLBAR "" 0 0 0 2
BUTTON DLG_EDIT 2 2
BEGIN
PROMPT 1 1 "Modifica"
PICTURE TOOL_EDIT
END
BUTTON DLG_LINK 2 2
BEGIN
PROMPT 2 1 "Collega"
PICTURE TOOL_LINK
END
#include <helpbar.h>
ENDPAGE
PAGE "Pareggio Partite" 0 0 0 0
LIST F_TIPO 1 10
BEGIN
PROMPT 1 0 "Tipo conto "
// ITEM "|Conto" MESSAGE SHOW,1@|HIDE,2@|HIDE,3@
ITEM "C|Cliente" MESSAGE HIDE,1@|SHOW,2@|HIDE,3@
ITEM "F|Fornitore" MESSAGE HIDE,1@|HIDE,2@|SHOW,3@
END
NUMBER F_GRUPPO 3
BEGIN
PROMPT 28 0 "Gruppo "
FLAGS "D"
END
NUMBER F_CONTO 3
BEGIN
PROMPT 43 0 "Conto "
FLAGS "D"
END
NUMBER F_SOTTOCONTO 6
BEGIN
PROMPT 58 0 "Sottoconto "
USE LF_PCON SELECT SOTTOCONTO!=""
INPUT GRUPPO F_GRUPPO
INPUT CONTO F_CONTO
INPUT SOTTOCONTO F_SOTTOCONTO
DISPLAY "Gruppo" GRUPPO
DISPLAY "Conto" CONTO
DISPLAY "Sottoconto" SOTTOCONTO
DISPLAY "Descrizione@50" DESCR
OUTPUT F_GRUPPO GRUPPO
OUTPUT F_CONTO CONTO
OUTPUT F_SOTTOCONTO SOTTOCONTO
OUTPUT F_DESCR DESCR
GROUP 1
CHECKTYPE REQUIRED
END
NUMBER F_CLIENTE 6
BEGIN
PROMPT 58 0 "Cliente "
USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "C"
INPUT CODCF F_CLIENTE
DISPLAY "Cliente" CODCF
DISPLAY "Descrizione@50" RAGSOC
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_CLIENTE CODCF
OUTPUT F_DESCRCLI RAGSOC
ADD RUN cg0 -1 C
GROUP 2
CHECKTYPE REQUIRED
END
NUMBER F_FORNITORE 6
BEGIN
PROMPT 58 0 "Fornitore "
USE LF_CLIFO SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "F"
INPUT CODCF F_FORNITORE
DISPLAY "Fornitore" CODCF
DISPLAY "Descrizione@50" RAGSOC
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_FORNITORE CODCF
OUTPUT F_DESCRFOR RAGSOC
ADD RUN cg0 -1 F
GROUP 3
CHECKTYPE REQUIRED
END
STRING F_DESCR 50 58
BEGIN
PROMPT 1 1 "Descrizione "
GROUP 1
CHECKTYPE NORMAL
END
STRING F_DESCRCLI 50 58
BEGIN
PROMPT 1 1 "Ragione sociale "
USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC="C" SOTTOCONTO==CODCF
INPUT TIPOCF "C"
INPUT RAGSOC F_DESCRCLI
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Cliente" CODCF
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_CLIENTE CODCF
OUTPUT F_DESCRCLI RAGSOC
CHECKTYPE NORMAL
ADD RUN cg0 -1 F
GROUP 2
END
STRING F_DESCRFOR 50 58
BEGIN
PROMPT 1 1 "Ragione sociale "
USE LF_CLIFO KEY 2 SELECT (LF_PARTITE->SOTTOCONTO!="")
JOIN LF_PARTITE INTO TIPOC=TIPOCF SOTTOCONTO==CODCF
INPUT TIPOCF "F"
INPUT RAGSOC F_DESCRFOR
DISPLAY "Ragione Sociale@50" RAGSOC
DISPLAY "Fornitore" CODCF
DISPLAY "Partita IVA" PAIV
DISPLAY "Codice Fiscale" COFI
DISPLAY "Sosp." SOSPESO
DISPLAY "Ric.Alt.@30" RICALT
OUTPUT F_FORNITORE CODCF
OUTPUT F_DESCRFOR RAGSOC
CHECKTYPE NORMAL
ADD RUN cg0 -1 F
GROUP 3
END
RADIOBUTTON F_TUTTE 1 38
BEGIN
PROMPT 1 2 "Mostra fatture"
ITEM "1|Aperte"
ITEM "2|Chiuse"
ITEM "3|Tutte"
FLAGS "Z"
END
STRING F_CODVAL 3
BEGIN
PROMPT 61 3 "Valuta "
USE %VAL
INPUT CODTAB F_CODVAL
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@50" S0
OUTPUT F_CODVAL CODTAB
FLAGS "U"
CHECKTYPE NORMAL
END
TLIST F_NC_TREE 35 -1
BEGIN
PROMPT 0 5 ""
DISPLAY "Partita@12" NUMPART
DISPLAY "Riga@4R" NRIGA
DISPLAY "Data@8" DATADOC
DISPLAY "Importo@10R" IMPORTO
DISPLAY "Residuo@10R" RESIDUO
DISPLAY "Descrizione Nota di Credito@35" PART.DESCR
DISPLAY "P.N.@6R" NREG
END
TLIST F_FT_TREE 35 -1
BEGIN
PROMPT 40 5 ""
DISPLAY "Partita@12" NUMPART
DISPLAY "Riga@4R" NRIGA
DISPLAY "Rata@4R" NRATA
DISPLAY "Scadenza@8" DATASCAD
DISPLAY "Importo@10R" IMPORTO
DISPLAY "Residuo@10R" RESIDUO
DISPLAY "Descrizione Fattura@35" PART.DESCR
DISPLAY "P.N.@6R" PART.NREG
FLAGS "M"
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
#define __DONGLE_H
#ifndef _WX_DATETIME_H
#include <wx/datetime.h>
#endif
enum TDongleHardware { _dongle_unknown, _dongle_hardlock, _dongle_eutron, _dongle_xsec };
enum TDongleType { _no_dongle, _user_dongle, _developer_dongle, _aga_dongle, _prassi_dongle };
enum { MAX_DONGLE_ASSIST = 8 };
class TBit_array : public wxObject
{
unsigned char* _bit;
size_t _size;
protected:
virtual bool ok() const;
void resize(size_t size);
void copy(const TBit_array& ba);
size_t index(size_t n) const
{ return size_t(n / 8); }
unsigned long mask(size_t n) const
{ return (unsigned long)(1 << (n & 0x7)); }
public:
TBit_array(size_t size = 0);
TBit_array(const TBit_array& ba);
virtual ~TBit_array();
TBit_array& operator=(const TBit_array& ba);
bool operator[] (size_t n) const;
TBit_array& operator |=(const TBit_array& b);
size_t items() const { return 8 * _size; }
long first_one() const;
long last_one() const;
size_t ones() const;
void set(size_t n);
void reset(size_t n);
void neg(size_t n);
void set(size_t n, bool on) { on ? set(n) : reset(n); }
void set();
void reset();
};
class TDongle : public wxObject
{
TDongleHardware _hardware;
TDongleType _type;
wxString _admin, _admpwd;
unsigned short _serno, _max_users, _year_assist;
unsigned short _eprom[64];
wxDateTime _last_update;
TBit_array _module;
bool _dirty;
protected:
bool already_programmed() const;
bool hardlock_login(bool test_all_dongles);
bool eutron_login(bool test_all_dongles);
bool burn_hardlock();
bool burn_eutron();
public:
bool Ok() const
{ return _hardware != _dongle_unknown && _type != _no_dongle && _serno != 0xFFFF; }
public:
bool Login(bool test_all_dongles = false);
bool Logout();
bool Connected();
unsigned short Number() const { return _serno; }
unsigned short MaxUsers() const { return _max_users; }
unsigned short YearAssist() const { return _year_assist; }
void garble(unsigned short* data) const;
// Solo per un po' di tempo, poi diverranno protected (servono a ba1500 old style)
bool read_words(unsigned short reg, unsigned short len, unsigned short *data) const;
bool write_words(unsigned short reg, unsigned short len, unsigned short *data) const;
TDongleType type() const { return _type; }
bool Active(size_t module) const { return _module[module]; }
void Activate(size_t module, bool on = true) { _module.set(module, on); _dirty = true; }
void Deactivate(size_t module) { Activate(module, false); }
void set_max_users(unsigned short u) { _max_users = u; _dirty = true; }
void set_year_assist(unsigned short y) { _year_assist = y; _dirty = true; }
const wxDateTime& last_update() const { return _last_update; }
bool dirty() const { return _dirty; }
bool Burn();
TDongleHardware hardware() const { return _hardware; }
TDongle();
virtual ~TDongle();
};
long date2julian(const wxDateTime& date);
#endif
#ifndef __DONGLE_H
#define __DONGLE_H
#ifndef _WX_DATETIME_H
#include <wx/datetime.h>
#endif
enum TDongleHardware { _dongle_unknown, _dongle_hardlock, _dongle_eutron, _dongle_ssa };
enum TDongleType { _no_dongle, _user_dongle, _developer_dongle, _aga_dongle, _sirio_dongle };
enum { MAX_DONGLE_ASSIST = 8 };
class TBit_array : public wxObject
{
unsigned char* _bit;
size_t _size;
protected:
virtual bool ok() const;
void resize(size_t size);
void copy(const TBit_array& ba);
size_t index(size_t n) const
{ return size_t(n / 8); }
unsigned long mask(size_t n) const
{ return (unsigned long)(1 << (n & 0x7)); }
public:
TBit_array(size_t size = 0);
TBit_array(const TBit_array& ba);
virtual ~TBit_array();
TBit_array& operator=(const TBit_array& ba);
bool operator[] (size_t n) const;
TBit_array& operator |=(const TBit_array& b);
size_t items() const { return 8 * _size; }
long first_one() const;
long last_one() const;
size_t ones() const;
void set(size_t n);
void reset(size_t n);
void neg(size_t n);
void set(size_t n, bool on) { on ? set(n) : reset(n); }
void set();
void reset();
};
class TDongle : public wxObject
{
TDongleHardware _hardware;
TDongleType _type;
wxString _admin, _admpwd;
unsigned short _serno, _max_users, _year_assist;
unsigned short _eprom[64];
wxDateTime _last_update;
TBit_array _module;
bool _dirty;
// Module codes and descriptions
wxArrayString _code, _desc;
unsigned short _user[64];
wxString GetSessionId() const; // host:session
unsigned short ComputeMaxUsers(size_t module) const;
bool OpenModule(size_t module);
protected:
bool already_programmed() const;
bool hardlock_login(bool test_all_dongles);
bool eutron_login(bool test_all_dongles);
bool ssa_login(bool test_all_dongles);
bool ssa_logout();
bool burn_hardlock();
bool burn_eutron();
public:
bool Ok() const
{ return _hardware != _dongle_unknown && _type != _no_dongle && _serno != 0xFFFF; }
public:
bool Login(bool test_all_dongles = false);
bool Logout();
bool Connected();
unsigned short Number() const { return _serno; }
unsigned short YearAssist() const { return _year_assist; }
unsigned short MaxUsers(size_t module = 0) const;
void garble(unsigned short* data) const;
bool read_words(unsigned short reg, unsigned short len, unsigned short *data) const;
bool write_words(unsigned short reg, unsigned short len, unsigned short *data) const;
TDongleType type() const { return _type; }
bool Active(size_t module) const { return _module[module]; }
void Activate(size_t module, bool on = true) { _module.set(module, on); _dirty = true; }
void Deactivate(size_t module) { Activate(module, false); }
void set_max_users(unsigned short u) { _max_users = u; _dirty = true; }
void set_year_assist(unsigned short y) { _year_assist = y; _dirty = true; }
const wxDateTime& last_update() const { return _last_update; }
bool IsDirty() const { return _dirty; }
bool Burn();
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 "ve6.h" // dichiarazioni delle procedure
int main( int argc, char** argv )
{
const int r = (argc > 1) ? argv[1][1]-'0' : -1;
switch (r)
{
case 2: ve6200(argc, argv); break; // creazione fatture partendo da bolle
case 3: ve6300(argc, argv); break; // generazione effetti
case 4: ve6400(argc, argv); break; // generazione scontrini
case 5: ve6500(argc, argv); break; // generazione righe da penna ottica
case 6: ve6600(argc, argv); break; // collegamento contabilita' industriosa
case 7: ve6700(argc, argv); break; // copia documenti interattiva da ditta a ditta
case 8: ve6800(argc, argv); break; // contabilizzazione analitica documenti
default: ve6100(argc, argv); break; // contabilizzazione documenti
}
return 0;
}
#include <xvt.h>
#include "ve6.h" // dichiarazioni delle procedure
int main( int argc, char** argv )
{
const int r = (argc > 1) ? argv[1][1]-'0' : -1;
switch (r)
{
case 2: ve6200(argc, argv); break; // fatturazione bolle
case 3: ve6300(argc, argv); break; // generazione effetti
case 4: ve6400(argc, argv); break; // generazione scontrini
case 5: ve6500(argc, argv); break; // generazione righe da penna ottica
case 6: ve6600(argc, argv); break; // collegamento contabilita' industriosa
case 7: ve6700(argc, argv); break; // copia documenti interattiva da ditta a ditta
case 8: ve6800(argc, argv); break; // contabilizzazione analitica documenti
default: ve6100(argc, argv); break; // contabilizzazione documenti
}
return 0;
}

View File

@ -1,367 +1,359 @@
// ve6100.cpp: programma di contabilizzazione documenti
// Orgiastica visione...
// L'anatra del dubbio dalle labbra di Vermouth.
//******************************************************************************
// \\\\\\\\ e *
// b \\\\\\\\ b *
// \\\\\\\\ e r d l *
// \\\\\\\\ *
// \\\\\\\\ i V o e h *
// L \\\\\\\\ *
// \\\\\\\\ b d *
// o \\\\\\\\ m a *
// +++++++++++++++++++++++++ b t *
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++ |---------------------------------------|
// u //////// u |---------------------------------------|
// ' //////// a | /\ /\ |
// //////// i | r / \ r / \ |
// a //////// \|/ / \ / \ l |
// ////////-----------------*---\ a / t \ / a \ /|
// //////// /|\ \ / \ / \ / |
// d //////// n | \ / \ / \ / |
// //////// l d | \/ a \/ l \/ |
//-----------------------------------------------------------------------------|
//
// Scared uh?
#include <applicat.h>
#include <mask.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <urldefid.h>
#include "velib04.h"
#include "../cg/cgsaldac.h"
#include "ve6100a.h"
// TContabilizzazione_app
// Applicazione di contabilizzazione documenti
class TContabilizzazione_app : public TApplication
{
TString16 _cod_el; // codice elaborazione immesso
TDate _data_reg; // data di registrazione immessa
TDate _data_ini; // data di inizio intervallo
TDate _data_fine; // data di fine intervallo
bool _auto_data; // se TRUE prende in automatico la data di registrazione dalla data documento
TMask *_msk; // maschera di selezione dati
TArray_sheet *_num_sheet; // Array sheet selezionabile dei codici numerazione
TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare
virtual const char * extra_modules() const {return "dt";}
protected: // TApplication
// Contabilizza i documenti
void contabilize();
// Le 4 seguenti non hanno bisogno di commenti
virtual bool menu(MENU_TAG mt);
virtual bool create();
virtual bool destroy();
virtual void on_config_change();
// Handler del codice elaborazione differita
static bool handle_cod_eld(TMask_field& f, KEY k);
// Handler dell'intervallo di date
static bool handle_data_range(TMask_field& f, KEY k);
// Handler della data di registrazione
static bool handle_data_reg(TMask_field& f, KEY k);
// Handler del pulsante di selezione codici numerazione
static bool handle_select(TMask_field& f, KEY k);
// Ritorna il TArray_sheet contenente le selezioni sui codici numerazione
// Costruisce lo sheet dei codici numerazione
void build_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
bool doc_tipo_stato_ok(const TRectype& doc);
public:
TContabilizzazione_app() {_msk = NULL; _num_sheet = NULL;}
virtual ~TContabilizzazione_app() { }
};
inline TContabilizzazione_app& app() { return (TContabilizzazione_app&) main_app(); }
bool TContabilizzazione_app::handle_data_range(TMask_field& f, KEY k)
{
if (k==K_ENTER && f.dirty())
{
TMask& m = f.mask();
if (m.get_bool(F_DATA_AUTO))
return TRUE; // Skip controls if data is automatic
TDate da(m.get_date(F_DATA_INI));
TDate a(m.get_date(F_DATA_FIN));
m.field(F_DATA_REG).set_dirty();
if ((a - da) > 15)
{
f.error_box(TR("L'intervallo tra le date non puo' eccedere i 15 giorni."));
return FALSE;
}
if (f.dlg() == F_DATA_FIN)
m.set(F_DATA_REG,f.get());
}
if (f.focusdirty())
{
TMask& m = f.mask();
if (!m.get_bool(F_DATA_AUTO) && f.dlg() == F_DATA_FIN)
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())
{
TMask& m = f.mask();
TDate data_reg(f.get());
if (data_reg == botime) return TRUE;
TDate da(m.get_date(F_DATA_INI));
if ((data_reg - da) > 15)
{
f.error_box(TR("L'intervallo tra la data di registrazione e la data di inizio non puo' eccedere i 15 giorni."));
return FALSE;
}
if (data_reg < da)
{
f.error_box(TR("La data di registrazione non puo' essere minore della data di inizio."));
return FALSE;
}
}
return TRUE;
}
bool TContabilizzazione_app::handle_cod_eld(TMask_field& f, KEY k)
{
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()
f.mask().disable(DLG_OK);
app().build_num_sheet();
}
return TRUE;
}
bool TContabilizzazione_app::handle_select(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask& m = f.mask();
TArray_sheet* s = app().get_num_sheet();
if (s->run())
{
if (s->checked() != 0) // Hai selezionato qualcosa ?
m.enable(DLG_OK); // allora abilita il pulsante di conferma
else
m.disable(DLG_OK);
}
}
return TRUE;
}
void TContabilizzazione_app::build_num_sheet()
{
_num_sheet->destroy();
_tipi_doc.destroy();
TTable num("%NUM");
TString s1,s2,s3;
TContabilizzazione* cont = new TContabilizzazione(_cod_el);
if (!cont->empty())
{
TToken_string t;
TString16 tipo;
for (int i=0;i<TElaborazione::_max_tipi_doc_elab;i++)
{
tipo = cont->tipo_iniziale(i);
if (tipo.not_empty())
{
t = tipo;
t.add(cont->stato_iniziale(i)); // Stato iniziale
_tipi_doc.add(t); // Aggiunge questo tipo documento alla lista
}
}
long pos=0l;
for (num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
{
TToken_string t,z;
t.add(" ");
t.add(num.get("CODTAB"));
t.add(num.get("S0"));
_num_sheet->add(t);
s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
for (int x = 0; x <= s2.len(); x += 4)
z.add(s2.mid(x,4));
bool found = FALSE;
for (int i = _tipi_doc.last(); !found && i >= 0; i--)
found |= (s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0);
if (found)
_num_sheet->enable_row(pos);
else
_num_sheet->disable_row(pos);
}
}
delete cont;
}
bool TContabilizzazione_app::doc_tipo_stato_ok(const TRectype& doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
bool found = FALSE;
const TString16 tipo = doc.get(DOC_TIPODOC);
const char stato = doc.get_char(DOC_STATO);
const int items = _tipi_doc.items();
for (int i=0;i<items && !found;i++)
{
TToken_string& t = _tipi_doc.row(i);
const TString16 tipox(t.get(0));
const char statox = t.get(1)[0];
if (tipo == tipox && stato == statox)
found = TRUE;
}
return found;
}
void TContabilizzazione_app::on_config_change()
{
TPartita::carica_allineamento();
}
bool TContabilizzazione_app::create()
{
TApplication::create();
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,
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);
_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);
_msk->set_handler(DLG_USER,handle_select);
_num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione",
"@1|Cod. numerazione|Descrizione@50");
dispatch_e_menu(BAR_ITEM_ID(1));
return TRUE;
}
bool TContabilizzazione_app::destroy()
{
if (_msk) delete _msk;
if (_num_sheet) delete _num_sheet;
return TApplication::destroy();
}
bool TContabilizzazione_app::menu(MENU_TAG mt)
{
while (_msk->run() == K_ENTER)
{
_cod_el = _msk->get(F_CODICE_ELAB);
_data_ini = _msk->get_date(F_DATA_INI);
_data_fine = _msk->get_date(F_DATA_FIN);
_data_reg = _msk->get_date(F_DATA_REG);
_auto_data = _msk->get_bool(F_DATA_AUTO);
contabilize();
}
return FALSE;
}
void TContabilizzazione_app::contabilize()
{
TRelation doc_rel(LF_DOC);
TRectype da(LF_DOC);
TRectype a(LF_DOC);
const long items = _num_sheet->items();
int year_from = _data_ini.year();
int year_to = _data_fine.year();
TString16 codnum;
TString msg,filt_expr;
TToken_string nums;
TContabilizzazione cont(_cod_el);
// Compone la lista dei documenti da elaborare
cont.set_auto(_auto_data); // Setta il flag per il settaggio automatico della data di registrazione del movimento
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" || ..."
{
codnum = _num_sheet->row(i).get(1);
filt_expr << "(CODNUM=\"";
filt_expr << codnum << "\")||";
nums.add(codnum);
}
}
filt_expr.rtrim(2);
da.put(DOC_DATADOC,_data_ini);
da.put(DOC_PROVV,"D");
da.put(DOC_ANNO,year_from);
a.put(DOC_DATADOC,_data_fine);
a.put(DOC_PROVV,"D");
a.put(DOC_ANNO,year_to);
// Se ho una sola numerazione ottimizzo la setregion!
if (nums.items() == 1)
{
da.put(DOC_CODNUM, nums);
a.put(DOC_CODNUM, nums);
filt_expr.cut(0); // Il filtro diventa inutile
}
// 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
// chiave, nel nostro caso CODNUM soddisfa i requisiti.
TCursor doc_cur(&doc_rel,filt_expr,3,&da,&a);
const TRecnotype cur_items = doc_cur.items();
if (cur_items > 0)
{
TLista_documenti lista_in,lista_out;
doc_cur.freeze();
msg = "Selezione documenti dal ";
msg << _data_ini.string() << " al ";
msg << _data_fine.string();
TProgind p(cur_items,msg,FALSE,TRUE);
const TRectype& cur_rec = doc_cur.curr();
// Scorre tutti i documenti che rientrano nell'intervallo selezionato
for (doc_cur = 0; doc_cur.pos() < cur_items; ++doc_cur)
{
p.addstatus(1);
// 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))
{
TDocumento* doc = new TDocumento;
if (doc->read(doc_cur.curr()) == NOERR) // legge il documento
lista_in.add(doc); // Viene aggiunto alla lista dei documenti
else
delete doc;
}
}
cont.elabora(lista_in,lista_out,_data_reg);
if (cont.processed_docs() > 0L)
message_box(FR("Totale documenti contabilizzati: %ld"), cont.processed_docs());
}
else
warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate."));
xvtil_statbar_set("");
}
int ve6100 (int argc, char **argv)
{
TContabilizzazione_app a;
a.run(argc,argv,"Contabilizzazione documenti");
return TRUE;
}
// ve6100.cpp: programma di contabilizzazione documenti
// Orgiastica visione...
// L'anatra del dubbio dalle labbra di Vermouth.
//******************************************************************************
// \\\\\\\\ e *
// b \\\\\\\\ b *
// \\\\\\\\ e r d l *
// \\\\\\\\ *
// \\\\\\\\ i V o e h *
// L \\\\\\\\ *
// \\\\\\\\ b d *
// o \\\\\\\\ m a *
// +++++++++++++++++++++++++ b t *
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++ |---------------------------------------|
// u //////// u |---------------------------------------|
// ' //////// a | /\ /\ |
// //////// i | r / \ r / \ |
// a //////// \|/ / \ / \ l |
// ////////-----------------*---\ a / t \ / a \ /|
// //////// /|\ \ / \ / \ / |
// d //////// n | \ / \ / \ / |
// //////// l d | \/ a \/ l \/ |
//-----------------------------------------------------------------------------|
//
// Scared uh?
#include <applicat.h>
#include <mask.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <urldefid.h>
#include "velib04.h"
#include "../cg/cgsaldac.h"
#include "ve6100a.h"
// TContabilizzazione_app
// Applicazione di contabilizzazione documenti
class TContabilizzazione_app : public TApplication
{
TString16 _cod_el; // codice elaborazione immesso
TDate _data_reg; // data di registrazione immessa
TDate _data_ini; // data di inizio intervallo
TDate _data_fine; // data di fine intervallo
bool _auto_data; // se true prende in automatico la data di registrazione dalla data documento
TMask *_msk; // maschera di selezione dati
TArray_sheet *_num_sheet; // Array sheet selezionabile dei codici numerazione
TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare
virtual const char * extra_modules() const {return "dt";}
protected: // TApplication
// Contabilizza i documenti
void contabilize();
// Le 4 seguenti non hanno bisogno di commenti
virtual bool menu(MENU_TAG mt);
virtual bool create();
virtual bool destroy();
virtual void on_config_change();
// Handler del codice elaborazione differita
static bool handle_cod_eld(TMask_field& f, KEY k);
// Handler dell'intervallo di date
static bool handle_data_range(TMask_field& f, KEY k);
// Handler della data di registrazione
static bool handle_data_reg(TMask_field& f, KEY k);
// Handler del pulsante di selezione codici numerazione
static bool handle_select(TMask_field& f, KEY k);
// Ritorna il TArray_sheet contenente le selezioni sui codici numerazione
// Costruisce lo sheet dei codici numerazione
void build_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
bool doc_tipo_stato_ok(const TRectype& doc);
public:
TContabilizzazione_app() {_msk = NULL; _num_sheet = NULL;}
virtual ~TContabilizzazione_app() { }
};
inline TContabilizzazione_app& app() { return (TContabilizzazione_app&) main_app(); }
bool TContabilizzazione_app::handle_data_range(TMask_field& f, KEY k)
{
if (k==K_ENTER && f.dirty())
{
TMask& m = f.mask();
if (m.get_bool(F_DATA_AUTO))
return true; // Skip controls if data is automatic
TDate da(m.get_date(F_DATA_INI));
TDate a(m.get_date(F_DATA_FIN));
m.field(F_DATA_REG).set_dirty();
if ((a - da) > 15)
return f.error_box(TR("L'intervallo tra le date non puo' eccedere i 15 giorni."));
if (f.dlg() == F_DATA_FIN)
m.set(F_DATA_REG,f.get());
}
if (f.focusdirty())
{
TMask& m = f.mask();
if (!m.get_bool(F_DATA_AUTO) && f.dlg() == F_DATA_FIN)
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())
{
TMask& m = f.mask();
TDate data_reg(f.get());
if (data_reg == botime)
return true;
TDate da(m.get_date(F_DATA_INI));
if ((data_reg - da) > 15)
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)
return f.error_box(TR("La data di registrazione non puo' essere minore della data di inizio."));
}
return true;
}
bool TContabilizzazione_app::handle_cod_eld(TMask_field& f, KEY k)
{
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()
f.mask().disable(DLG_OK);
app().build_num_sheet();
}
return true;
}
bool TContabilizzazione_app::handle_select(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask& m = f.mask();
TArray_sheet* s = app().get_num_sheet();
if (s->run())
{
if (s->checked() != 0) // Hai selezionato qualcosa ?
m.enable(DLG_OK); // allora abilita il pulsante di conferma
else
m.disable(DLG_OK);
}
}
return true;
}
void TContabilizzazione_app::build_num_sheet()
{
_num_sheet->destroy();
_tipi_doc.destroy();
TTable num("%NUM");
TString s1,s2,s3;
TContabilizzazione* cont = new TContabilizzazione(_cod_el);
if (!cont->empty())
{
TToken_string t;
TString16 tipo;
for (int i=0;i<TElaborazione::_max_tipi_doc_elab;i++)
{
tipo = cont->tipo_iniziale(i);
if (tipo.not_empty())
{
t = tipo;
t.add(cont->stato_iniziale(i)); // Stato iniziale
_tipi_doc.add(t); // Aggiunge questo tipo documento alla lista
}
}
long pos=0l;
for (num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
{
TToken_string t,z;
t.add(" ");
t.add(num.get("CODTAB"));
t.add(num.get("S0"));
_num_sheet->add(t);
s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
for (int x = 0; x <= s2.len(); x += 4)
z.add(s2.mid(x,4));
bool found = FALSE;
for (int i = _tipi_doc.last(); !found && i >= 0; i--)
found |= (s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0);
if (found)
_num_sheet->enable_row(pos);
else
_num_sheet->disable_row(pos);
}
}
delete cont;
}
bool TContabilizzazione_app::doc_tipo_stato_ok(const TRectype& doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
bool found = FALSE;
const TString16 tipo = doc.get(DOC_TIPODOC);
const char stato = doc.get_char(DOC_STATO);
const int items = _tipi_doc.items();
for (int i=0;i<items && !found;i++)
{
TToken_string& t = _tipi_doc.row(i);
const TString16 tipox(t.get(0));
const char statox = t.get(1)[0];
if (tipo == tipox && stato == statox)
found = true;
}
return found;
}
void TContabilizzazione_app::on_config_change()
{
TPartita::carica_allineamento();
}
bool TContabilizzazione_app::create()
{
TApplication::create();
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,
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);
_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);
_msk->set_handler(DLG_USER,handle_select);
_num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione",
"@1|Cod. numerazione|Descrizione@50");
dispatch_e_menu(BAR_ITEM_ID(1));
return true;
}
bool TContabilizzazione_app::destroy()
{
if (_msk) delete _msk;
if (_num_sheet) delete _num_sheet;
return TApplication::destroy();
}
bool TContabilizzazione_app::menu(MENU_TAG mt)
{
while (_msk->run() == K_ENTER)
{
_cod_el = _msk->get(F_CODICE_ELAB);
_data_ini = _msk->get_date(F_DATA_INI);
_data_fine = _msk->get_date(F_DATA_FIN);
_data_reg = _msk->get_date(F_DATA_REG);
_auto_data = _msk->get_bool(F_DATA_AUTO);
contabilize();
}
return FALSE;
}
void TContabilizzazione_app::contabilize()
{
TRelation doc_rel(LF_DOC);
TRectype da(LF_DOC);
TRectype a(LF_DOC);
const long items = _num_sheet->items();
int year_from = _data_ini.year();
int year_to = _data_fine.year();
TString4 codnum;
TString msg,filt_expr;
TToken_string nums;
TContabilizzazione cont(_cod_el);
// Compone la lista dei documenti da elaborare
cont.set_auto(_auto_data); // Setta il flag per il settaggio automatico della data di registrazione del movimento
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" || ..."
{
codnum = _num_sheet->row(i).get(1);
filt_expr << "(CODNUM=\"";
filt_expr << codnum << "\")||";
nums.add(codnum);
}
}
filt_expr.rtrim(2);
da.put(DOC_DATADOC,_data_ini);
da.put(DOC_PROVV,"D");
da.put(DOC_ANNO,year_from);
a.put(DOC_DATADOC,_data_fine);
a.put(DOC_PROVV,"D");
a.put(DOC_ANNO,year_to);
// Se ho una sola numerazione ottimizzo la setregion!
if (nums.items() == 1)
{
da.put(DOC_CODNUM, nums);
a.put(DOC_CODNUM, nums);
filt_expr.cut(0); // Il filtro diventa inutile
}
// 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
// chiave, nel nostro caso CODNUM soddisfa i requisiti.
TCursor doc_cur(&doc_rel,filt_expr,3,&da,&a);
const TRecnotype cur_items = doc_cur.items();
if (cur_items > 0)
{
TLista_documenti lista_in,lista_out;
doc_cur.freeze();
msg = TR("Selezione documenti dal ");
msg << _data_ini.string() << TR(" al ");
msg << _data_fine.string();
TProgind p(cur_items,msg,FALSE,true);
const TRectype& cur_rec = doc_cur.curr();
// Scorre tutti i documenti che rientrano nell'intervallo selezionato
for (doc_cur = 0; doc_cur.pos() < cur_items; ++doc_cur)
{
p.addstatus(1);
// 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))
{
TDocumento* doc = new TDocumento;
if (doc->read(doc_cur.curr()) == NOERR) // legge il documento
lista_in.add(doc); // Viene aggiunto alla lista dei documenti
else
delete doc;
}
}
cont.elabora(lista_in,lista_out,_data_reg);
if (cont.processed_docs() > 0L)
message_box(FR("Totale documenti contabilizzati: %ld"), cont.processed_docs());
}
else
warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate."));
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 <recset.h>
#include "velib04.h"
#include "ve6200.h"
#include "ve6200a.h"
#include <doc.h>
///////////////////////////////////////////////////////////
// TFatturazione_bolle_app
///////////////////////////////////////////////////////////
bool TFatturazione_bolle_app::create()
{
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_AGENTI, LF_PERCPROV, LF_CAUSALI, 0);
TConfig cfg(CONFIG_DITTA, "ve");
_default_selection = cfg.get("FATBOLSEL");
return TSkeleton_application::create();
}
bool TFatturazione_bolle_app::process(TIndwin& iw, TElaborazione & eld,
TLista_documenti& din, const TDate& data_elab)
{
// Crea documenti di output
TLista_documenti dout;
bool ok = true;
if (eld.elabora(din, dout, data_elab))
{
TString msg;
msg << din.items() << TR(" documenti raggruppati in ") << dout.items();
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
int err = dout.write(); // Scrive documenti di output
if (err == NOERR)
{
err = din.rewrite(); // Aggiorna stato dei documenti di input
if (err != NOERR)
ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err);
}
else
ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err);
}
return ok;
}
void TFatturazione_bolle_app::process_by_cli(const TMask& m)
{
TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const long dc = m.get_long(F_CODICE_CLIFO_DA);
const long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
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 TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi(dc, ac, da, aa, dz, az);
TString msg(80);
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = "Elaborazione dei documenti del cliente ";
msg << codcli << " ...";
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
if (din.items() > 0 && !iw.iscancelled())
{
bool ok = process(iw, eld, din, data_elab);
if (!ok) // In caso di errore termina qui l'elaborazione.
break;
}
}
delete e;
}
void TFatturazione_bolle_app::process_by_ragsoc(const TMask& m)
{
TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const TString dr = m.get(F_RAGSOC_CLIFO_DA);
const TString ar = m.get(F_RAGSOC_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
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 TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi_ragsoc(dr, ar, da, aa, dz, az);
TString msg(80);
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = "Elaborazione dei documenti del cliente ";
msg << codcli << " ...";
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
if (din.items() > 0 && !iw.iscancelled())
{
bool ok = process(iw, eld, din, data_elab);
if (!ok) // In caso di errore termina qui l'elaborazione.
break;
}
}
delete e;
}
void TFatturazione_bolle_app::process_by_doc(const TMask& m)
{
TIndwin iw(0, TR("Inizializzazione...\n "), TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
long dc = m.get_long(F_CODICE_CLIFO_DA);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString8 dz(m.get(F_CODICE_ZONA_DA));
const TString8 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
if (!ad.ok()) ad = data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi(dc, ac);
TLista_documenti din, dout; // Legge tutti i documenti di input
TString msg(80);
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = TR("Elaborazione dei documenti del cliente");
msg << ' ' << codcli << "...";
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
if (codcli == 203726)
int cazzone = 1;
TLista_documenti list;
list.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
for (int i = list.items()-1; i >= 0; i--)
{
const TDocumento& doc = list[i];
bool to_del = FALSE;
const int agente = doc.get_int(DOC_CODAG);
if (agente > 0)
{
if (da > 0 && agente < da) to_del = true;
if (aa > 0 && agente > aa) to_del = true;
}
const TString8 zona = doc.get(DOC_ZONA);
if (zona.full())
{
if (dz.not_empty() && zona < dz) to_del = true;
if (az.not_empty() && zona > az) to_del = true;
}
if (to_del)
list.destroy(i);
}
const int items = list.items();
for (int j = 0; j < items; j++)
din.add(list[j]);
}
if (din.items() > 0 && !iw.iscancelled())
bool ok = process(iw, eld, din, data_elab);
delete e;
}
void TFatturazione_bolle_app::process_by_fatt(const TMask& m)
{
TWait_cursor hourglass;
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TElaborazione& eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
const TTipo_documento t(eld.tipo_iniziale(0));
const char tipocffatt = t.tipocf() == 'C' ? 'F' : 'C';
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
long dc = m.get_long(F_CODICE_CLIFO_DA);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString& dz = m.get(F_CODICE_ZONA_DA);
const TString& az = m.get(F_CODICE_ZONA_A);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
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;
TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
if (!dd.ok())
dd = TDate(1,1,anno);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
if (!ad.ok())
ad = data_elab;
const int nkey = (dn > 0 || an > 0) ? 1 : 3;
TString query;
query << "USE DOC KEY " << nkey << " SELECT (TIPOCFFATT=\"" << tipocffatt << "\")";
if (dc > 0 || ac > 0)
query << "&&(BETWEEN(CODCFFATT," << dc << ',' << ac << "))";
query << "&&(BETWEEN(DATADOC," << dd.date2ansi() << ',' << ad.date2ansi() << "))";
if (da > 0 || aa > 0)
query << "&&(BETWEEN(CODAG," << da << "," << aa << "))";
if (dz.full() || az.full())
query << "&&(BETWEEN(ZONA,\"" << dz << "\",\"" << az << "\"))";
if (nkey == 3 && codnum.full())
query << "&&(CODNUM=\"" << codnum << "\")";
query << "\nBY " << DOC_CODCFFATT;
if (eld.usa_doc_rif())
query << ' ' << DOC_DATADOCRIF;
if (nkey == 1)
{
query << "\nFROM PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << dn;
query << "\nTO PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << an;
}
else
{
query << "\nFROM DATADOC=" << dd.date2ansi();
query << "\nTO DATADOC=" << ad.date2ansi();
}
TISAM_recordset docs(query);
const TRectype& head = docs.cursor()->curr();
TProgind iw(docs.items(), "Elaborazione documenti da fatturare", true, true);
long last_clifo = 0; // Ultimo cliente elaborato
TLista_documenti din; // Lista dei documenti dell'ultimo cliente
for (bool ok = docs.move_first(); ok; ok = docs.move_next())
{
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 != last_clifo) // Cambio cliente
{
if (din.items() > 0) // Ci sono documenti da elaborare?
{
process(iw, eld, din, data_elab); // Elaborali ...
din.destroy(-1); // ... e poi buttali
}
last_clifo = clifo;
}
if (!iw.addstatus(1))
break;
// Controlla se il documento e' in uno stato valido per l'elaborazione
const TString4 tipodoc = head.get(DOC_TIPODOC);
const TString4 statodoc = head.get(DOC_STATO);
for (int i = tipidoc.items()-1; i>=0; i--)
{
if (tipodoc == tipidoc.get(i) && statodoc == statidoc.get(i))
{
din.add(head);
break;
}
}
}
}
// Termina l'elaborazione dei documenti dell'ultimo cliente
if (din.items() > 0 && !iw.iscancelled())
process(iw, eld, din, data_elab);
delete e;
}
bool TFatturazione_bolle_app::clifo_da_fatt(const TMask& m) const
{
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TFatturazione_bolle& eld = *(TFatturazione_bolle*)e;
const bool yes = eld.change_clifo();
delete e;
return yes;
}
void TFatturazione_bolle_app::main_loop()
{
TMask m("ve6200a");
m.set(F_SELEZIONE, _default_selection);
while (m.run() == K_ENTER)
{
const TString& select_from = m.get(F_SELEZIONE);
if (select_from != _default_selection)
{
TConfig cfg(CONFIG_DITTA, "ve");
cfg.set("FATBOLSEL", _default_selection = select_from);
}
if (m.get(F_ORDINAMENTO) == "R")
process_by_ragsoc(m);
else
{
if (clifo_da_fatt(m))
{
process_by_fatt(m);
}
else
{
if (select_from == "D")
process_by_doc(m);
else
process_by_cli(m);
}
}
}
}
int ve6200 (int argc, char **argv)
{
TFatturazione_bolle_app a;
a.run (argc, argv, TR("Fatturazione Bolle"));
return TRUE;
}
//#include <progind.h>
#include <recset.h>
#include "velib04.h"
#include "ve6200.h"
#include "ve6200a.h"
#include <doc.h>
///////////////////////////////////////////////////////////
// TFatturazione_bolle_app
///////////////////////////////////////////////////////////
bool TFatturazione_bolle_app::create()
{
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_AGENTI, LF_PERCPROV, LF_CAUSALI, 0);
_default_selection = ini_get_string(CONFIG_DITTA, "ve", "FATBOLSEL");
return TSkeleton_application::create();
}
bool TFatturazione_bolle_app::process(TIndwin& iw, TElaborazione & eld,
TLista_documenti& din, const TDate& data_elab)
{
// Crea documenti di output
TLista_documenti dout;
bool ok = true;
if (eld.elabora(din, dout, data_elab))
{
TString msg;
msg << din.items() << TR(" documenti raggruppati in ") << dout.items();
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
int err = dout.write(); // Scrive documenti di output
if (err == NOERR)
{
err = din.rewrite(); // Aggiorna stato dei documenti di input
if (err != NOERR)
ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err);
}
else
ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err);
}
return ok;
}
void TFatturazione_bolle_app::process_by_cli(const TMask& m)
{
TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const long dc = m.get_long(F_CODICE_CLIFO_DA);
const long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
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 TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi(dc, ac, da, aa, dz, az);
TString msg(80);
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = "Elaborazione dei documenti del cliente ";
msg << codcli << " ...";
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
if (din.items() > 0 && !iw.iscancelled())
{
bool ok = process(iw, eld, din, data_elab);
if (!ok) // In caso di errore termina qui l'elaborazione.
break;
}
}
delete e;
}
void TFatturazione_bolle_app::process_by_ragsoc(const TMask& m)
{
TIndwin iw(0, "Inizializzazione...\n ", TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const TString dr = m.get(F_RAGSOC_CLIFO_DA);
const TString ar = m.get(F_RAGSOC_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
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 TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi_ragsoc(dr, ar, da, aa, dz, az);
TString msg(80);
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = "Elaborazione dei documenti del cliente ";
msg << codcli << " ...";
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
if (din.items() > 0 && !iw.iscancelled())
{
bool ok = process(iw, eld, din, data_elab);
if (!ok) // In caso di errore termina qui l'elaborazione.
break;
}
}
delete e;
}
void TFatturazione_bolle_app::process_by_doc(const TMask& m)
{
TIndwin iw(0, TR("Inizializzazione...\n "), TRUE, FALSE, 60);
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
long dc = m.get_long(F_CODICE_CLIFO_DA);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString8 dz(m.get(F_CODICE_ZONA_DA));
const TString8 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
if (!ad.ok()) ad = data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi(dc, ac);
TLista_documenti din, dout; // Legge tutti i documenti di input
TString msg(80);
for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = TR("Elaborazione dei documenti del cliente");
msg << ' ' << codcli << "...";
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
if (codcli == 203726)
int cazzone = 1;
TLista_documenti list;
list.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
for (int i = list.items()-1; i >= 0; i--)
{
const TDocumento& doc = list[i];
bool to_del = FALSE;
const int agente = doc.get_int(DOC_CODAG);
if (agente > 0)
{
if (da > 0 && agente < da) to_del = true;
if (aa > 0 && agente > aa) to_del = true;
}
const TString8 zona = doc.get(DOC_ZONA);
if (zona.full())
{
if (dz.not_empty() && zona < dz) to_del = true;
if (az.not_empty() && zona > az) to_del = true;
}
if (to_del)
list.destroy(i);
}
const int items = list.items();
for (int j = 0; j < items; j++)
din.add(list[j]);
}
if (din.items() > 0 && !iw.iscancelled())
bool ok = process(iw, eld, din, data_elab);
delete e;
}
void TFatturazione_bolle_app::process_by_fatt(const TMask& m)
{
TWait_cursor hourglass;
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TElaborazione& eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
const TTipo_documento t(eld.tipo_iniziale(0));
const char tipocffatt = t.tipocf() == 'C' ? 'F' : 'C';
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
long dc = m.get_long(F_CODICE_CLIFO_DA);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString& dz = m.get(F_CODICE_ZONA_DA);
const TString& az = m.get(F_CODICE_ZONA_A);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
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;
TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
if (!dd.ok())
dd = TDate(1,1,anno);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
if (!ad.ok())
ad = data_elab;
const int nkey = (dn > 0 || an > 0) ? 1 : 3;
TString query;
query << "USE DOC KEY " << nkey << " SELECT (TIPOCFFATT=\"" << tipocffatt << "\")";
if (dc > 0 || ac > 0)
query << "&&(BETWEEN(CODCFFATT," << dc << ',' << ac << "))";
query << "&&(BETWEEN(DATADOC," << dd.date2ansi() << ',' << ad.date2ansi() << "))";
if (da > 0 || aa > 0)
query << "&&(BETWEEN(CODAG," << da << "," << aa << "))";
if (dz.full() || az.full())
query << "&&(BETWEEN(ZONA,\"" << dz << "\",\"" << az << "\"))";
if (nkey == 3 && codnum.full())
query << "&&(CODNUM=\"" << codnum << "\")";
query << "\nBY " << DOC_CODCFFATT;
if (eld.usa_doc_rif())
query << ' ' << DOC_DATADOCRIF;
if (nkey == 1)
{
query << "\nFROM PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << dn;
query << "\nTO PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << an;
}
else
{
query << "\nFROM DATADOC=" << dd.date2ansi();
query << "\nTO DATADOC=" << ad.date2ansi();
}
TISAM_recordset docs(query);
const TRectype& head = docs.cursor()->curr();
TProgind iw(docs.items(), "Elaborazione documenti da fatturare", true, true);
long last_clifo = 0; // Ultimo cliente elaborato
TLista_documenti din; // Lista dei documenti dell'ultimo cliente
for (bool ok = docs.move_first(); ok; ok = docs.move_next())
{
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 != last_clifo) // Cambio cliente
{
if (din.items() > 0) // Ci sono documenti da elaborare?
{
process(iw, eld, din, data_elab); // Elaborali ...
din.destroy(-1); // ... e poi buttali
}
last_clifo = clifo;
}
if (!iw.addstatus(1))
break;
// Controlla se il documento e' in uno stato valido per l'elaborazione
const TString4 tipodoc = head.get(DOC_TIPODOC);
const TString4 statodoc = head.get(DOC_STATO);
for (int i = tipidoc.items()-1; i>=0; i--)
{
if (tipodoc == tipidoc.get(i) && statodoc == statidoc.get(i))
{
din.add(head);
break;
}
}
}
}
// Termina l'elaborazione dei documenti dell'ultimo cliente
if (din.items() > 0 && !iw.iscancelled())
process(iw, eld, din, data_elab);
delete e;
}
bool TFatturazione_bolle_app::clifo_da_fatt(const TMask& m) const
{
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TFatturazione_bolle& eld = *(TFatturazione_bolle*)e;
const bool yes = eld.change_clifo();
delete e;
return yes;
}
void TFatturazione_bolle_app::main_loop()
{
TMask m("ve6200a");
m.set(F_SELEZIONE, _default_selection);
while (m.run() == K_ENTER)
{
const TString& select_from = m.get(F_SELEZIONE);
if (select_from != _default_selection)
{
TConfig cfg(CONFIG_DITTA, "ve");
cfg.set("FATBOLSEL", _default_selection = select_from);
}
if (m.get(F_ORDINAMENTO) == "R")
process_by_ragsoc(m);
else
{
if (clifo_da_fatt(m))
{
process_by_fatt(m);
}
else
{
if (select_from == "D")
process_by_doc(m);
else
process_by_cli(m);
}
}
}
}
int ve6200 (int argc, char **argv)
{
TFatturazione_bolle_app a;
a.run (argc, argv, TR("Fatturazione Bolle"));
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 "xvt.h"
#include "../../ssa/h/ssadll.h"
#include "../../ssa/h/ssaerr.h"
//#define SSA_MOD_NOTFOUND -201
//#define SSA_NO_LOGIN -301
static int _ssa_serial = SSA_UTENTE_NON_LOGGATO;
static wxString _ssa_module;
static const char* xvt_dongle_sa_id()
{
static char id[80];
if (!*id)
{
char user[32], host[32];
const int sess = xvt_sys_get_session_id();
xvt_sys_get_user_name(user, sizeof(user));
xvt_sys_get_host_name(host, sizeof(host));
sprintf(id, "%s@%s:%d", user, host, sess);
}
return id;
}
int xvt_dongle_sa_login(const char* module)
{
int err = _ssa_serial;
if (_ssa_serial < 0)
{
err = SSA_Login(xvt_dongle_sa_id(), "Campo");
if (err == 0)
err = _ssa_serial = SSA_NumeroSerie("Campo");
}
if (_ssa_serial >= 0 && module && *module)
{
err = SSA_ApriModulo(xvt_dongle_sa_id(), module);
if (err == 0)
{
if (!_ssa_module.IsEmpty())
xvt_dongle_sa_logout(_ssa_module);
_ssa_module = module;
}
}
return err;
}
int xvt_dongle_sa_crypt(unsigned short* data)
{
if (_ssa_serial < 0)
return SSA_UTENTE_NON_LOGGATO;
if (data == NULL)
return -ENOMEM;
data[0] ^= 0xDEAD;
data[1] ^= 0xBEEF;
data[2] ^= 0xDEAD;
data[3] ^= 0xBEEF;
return 0;
}
int xvt_dongle_sa_logout(const char* module)
{
int err = SSA_UTENTE_NON_LOGGATO;
if (_ssa_serial >= 0)
{
if (module && *module)
{
if (_ssa_module == module)
{
err = SSA_ChiudiModulo(xvt_dongle_sa_id(), _ssa_module);
_ssa_module.Empty();
}
else
err = SSA_MOD_NOTFOUND;
}
else
{
err = SSA_Logout(xvt_dongle_sa_id(), "Campo");
if (err == 0)
{
_ssa_serial = SSA_UTENTE_NON_LOGGATO;
_ssa_module.Empty();
}
}
}
return err;
}
int xvt_dongle_sa_test(const char* module)
{
int err = _ssa_serial;
if (err >= 0 && module && *module)
err = SSA_VerificaModulo("Campo", module);
return err;
}
#include "wxinc.h"
#include "xvt.h"
#include "../../ssa/h/ssadll.h"
#include "../../ssa/h/ssaerr.h"
#include <errno.h>
static int _ssa_serial = SSA_UTENTE_NON_LOGGATO;
static wxString _ssa_module;
static const char* xvt_dongle_sa_id()
{
static char id[80];
if (!*id)
{
char user[32], host[32];
const int sess = xvt_sys_get_session_id();
xvt_sys_get_user_name(user, sizeof(user));
xvt_sys_get_host_name(host, sizeof(host));
sprintf(id, "%s@%s:%d", user, host, sess);
}
return id;
}
int xvt_dongle_sa_login(const char* module)
{
int err = _ssa_serial;
const int nAssYear = xvt_vobj_get_attr(NULL_WIN, ATTR_APPL_VERSION_YEAR);
if (nAssYear > 2091)
{
if (_ssa_serial < 0)
{
err = SSA_Login(xvt_dongle_sa_id(), "Campo");
if (err == 0)
err = _ssa_serial = SSA_NumeroSerie("Campo");
}
if (_ssa_serial >= 0 && module && *module)
{
err = SSA_ApriModulo(xvt_dongle_sa_id(), module);
if (err == 0)
{
if (!_ssa_module.IsEmpty())
xvt_dongle_sa_logout(_ssa_module);
_ssa_module = module;
}
}
}
return err;
}
int xvt_dongle_sa_crypt(unsigned short* data)
{
if (_ssa_serial < 0)
return SSA_UTENTE_NON_LOGGATO;
if (data == NULL)
return -EACCES;
data[0] ^= 0xDEAD;
data[1] ^= 0xBEEF;
data[2] ^= 0xDEAD;
data[3] ^= 0xBEEF;
return 0;
}
int xvt_dongle_sa_logout(const char* module)
{
int err = SSA_UTENTE_NON_LOGGATO;
if (_ssa_serial >= 0)
{
if (module && *module)
{
if (_ssa_module == module)
{
err = SSA_ChiudiModulo(xvt_dongle_sa_id(), _ssa_module);
_ssa_module.Empty();
}
else
err = SSA_MOD_NOTFOUND;
}
else
{
err = SSA_Logout(xvt_dongle_sa_id(), "Campo");
if (err == 0)
{
_ssa_serial = SSA_UTENTE_NON_LOGGATO;
_ssa_module.Empty();
}
}
}
return err;
}
int xvt_dongle_sa_test(const char* module)
{
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