campo-sirio/cg/pagament.h

#ifndef __PAGAMENT_H
#define __PAGAMENT_H

#ifndef __MSKSHEET_H
#include <msksheet.h>
#endif                                         

#ifndef __RELATION_H
#include <relation.h>
#endif

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

// Error codes for pagation
const word P_OK      = 0x0000;     // ok
const word P_RSUM    = 0x0001;     // percentages do not sum up to 100
const word P_IMPNC   = 0x0002;     // inconsistenza percentuali / importi
const word P_SCAD    = 0x0004;     // scadenze non consecutive 
const word P_INIZIO  = 0x0008;     // data 1a rata < data inizio pagamenti
const word P_NEG     = 0x0010;     // importo specificato < minimo possibile
const word P_TROP    = 0x0020;     // importo specificato > massimo possibile
const word P_TOTNCLIT= 0x0040;     // totale importi in lire != totale pagamento
const word P_MCOMM   = 0x0080;     // inconsistenza mese commerciale/scadenze
const word P_ZEROLIT = 0x0100;     // importo di una rata in lire uguale a zero
const word P_SCWIDE  = 0x0200;     // date di scadenza separate da piu' di 10000 giorni
const word P_TOOMANY = 0x0400;     // troppe rate (piu' di 999)
const word P_TOTNCVAL= 0x0800;     // totale importi in valuta != totale pagamento
const word P_ZEROVAL = 0x1000;     // importo di una rata in valuta uguale a zero

class TPagamento : public TObject
{   
  TString   _code;       // codice
  TString   _name;       // descrizione
  real      _imponval; // imponibile da affettare
  real      _imposval;    // imposta da affettare
  real      _speseval;      // spese da affettare
  real      _imponlit;   // imponibile da affettare in lire (se imp. in valuta)
  real      _imposlit;   // imposta da affettare in lire
  real      _speselit;   // spese da affettare in lire
  real      _cambio;     // cambio valuta (TBZ?) 

  bool      _new;        // non letto da database
  TString_array _rate;   // rate medesime
  char      _inscad;     // inizio scadenze:    S1    
  bool      _mcomm;      // mese commerciale:   B0   
  bool      _rdiff;      // rate differenziate: B1
  int       _tpr;        // tipo prima rata:    S3
  bool      _dirty;      // modificato (strutturalmente!)
  TDate     _inizio;     // data inizio pagamenti
  TDate     _datadoc;    // data documento
  bool      _inited;     // vero se c'e' un movimento di riferimento
  real      _firstr;     // importo da pagare/distribuire in prima rata
  real      _secndr;     // importo da distribuire/pagare
  real      _firstl;     // importo da pagare/distribuire in lire (se valuta)
  real      _secndl;     // importo da distribuire/pagare in lire
  
  int       _fixd[3];    // giorni scadenza fissa, se desiderati
  int       _roundlit;   // decimali arrotondamento importo in lire (sempre 0 per ora)
  int       _roundval;   // decimali arrotondamento importo in valuta
  int       _int_rate;   
  
  int       _rata_ifield(int n, int f) const;
  long      _rata_lfield(int n, int f) const;
  real      _rata_rfield(int n, int f) const;
  TDate     _rata_dfield(int n, int f) const;
  const char* _rata_sfield(int n, int f) const;
  
  int       _def_tpr;    // tipo rata default
  TString16 _def_ulc;    // ulteriore classificazione default

  bool      _was_tpr4;   // chiederne ragione ai responsabili morali (bonazzi, gabriella)
   
  bool      _in_valuta;  // in valuta o non 

protected:                                 

  // gestione casino se si modificano importi o percentuali rate
  word   change_value(int rata, real new_val, int rdiff, bool is_perc, bool mcomm, bool v);
  word   change_value_differenziate(int rata, real value, bool is_perc, bool v);
  word   change_value_uguali(int rata, real value, bool is_perc, bool v);
  word   change_value_uguali_prossima(int rata, real value, bool is_perc, bool v);
  word   change_value_uguali_possible(int rata, real value, bool is_perc, bool v);

