campo-sirio/cg/cglib.h

#ifndef __CGLIB_H
#define __CGLIB_H

#ifndef __ASSOC_H
#include <assoc.h>
#endif

#ifndef __TABUTIL_H
#include <tabutil.h>
#endif

#ifndef __CONTO_H
#include "conto.h"
#endif

#ifndef __CG2103_H
#include "cg2103.h"  // per TCausale
#endif

class TCaus : public TCausale
{
private:
  TRectype _rec;
  
public:
  bool            chiusura() const;
  bool            apertura() const;
  virtual bool    read(const char* cod);
  
  TCaus(const char* cod);
  ~TCaus() {}
};

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 };

const int EsePre(const int EseCorr);

class TSaldo 
{
  TLocalisamfile _saldi;

  real      _saldo, _saldo_iniziale, _saldoiniziale;  // oh my GOSH
  real      _prg_dare, _prg_avere;
  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;
  
protected:
  void      InFinEs(int);
  bool      leggi_mov(long numreg);       // Leggi testata      
  real      calcola_saldo_iniziale(int g, int c, long s, int indbil);
  bool      prg_saldo(int, TConto&, real&, real&, bool);
  
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&);
  const char*   causale_chiusura_es();
  const char*   causale_apertura_es();

  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);

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

  real saldofin_esprec(int,int,int,long,bool saldo_chiusura = FALSE,bool mov_prec = 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 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();
};



class TTab_conti : public TAssoc_array
{
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
  TSaldo_agg();
  int items() const { return _tab_conti.items();}
};

class TEsercizio : public TSortable
{            
  int _codice;
  TDate _inizio, _fine, _scarico, _chiusura;
  
protected:  // TSortable
  int compare(const TSortable& s) const;

public:    
  int codice() const            { return _codice; }
  const TDate& inizio() const   { return _inizio; }
  const TDate& fine() const     { return _fine; }
  const TDate& scarico() const  { return _scarico; }
  const TDate& chiusura() const { return _chiusura; }

  TEsercizio(const TRectype& rec);
  virtual ~TEsercizio() {}
};

class TEsercizi_contabili : public TObject
{               
  static TArray _esercizi;
  static long _firm;

protected:
  static void check();
  
  const TEsercizio& esc(int i) const 
  { return (const TEsercizio&)_esercizi[i]; }

  int date2index(const TDate& d) const;
  int esc2index(int codice) const;
  int items() const { return _esercizi.items(); }

public:
  static void update();
  
  const TEsercizio& esercizio(int codice) const; 
  const TEsercizio& operator [](int codice) const { return esercizio(codice); }
  
  int date2esc(const TDate& date) const;
  int pred(int codice) const;
  int next(int codice) const;
  int first() const;
  int last() const;
  bool exist(int codice) const;
  
  TEsercizi_contabili();
  virtual ~TEsercizi_contabili() {}
};

#endif