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

Allineamento file modificati durante la transizione da cvs a svn

Browse Source 
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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4824
cg/cg2100.cpp
View File

File diff suppressed because it is too large Load Diff

4634
cg/cgsaldac.cpp
View File

File diff suppressed because it is too large Load Diff

734
cg/cgsaldac.h
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

534
ef/ef0101.cpp
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;
}

208
ef/ef0101.h
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

1912
ef/ef0300.cpp
View File

File diff suppressed because it is too large Load Diff

465
ef/ef0400.cpp
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;
}

242
ef/ef0400a.uml
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

2624
ef/ef0500.cpp
View File

File diff suppressed because it is too large Load Diff

1584
include/applicat.cpp
View File

File diff suppressed because it is too large Load Diff

3816
include/brwbut.cpp
View File

File diff suppressed because it is too large Load Diff

210
include/doc.h
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

3239
include/treectrl.cpp
View File

File diff suppressed because it is too large Load Diff

4041
mg/mglib02.cpp
View File

File diff suppressed because it is too large Load Diff

652
sc/sc0300.cpp
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;
}

390
sc/sc0300a.uml
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

2350
server/authoriz.cpp
View File

File diff suppressed because it is too large Load Diff

1944
server/baseserv.cpp
View File

File diff suppressed because it is too large Load Diff

2042
server/dongle.cpp
View File

File diff suppressed because it is too large Load Diff

236
server/dongle.h
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

6315
setup/dninst.txt
View File

File diff suppressed because it is too large Load Diff

1606
setup/utils.cpp
View File

File diff suppressed because it is too large Load Diff

1887
tp/tp0102.cpp
View File

File diff suppressed because it is too large Load Diff

42
ve/ve6.cpp
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;
}

726
ve/ve6100.cpp
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;
}

799
ve/ve6200.cpp
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;
}

1192
ve/ve6300.cpp
View File

File diff suppressed because it is too large Load Diff

1285
ve/velib04.cpp
View File

File diff suppressed because it is too large Load Diff

1292
ve/velib04.h
View File

File diff suppressed because it is too large Load Diff

1192
ve/velib04a.cpp
View File

File diff suppressed because it is too large Load Diff

8981
ve/velib04b.cpp
View File

File diff suppressed because it is too large Load Diff

1487
ve/velib04c.cpp
View File

File diff suppressed because it is too large Load Diff

9121
xvaga/xvaga.cpp
View File

File diff suppressed because it is too large Load Diff

1073
xvaga/xvt_defs.h
View File

File diff suppressed because it is too large Load Diff

200
xvaga/xvt_ssa.cpp
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;
}

6429
xvaga/xvtctl.cpp
View File

File diff suppressed because it is too large Load Diff

1668
xvaga/xvtdm.cpp
View File

File diff suppressed because it is too large Load Diff