  void init_total(const real& ib, const real& im, const real& sp, bool valuta);

  // aggiusta parametri diversi da importo se si sono aggiunte rate
  void adjust_parameters(bool mcomm);  
  // riaggiusta le percentuali o gli importi rispetto al dato modificato              
  void adjust_perc_imp(bool is_perc, int rdiff, bool v);
  // riaggiusta le percentuali rispetto al dato modificato              
  void adjust_perc(int rdiff, bool v);       
  // controlla il segno di un valore in base a _tpr e row
  bool sign_ok(const real& val, int row) const;

public:

  // pregasi notare la straordinaria dovizia di const
  const int n_rate()          const { return _rate.items(); }
  bool   is_new()             const { return _new;          }  
  bool   dirty()              const { return _dirty;        }

  const real&   imponibile(bool v = FALSE) { return v ? _imponval : _imponlit; }
  const real&   imposta(bool v = FALSE)    { return v ? _imposval : _imposlit; }
  const real&   spese(bool v = FALSE)      { return v ? _speseval : _speselit; }

  const real&   imponlit()  const { return _imponlit;       }
  const real&   imposlit()  const { return _imposlit;       }
  const real&   speselit()  const { return _speselit;       }
  const real&   imponval()  const { return _imponval;       }
  const real&   imposval()  const { return _imposval;       }
  const real&   speseval()  const { return _speseval;       }
  
  const real&   importo_da_dividere(bool v = FALSE)      const;
  const real&   importo_da_non_dividere(bool v = FALSE)  const;
  
  real  tval_rata(int n) const  { return _rata_rfield(n,4);}
  real  tlit_rata(int n) const  { return _rata_rfield(n,7);}

  int   scad_rata(int n) const  { return _rata_ifield(n,0);}               
  real  perc_rata(int n) const  { return _rata_rfield(n,1);}
  int   tipo_rata(int n) const  { return _rata_ifield(n,2);}
  TDate data_rata(int n) const  { return _rata_dfield(n,3);}
  real  importo_rata(int n, bool v = FALSE) const 
    { return v ? tval_rata(n) : tlit_rata(n); }
  const char* ulc_rata(int n) const { return _rata_sfield(n,5);}
  bool  ratapagata(int n) const { return _rata_sfield(n,6)[0] > ' ';}

  char   inizio_scadenza()    const { return _inscad;   }           
  bool   mese_commerciale()   const { return _mcomm;    }           
  bool   rate_differenziate() const { return _rdiff;    }
  int    tipo_prima_rata()    const { return _tpr;      }
  int    intervallo_rate()    const { return _int_rate; }
  int    round(bool v)        const { return v ? _roundval : _roundlit; }
  
  const TString& name()       const { return _name;     }                                    
  const TString& code()       const { return _code;     }                                    
  const char* desc_tpr()      const;
  const char* desc_tipo(int tipo, char ulc, bool* ok = NULL)  const;
  
  // giorni scadenza fissi, aggiunti poi  
  void  set_fixed_scad(int a, int ind) { _fixd[ind] = a;  }
  
  // queste vengono usate solo per movimenti editabili nella struttura
  // (da tabella pagamenti) e riaggiustano tutte le rate in accordo
  // con il parametro modificato
  void   set_intervallo_rate(int i);     
  void   set_mese_commerciale(bool v, int& sscad);          
  void   set_rate_differenziate(int v);
  void   set_tipo_prima_rata(int v, int sscad = -1);
  void   set_percrata(int n, real r);
  void   set_datarata(int n, const TDate & d);
  real   recalc_percrata(int i, bool valuta);                          
  // gestisce da se' casi con e senza valuta
  void   set_numero_rate(int n, int sscad = -1, int rdiff = 1);
  
