campo-sirio/cg/cglib02.h

#ifndef __CGLIB02_H
#define __CGLIB02_H

// Gestione saldi e ... basta

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

#ifndef __CGLIB01_H
#include "cglib01.h"
#endif       

#ifndef __CG2103_H                
class TCausale;
#endif

class TConto : public TBill
{
  real _dare, _avere, _darepro, _averepro, _saldofin, _saldo;
  TImporto _saldo_finale;

public:
  TConto(int g = 0, int c = 0, long s = 0L, char t = ' ', const char* d = NULL)
    : TBill(g, c, s, t, d) {}
  TConto (TToken_string& tgcsd, int from, int mode = 0)
    : TBill(tgcsd, from, mode) {}
  
  real& dare() { return _dare; }
  const real& dare() const { return _dare; }

  real& avere() { return _avere; }
  const real& avere() const { return _avere; }

  real& darepro() { return _darepro; }
  const real& darepro() const { return _darepro; }

  real& averepro() { return _averepro; }
  const real& averepro() const { return _averepro; }

  real& saldo() { return _saldo; }
  const real& saldo() const { return _saldo; }
  
  real& saldofin() { return _saldofin; }
  const real& saldofin() const { return _saldofin; }
  
  TImporto& saldo_finale() { return _saldo_finale; }
  const TImporto& saldo_finale() const { return _saldo_finale; }
};

///////////////////////////////////////////////////////////
// TSaldi_list
///////////////////////////////////////////////////////////

class TSaldi_list : public TAssoc_array
{
public:
  TSaldi_list (int g, int c, int aec, int aep=0);
  TRectype* saldi() const;
};

enum tipobil { DataLimite=1, UltimaImmissione };        
enum tiposal { normale, apertura, chiusura };

class TSaldo : public TObject
{
  TLocalisamfile _saldi;

  real      _saldo, _saldo_iniziale, _saldoiniziale;  // oh my GOSH
  real      _prg_dare, _prg_avere, _saldofin;
  char      _sezsf;
  int       _indbil;
  int       _annoes;
  TDate     _inizioEs, _fineEs;
  TString16 _codcaus;
  TDate     _datareg;
  TDate     _datacomp;
  TString   _provv;

  bool      _movimentato;
  bool      _significativo;
  bool      _rec_presente_ec;
  bool      _rec_presente_ep;
  bool      _prec;
  
  TDecoder      _causali_apertura;
  
protected:
  void			InFinEs(int);
  bool      leggi_mov(long numreg);       // Leggi testata      
  real      calcola_saldo_iniziale(int g, int c, long s, int indbil, bool provvis);
  bool      prg_saldo(int, TConto&, real&, real&, bool);
	const real& iniziale() const { return _saldo_iniziale;}
  void			set_iniziale(const real& val) { _saldo_iniziale = val; }

public:

  bool  movimentato()   const { return _movimentato; }
  bool  significativo() const { return _significativo; }
  bool  esiste_saldo()  const { return _rec_presente_ec || _rec_presente_ep; }
  bool  esiste_saldo_ep() const { return _rec_presente_ep; }
  
  int   annoes () const { return _annoes; }
  void  set_annoes (int anno) { _annoes = anno; }

  bool  causale_mov(long, const TDate&, const TDate&, TString&);
  
  bool ultima_immissione_bilancio(int anno,int g,int c,long s,int indbil,int prov,bool saldo_chiusura = TRUE);
  bool ultima_immissione_verifica(int anno,int g,int c,long s,int indbil,int prov);
  bool data_limite_bilancio(int,int,int,long,const TDate&,const TDate&,int,int, const char* = NULL);
  const real& saldo_periodo(int g,int c,long s,const TDate& dal,const TDate& al,int indbil, bool provv, const TString & codcomm = EMPTY_STRING);

  bool ricerca_progr_prec(int, int, int, long);

  real saldofin_esprec(int,int,int,long,bool saldo_chiusura = FALSE, bool provvisori = FALSE); 
  bool prg_attuali(int i,TConto& c, real& p1, real& p2)
    { return prg_saldo(i, c, p1, p2, FALSE); }
  bool prg_mov_eliminati(int i, TConto& c, real& p1, real& p2)
    { return prg_saldo(i, c, p1, p2, TRUE); }

