campo-sirio/cg/cgsaldac.h

#ifndef __CGSALDAC_H
#define __CGSALDAC_H

#ifndef __RECARRAY_H
#include <recarray.h>
#endif                                         

#ifndef __CGLIB01_H
#include "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;
  int fill_array();

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:
  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
{ 
  TString16 _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 lit2val(const real& lit) const;
  real val2lit(const real& val) const;
  void val2lit(real& val) const;
  void lit2val(real& lit) const;
  void val2lit(TImporto& impval) const;
  void lit2val(TImporto& implit) const;
  
  bool in_lire() 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
///////////////////////////////////////////////////////////

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;     
  
  bool in_valuta() const;
  
  TPartita& partita() const;
  TRiga_partite& riga() const { return *_riga; } // Riga partite
  
  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
  
  bool esistono_abbuoni_diffcam() const;

  TRiga_scadenze(TRiga_partite* riga);
  TRiga_scadenze(const TRiga_scadenze& s);
  virtual ~TRiga_scadenze();
};

enum tipo_movimento { tm_nessuno = 0, tm_fattura = 1, tm_nota_credito = 2, 
                      tm_pagamento = 3, tm_insoluto = 5, tm_pagamento_insoluto = 6 };

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);
  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;                 
  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); }
  TImporto importo(bool valuta, int mode = 0xF) const;
  TImporto esposto(bool valuta, const TDate & data_scad, const TDate & data_rischio, bool & sbf) 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;
  char _align;        // current _num alignment
  
  TRecord_array _part;
  TRecord_array _unassigned;
  
  static char _cli_align, _for_align;  // default _num alignment

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 { return (TRiga_partite&)_part.row(r); } 
  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;  
  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_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);
  
  static void carica_allineamento();
  static char allineamento_richiesto(char tipocf);
  static int read_saldo(TRectype& riga, TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp);
  
  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);
  
  TPartita* first() { restart(); return next(); }
  TPartita* next() { return (TPartita*)get(); }
  
  TPartite_array() : _numreg(0) {} 
  virtual ~TPartite_array() {}
};

#endif