  void   set_inizio(const TDate& d, bool rispetta_date = FALSE);  // resetta tutto                                                       
  void   set_datadoc(const TDate & d)   { _datadoc = d;}
  void   set_inizio_scadenza(char v)    { _inscad = v; }           
  void   set_code(const char* c)        { _code = c;   }       
  void   set_roundval(int n)            { _roundval = n;  }
    
  bool   in_valuta()    const { return _in_valuta; }
  const real&  cambio() const { return _cambio;    }
  
  // check consistency: returns word with errors flagged, 0 if ok
  word   validate() const;
  // writes description of errors err in s
  void   strerr(word err, TString& s);
  
  // read/write from database 
  // relapp passa i files, se no vengono aperti
  bool   read(TTable* cpg = NULL, TTable* rpg = NULL);
  
  // chiamabili solo da relapp, agiscono solo su %RPG
  int   write  (TTable& rpg);
  int   rewrite(TTable& rpg);
  int   remove (TTable& rpg);
  
  // modifica rate manualmente o non
  TToken_string&   rata(int r) { return (TToken_string&)_rate[r]; }
  TToken_string&   add_rata (real perc, int day, int type, const char* ulc = "");
  TToken_string&   add_rata ();
  // setta rata senza automatismi, un importo solo (valuta o no)
  TToken_string&   set_rata (int index, real perc, int day, int type, bool valuta,
                             const char* ulc = NULL, const char* imp = NULL,
                             const char* data = NULL);     

  // calcola percentuali e scadenze a partire dagli importi
  TToken_string& set_rata(int index, const real& impval, const real& implit,
                          const TDate& date, int type, const char* ulc, bool pagata);                    
  
  // settano tipo rata e ult. class default per le rate; se bool = TRUE
  // modificano anche le eventuali rate esistenti
  void set_default_type(int type, bool change_existing = TRUE);
  void set_default_ulc(const char* ulc, bool change_existing = TRUE);
  
  void   remove_rata(int r);  
  void   remove_rate_from(int r);  
  void   zap_rate () { _rate.destroy(); } 
  // calcola le rate automaticamente secondo quanto specificato
  void   set_rate_auto();          
  // data una rata esistente, riaggiusta gli importi usando lo slicer e 
  // le scadenze usando la data di inizio
  void   set_imprata(int i, const real& r, bool val);

  // only one of these must be called
  void   set_total(const real& ib, const real& im, const real& sp);
  void   set_total_valuta(const real& ib,  const real& im,  const real& sp, const real& cambio,
                          const real& ibl, const real& iml, const real& spl);
  
  // istanzia uno sheet field come diobue comanda                                   
  void   set_sheet(TSheet_field& sf, int sscad = -1);         

  // ricalcola automaticamente tutto il ricalcolabile
  // alla modifica di una percentuale (o di un importo)
  // ritorna TRUE (con errori OR-ati) se non si poteva; 
  word   recalc_rate(int row, bool is_perc_modified, const char* new_value, 
                     const char* new_lire, const char* scad, const char* typ, 
                     const char* ulc, int rdiff, bool mcomm, bool& need_recalc);
  
  // aggiusta scadenze fisse (tutte in un colpo)
  void  adjust_fixed_scad();
  // determina la prossima scadenza
  void   next_scad(TDate& d, int scad, bool mcomm, int rata);
  
  // folies bergeres pretese, delle quali non rispondo a nessuno
  bool was_tpr4() const { return _was_tpr4; }
  void set_tpr4(bool b) { _was_tpr4 = b;    }
  
  // se codtab non e' NULL legge da file (e da' errore se non c'e')
  // se si vuole fare un pagamento nuovo si da' il codice con set_code                                                              
  TPagamento(const char* codtab = NULL, const char* data = NULL);
  virtual ~TPagamento() {}
};                          

#endif