  const real& saldo() const { return _saldo;}
  const real& saldoini() const { return _saldo_iniziale;}
  const real& saldoinisusaldi() const { return _saldoiniziale;}
  const real& prgdare() const { return _prg_dare;}
  const real& prgavere() const { return _prg_avere;}
  const real& saldofin() const { return _saldofin;}
  const char  sezsf() const { return _sezsf;}
  const bool  flagprec() { return _prec; } 
  
//  bool prg_attuali(int i,TConto& c, int d, real& p1, real& p2); 
//  bool prg_mov_eliminati(int i,TConto& c,int d, real& p1, real& p2);

  TSaldo();
  virtual ~TSaldo() {}
};

class TTab_conti : public TAssoc_array
{
protected:  
  const TString& build_key(const TBill& c, int anno, bool scar) const;

public:
  void aggiorna_conto(const TBill& tc, int anno_es, const TImporto& importo,
                      tiposal movap, bool provv, bool somma, bool movimentato, bool scaricato);
  
  TConto* add(const TBill& c, int anno, bool provv = FALSE);
  TConto* find(const TBill& c, int anno, bool provv = FALSE);                    
  void remove(const TBill& c, int anno, bool provv = FALSE);
};

class TSaldo_agg : public TObject
{
  TTab_conti _tab_conti;
  tiposal    _movap;       // se e' mov. d'apertura (aggiorno SALDO e FLAGSALINI in saldi)
  bool       _provv;      
  int        _anno_es;     // anno esercizio
  TDate      _data_ulmov;  // data ultimo movimento
  long       _num_ulmov;   // numero ultimo movimento 
  TRectype*  _rec;         // record corrente sui saldi
  bool       _movimentato; // di default e' FALSE; viene usato a TRUE solo quando voglio
                           // che un conto sia movimentato sui saldi anche se progressivi
                           // e saldo iniziale non sono significativi. Usato dalla Chiusura/Apertura conti  
public:
  void clear_saldi(int year);
  void registra();
  void aggiorna (const TBill& tc, const TImporto& importo, bool somma=TRUE, bool scaricato = FALSE);  
  void aggiorna (int gruppo, int conto, long sottoconto, 
                 const real& importo, char sezione, bool somma=TRUE, bool scaricato = FALSE);  
  
  TConto* find(const TBill& c, int anno) { return _tab_conti.find(c, anno); }               

  void set_anno_es(int anno) { _anno_es = anno; }
  int anno_es() const { return _anno_es; }

  void    set_tipo_saldo (tiposal movap) { _movap = movap; }
  tiposal tipo_saldo() const { return _movap; }

  void set_movprovv (bool p) { _provv = p; }
  bool movprovv() const { return _provv; }

  void set_movimentato (bool movimentato) { _movimentato = movimentato; }
  bool movimentato() const { return _movimentato; }

  void set_data_ulmov (const TDate& data) { _data_ulmov = data; }
  const TDate& data_ulmov() const { return _data_ulmov; }

  void set_num_ulmov (long num) { _num_ulmov = num; }
  long num_ulmov() const { return _num_ulmov; }

  void reset(); // pulisce l'array dei conti
  int items() const { return _tab_conti.items();}

  TSaldo_agg();
  virtual ~TSaldo_agg() { }
};

///////////////////////////////////////////////////////////
// TBalance
///////////////////////////////////////////////////////////

class TBalance : public TObject
{           
  TImporto _saldo_ini, _progr_dare, _progr_avere, _saldo_fin;

protected:                
  bool find(const TBill& b, int esercizio, 
            TImporto& si, TImporto& da, TImporto& av, TImporto& sf, 
            TImporto& pd, TImporto& pa) const;
  int indicatore_bilancio(const TBill& b) const;

public:
  void read(int g, int c, long s, int esercizio, bool ignora_movap, bool provvis);
  void read(const TBill& b, int esercizio, bool ignora_movap, bool provvis);
  void reread();
  
  const TImporto& saldo_iniziale() const;
  const real& progressivo_dare_iniziale() const;
  const real& progressivo_avere_iniziale() const;
  real progressivo_dare_finale() const;
  real progressivo_avere_finale() const;
  TImporto saldo_finale(bool chiusura = FALSE) const;
  TImporto saldo_finale_chiusura() const;

  TBalance();
  TBalance(int g, int c, long s, int esercizio, bool ignora_movap, bool provvis);
  TBalance(const TBill& b, int esercizio, bool ignora_movap, bool provvis);
  virtual ~TBalance() { }
};

#endif