campo-sirio/cg/cglib01.cpp

// cglib01.cpp
// calcolo dei saldi

// La compilazione e' gia' lenta da sola: evitare include inutili (Guy)
// #include <applicat.h>
// #include <utility.h>

#include <config.h>

#include "cglib.h"

#include <rmov.h>
#include <mov.h>
#include <saldi.h> 
#include <pconti.h> 
#include <causali.h> 
#include <clifo.h> 


///////////////////////////////////////////////////////////
// Causale
///////////////////////////////////////////////////////////

TCaus::TCaus(const char* cod) 
:  _rec(LF_CAUSALI)
{
  //if (*cod) read(cod);
  read(cod);
}


// Legge le righe della causale attualmente selezionata sulla maschera
bool TCaus::read(const char* cod)
{
  TLocalisamfile caus(LF_CAUSALI);
  
  _rec = caus.curr(); _rec.zero();                    // Delete header

  if (*cod > ' ')
  {
    caus.setkey(1);
    caus.put(CAU_CODCAUS, cod);

    int err = caus.read();
    if (err != NOERR) return FALSE;
    _rec = caus.curr();
  }    
  return TRUE;
}

bool TCaus::chiusura() const 
{ return _rec.get_char("MOVAP") == 'C'; }

bool TCaus::apertura() const 
{ return _rec.get_char("MOVAP") == 'A'; }

//  
// Cerca l'esercizio precedente di EseCorr
// Se EseCorr e' gia' il primo ritorna 0
// senno' ritorna il precedente (Stavolta meno astutamente, ma correttamente)
//
const int EsePre(const int EseCorr)
{
  TEsercizi_contabili esc;
  return esc.pred(EseCorr);
}

// aep e' l'esercizio precedente
TSaldi_list::TSaldi_list(int gr, int co, int aec, int aep_par)
{
  TLocalisamfile    cf(LF_SALDI, FALSE);
  bool              force;
  TString16         key;
  int               aep = aep_par;
  
  destroy();
  cf.zero();

  // Se non passo l'anno precedente lo devo comunque calcolare
  if (aep_par == 0)
    aep = EsePre(aec);
  
  //  if (aep)             
  cf.setkey(2);
  /*  else
      {
      cf.setkey(1);
      cf.put(SLD_ANNOES,aec);    
      } 
      */  
  cf.put(SLD_GRUPPO,gr);
  cf.put(SLD_CONTO,co);
  //  TRectype rec(cf.curr());

  for (cf.read(_isgteq);!cf.eof();cf.next())
  {
    //    if (cf.curr() > rec) break;
    const int ae = cf.get_int(SLD_ANNOES);
    const int  g = cf.get_int(SLD_GRUPPO);
    const int  c = cf.get_int(SLD_CONTO);        
    const long s = cf.get_long(SLD_SOTTOCONTO);
    
    if (g != gr || c != co) break;
    
    //    if (aep)    {
    if (ae != aec && ae != aep) continue;
    //    }
    
    TRectype r(cf.curr());   
    key.format("%3d%3d%6ld", g, c, s);
    
    // Se avevo chiesto anche l'es. prec. puo' darsi che l'abbia gia' trovato
    if (aep_par)
      force = FALSE;
    else
      force = TRUE;

    add((const char*) key, r, force);      
  }
}

TRectype* TSaldi_list::saldi() const 
{ 
  TObject* o = ((TAssoc_array*)this)->get();
  if (o == NULL)
    return (TRectype*)NULL;
  else
    return (TRectype*)o; 
}

TSaldo::TSaldo() 
{                
  _saldo_ep        = new TRectype(LF_SALDI);
  _saldo_iniziale  = ZERO;
  _saldoiniziale   = ZERO;
  _prg_dare        = ZERO;
  _prg_avere       = ZERO;  
  _saldo           = ZERO;
  _annoes          = 0;
  _indbil          = 0; 
  _prec            = FALSE;
  _movimentato     = _significativo   = FALSE;
  _rec_presente_ec = _rec_presente_ep = FALSE;
}

TSaldo::~TSaldo() 
{
  delete _saldo_ep;
}

real TSaldo::saldofin_esprec(int annoes, int g, int c, long s) 
{
  const int annoesprec = EsePre(annoes);
  if (annoesprec == 0) // non ci sono esercizi prima del primo
  {
    _rec_presente_ep = FALSE;
    _significativo = FALSE;
    return ZERO;  
  }
  
  const TRectype& app = ricerca_progr_prec(annoesprec, g, c, s);
  
  const char flag      = app.get(SLD_FLAGSALINI)[0];
  const real saldo     = app.get_real(SLD_SALDO);
  const real pdare     = app.get_real(SLD_PDARE);
  const real pavere    = app.get_real(SLD_PAVERE); 
  //const real pdaresca  = app.get_real(SLD_PDARESCA);
  //const real paveresca = app.get_real(SLD_PAVERESCA);
  
  /*
     _significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO
     || pdaresca != ZERO || paveresca != ZERO);
     */
  _significativo = (saldo != ZERO || pdare != ZERO || pavere != ZERO);

  //real tot = pdare-pavere+pdaresca-paveresca;                                  
  real tot = pdare-pavere;                                  

  if (flag == 'D')
    tot += saldo;
  else 
    tot -= saldo;   

  return tot;  
} 

//richiamata nel bilancio a sez.contr per data limite
//in realta' calcola il saldo finale es.prec
real TSaldo::calcola_saldo_iniziale(int g,int c,long s,int indbil)
{
  real saldoini, pdaresca, paveresca, pdare, pavere;
  char flag;
  TLocalisamfile saldi(LF_SALDI, FALSE);

  _significativo = TRUE; 
  
  saldi.zero();
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);
  saldi.put(SLD_ANNOES,_annoes);
  
  if (saldi.read() == NOERR)
    _rec_presente_ec = TRUE;
  else
  {
    saldi.zero();
    _rec_presente_ec = FALSE;
  }

  flag      = saldi.get_char(SLD_FLAGSALINI);
  saldoini  = saldi.get_real(SLD_SALDO);
  
  _significativo = (saldoini != ZERO);
  
  if (saldoini != ZERO) //non va considerato!!! Vedi appunti
    _saldo_iniziale = ZERO;
  
  if (saldoini == ZERO)
  { 
    if ( indbil == 1 || indbil == 2 || indbil == 5 )
    {
      _prec = TRUE;
      saldoini = saldofin_esprec(_annoes, g, c, s);
      flag     = 'D';  // Il segno DEVE essere quello del saldo precedente
    }
    _saldo_iniziale = saldoini;  
  }  

#ifdef DBG
  TString sldi(saldoini.string());
#endif
  
  //if (flag == 'D')
  //return saldoini;
  return _saldo_iniziale; 
  //else 
  //return (-saldoini);
  //return (-_saldo_iniziale);
}

const char* TSaldo::causale_chiusura_es()
{
  TConfig conf(CONFIG_DITTA);
  return conf.get("CoCaCh");
}

const char* TSaldo::causale_apertura_es()
{
  TConfig conf(CONFIG_DITTA);
  return conf.get("CoCaAp");
}

void TSaldo::leggi_mov(long nr)
{
  TLocalisamfile mov(LF_MOV, FALSE);

  mov.zero();
  mov.put (MOV_NUMREG,nr);

  if (mov.read() == NOERR)
  {
    _codcaus  = mov.get     (MOV_CODCAUS);
    _datareg  = mov.get_date(MOV_DATAREG);
    _provv    = mov.get     (MOV_PROVVIS);
    _datacomp = mov.get_date(MOV_DATACOMP);
  }  
}

//per bilancio scalare (ovvero a sezioni contrapposte) per data limite
bool TSaldo::data_limite_bilancio(int bilancio, int g, int c, long s, const TDate& data_inf, 
                                  const TDate& data_sup, int indbil, int stp_prov)
{
  TString16 gcs_corr, gcs_prec;
  int       gruppo, conto, annoe;
  long      sottoconto, num_reg;
  real      importo;  
  TDate     data_mov;   
  char      sezione;
  
  TLocalisamfile rmov(LF_RMOV, FALSE);
  
  _saldo_iniziale  = ZERO;
  _saldo           = ZERO;
  _movimentato     = FALSE;
  _rec_presente_ep = FALSE;
  _rec_presente_ec = FALSE; 
  _prec            = FALSE;
  
  gcs_prec         = "";
  
  rmov.setkey(2);
  rmov.zero();
  rmov.put(RMV_GRUPPO,g);
  rmov.put(RMV_CONTO,c);
  rmov.put(RMV_SOTTOCONTO,s);
  TRectype rec(rmov.curr());

  for (rmov.read(_isgteq); !rmov.eof(); rmov.next())
  {    
    if (rmov.curr() != rec) break;
    
    annoe      = rmov.get_int(RMV_ANNOES);
    gruppo     = rmov.get_int(RMV_GRUPPO);
    conto      = rmov.get_int(RMV_CONTO);
    sottoconto = rmov.get_long(RMV_SOTTOCONTO);
    num_reg    = rmov.get_long(RMV_NUMREG);
    sezione    = rmov.get_char(RMV_SEZIONE);
    importo    = rmov.get_real(RMV_IMPORTO);

    // Leggo la testata
    leggi_mov(num_reg);    

    if (bilancio == DataLimite)
      data_mov = _datacomp;
    else
    {
      if (_annoes == 0)
        data_mov = _datareg;
      else              
        data_mov = _datacomp;
    } 
    if (data_mov < data_inf || data_mov > data_sup)
      continue;                         
    
    // "Se la causale del movimento e' uguale a quella di chiusura, 
    //  o di apertura il movimento non va considerato"
      //  if (_codcaus.not_empty())
      //    if (_codcaus == causale_chiusura_es() || 
      //       _codcaus == causale_apertura_es()) 
      //      continue;         
      
      // Modifica del 03-03-1995  
      TCaus cau(_codcaus); 
    
    if (_codcaus.not_empty())
      if (cau.chiusura()) //|| cau.apertura()) 
        continue;                   
    
    /*
       if (!stp_prov && _provv.trim().not_empty()) 
       continue;                                
       */
    
    if (stp_prov == 1 && _provv.trim().not_empty()) //bilancio normale (non comprende i provvisori)
      continue;
    
    if (stp_prov == 3 && _provv.trim().empty())     //bilancio dei soli provvisori
      continue;                                             
    
    // "I mov. di puro riferimento (= con importo = 0) vanno scartati"
    if (importo == ZERO) continue;
    
    gcs_corr.format ("%3d%3d%6ld", gruppo, conto, sottoconto);  
    
    if (gcs_corr != gcs_prec)  
    {
      gcs_prec = gcs_corr;
      if (stp_prov != 3) //bilancio normale o globale 
        _saldo = calcola_saldo_iniziale(gruppo,conto,sottoconto,indbil);
    }
    
#ifdef DBG
    TString dep1(_saldo.string());
#endif

    _movimentato = TRUE;

    if (sezione == 'D')  
      _saldo += importo;
    else 
      _saldo -= importo;
  }
#ifdef DBG
  TString dep2(_saldo.string());
#endif  

  // Anche se non movimentato vado a vedere il saldo 
  if (!_movimentato)
    if (stp_prov != 3)
      _saldo = calcola_saldo_iniziale(g,c,s,indbil);  
  
  return _movimentato;  
}


//per bilancio di verifica all'ultima immissione
bool TSaldo::ultima_immissione_verifica(int annoes,int g,int c,long s,int indbil,int stp_prov)
{
  //Si considerano i saldi e non piu' i movimenti
  char sezione; 
  int  gruppo, conto, annoe;
  long sottoconto;
  real pdarepro, paverepro;
  bool esito = FALSE;
  
  TLocalisamfile saldi(LF_SALDI);
  
  _saldo_iniziale = ZERO; 
  _saldoiniziale  = ZERO;
  _prg_dare       = ZERO;
  _prg_avere      = ZERO;
  _prg_daresca    = ZERO;
  _prg_averesca   = ZERO;
  _saldo          = ZERO;

  saldi.zero();
  
  saldi.put(SLD_ANNOES,annoes);
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);
  
  if (saldi.read() == NOERR)
  {
    annoe           = saldi.get_int(SLD_ANNOES);
    gruppo          = saldi.get_int(SLD_GRUPPO);
    conto           = saldi.get_int(SLD_CONTO);
    sottoconto      = saldi.get_long(SLD_SOTTOCONTO);
    _saldo_iniziale = saldi.get_real(SLD_SALDO);
    _prg_dare       = saldi.get_real(SLD_PDARE);
    _prg_avere      = saldi.get_real(SLD_PAVERE);
    pdarepro        = saldi.get_real(SLD_PDAREPRO);
    paverepro       = saldi.get_real(SLD_PAVEREPRO);
    sezione         = saldi.get_char(SLD_FLAGSALINI);
    
    if (stp_prov == 1)  //bilancio normale (senza provvisori)
      if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO) 
        return esito;
    
    if (stp_prov == 2)  //bilancio globale (con provvisori)
      if (_saldo_iniziale == ZERO && _prg_dare == ZERO && _prg_avere == ZERO
          && pdarepro == ZERO && paverepro == ZERO) 
        return esito;
    
    if (stp_prov == 3)  //bilancio dei soli mov. provvisori
      if (pdarepro == ZERO && paverepro == ZERO) 
        return esito;
    
    if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
    
    _saldoiniziale = _saldo_iniziale; //saldo iniziale presente sul record saldi
    //non comprensivo del saldo finale es.precedente
    
    if (stp_prov != 3)
      if (indbil == 1 || indbil == 2 || indbil == 5)      
        if (_saldo_iniziale == ZERO)
          _saldo_iniziale += saldofin_esprec(annoes,gruppo,conto,sottoconto);   

    esito = TRUE;
    
    switch (stp_prov)
    {
    case 1: 
      _saldo = _saldo_iniziale + _prg_dare - _prg_avere;
      break;
    case 2:
      _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro;
      break;
    case 3:
      _saldo = pdarepro - paverepro;
      break;
    default:
      break;  
    }  
  }
  return esito;
}  

//per bilancio a sezioni contrapposte all'ultima immissione
bool TSaldo::ultima_immissione_bilancio(int annoes,int g,int c,long s,int indbil,int stp_prov)
{
  //Si considerano i saldi e non piu' i movimenti
  char sezione; 
  int  gruppo, conto, annoe;
  long sottoconto;
  real pdarepro, paverepro;
  bool esito = FALSE;
  TLocalisamfile saldi(LF_SALDI, FALSE);
  
  _saldo_iniziale = ZERO;
  _prg_dare       = ZERO;
  _prg_avere      = ZERO;
  _prg_daresca    = ZERO;
  _prg_averesca   = ZERO; 
  _saldo          = ZERO;
  _rec_presente_ec = FALSE;
  _rec_presente_ep = FALSE; 
  _prec = FALSE;
  
  saldi.zero();
  
  saldi.put(SLD_ANNOES,annoes);
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);
  
  if (saldi.read() == NOERR)
  {
    annoe           = saldi.get_int(SLD_ANNOES);
    gruppo          = saldi.get_int(SLD_GRUPPO);
    conto           = saldi.get_int(SLD_CONTO);
    sottoconto      = saldi.get_long(SLD_SOTTOCONTO);
    _saldo_iniziale = saldi.get_real(SLD_SALDO);
    _prg_dare       = saldi.get_real(SLD_PDARE);
    _prg_avere      = saldi.get_real(SLD_PAVERE);
    pdarepro        = saldi.get_real(SLD_PDAREPRO);
    paverepro       = saldi.get_real(SLD_PAVEREPRO);
    sezione         = saldi.get_char(SLD_FLAGSALINI);
    
    /*
       esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
       || _prg_daresca != ZERO || _prg_averesca != ZERO);
       */
    if (stp_prov == 1)   //bilancio normale (senza provvisori)
      esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO);
    
    if (stp_prov == 2)  //bilancio globale (con provvisori)
      esito = (_saldo_iniziale != ZERO || _prg_dare != ZERO || _prg_avere != ZERO
               || pdarepro != ZERO || paverepro != ZERO); 
    
    if (stp_prov == 3)  //bilancio dei soli mov. provvisori
      esito = (pdarepro != ZERO || paverepro != ZERO); 
    
    if (sezione == 'A') _saldo_iniziale = -_saldo_iniziale;
    
    _rec_presente_ec = esito;
  }
  
  if (stp_prov != 3)
    if (indbil == 1 || indbil == 2 || indbil == 5)      
      if (_saldo_iniziale == ZERO)  
      {
        _prec = TRUE;
        _saldo_iniziale += saldofin_esprec(annoes,g,c,s);
      }
  
  //_saldo = _saldo_iniziale + _prg_dare - _prg_avere + _prg_daresca - _prg_averesca;  
  if (stp_prov == 1)
    _saldo = _saldo_iniziale + _prg_dare - _prg_avere;  
  
  if (stp_prov == 2)
    _saldo = _saldo_iniziale + _prg_dare - _prg_avere + pdarepro - paverepro;  
  
  if (stp_prov == 3)
    _saldo = pdarepro - paverepro;  

  return esito;
} 

TRectype& TSaldo::ricerca_progr_prec (int annoesprec, int g, int c, long s)
{
  TLocalisamfile saldi(LF_SALDI);

// Tre righe inutili che vengono gia' eseguite da TLocalisamfile (Guy)
  const int oldkey = saldi.getkey();       
  saldi.setkey(1);  
  saldi.zero();

  saldi.put(SLD_ANNOES,annoesprec);
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);

  if (saldi.read() == NOERR) 
    _rec_presente_ep = TRUE;
  else
  {
    saldi.zero();
    _rec_presente_ep = FALSE;
  }

  *_saldo_ep = saldi.curr();

  // riposiziona...   7 righe inutili (Guy)
  saldi.setkey(oldkey);
  saldi.zero();
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);
  saldi.put(SLD_ANNOES,annoesprec+1);   // Astuto anche questo (Guy)
  saldi.read(_isequal);

  return (*_saldo_ep);
}

//calcolo dei progressivi attuali  
bool TSaldo::prg_attuali(int annoes,TConto& conto,real& prgdare,real& prgavere)
{
  real saldoini  = ZERO;
  real pdare     = ZERO;
  real pavere    = ZERO;
  real pdaresca  = ZERO;
  real paveresca = ZERO;
  char flagsalini;
  int g  = conto.gruppo();
  int c  = conto.conto();
  long s = conto.sottoconto();
  TLocalisamfile saldi(LF_SALDI, FALSE);
  
  saldi.zero();
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);
  saldi.put(SLD_ANNOES,annoes);
  
  if (saldi.read() == NOERR)
  {
    flagsalini = saldi.get_char(SLD_FLAGSALINI);
    saldoini   = saldi.get_real(SLD_SALDO);
    pdare      = saldi.get_real(SLD_PDARE);
    pavere     = saldi.get_real(SLD_PAVERE);
    pdaresca   = saldi.get_real(SLD_PDARESCA);
    paveresca  = saldi.get_real(SLD_PAVERESCA);
    
    if (flagsalini == 'D')
    {
      prgdare  = saldoini + pdare + pdaresca;
      prgavere = pavere + paveresca; 
    }
    else
    {
      prgdare  = pdare + pdaresca;
      prgavere = saldoini + pavere + paveresca;  
    }
  }
  return TRUE;
}

bool TSaldo::prg_mov_eliminati(int annoes,TConto& conto,real& prgdare,real& prgavere)
{
  real saldoini  = ZERO;
  real pdaresca  = ZERO;
  real paveresca = ZERO;
  char flagsalini;
  int g  = conto.gruppo();
  int c  = conto.conto();
  long s = conto.sottoconto();
  TLocalisamfile saldi(LF_SALDI, FALSE);
  
  saldi.zero();
  saldi.put(SLD_GRUPPO,g);
  saldi.put(SLD_CONTO,c);
  saldi.put(SLD_SOTTOCONTO,s);
  saldi.put(SLD_ANNOES,annoes);
  
  if (saldi.read() == NOERR)
  {
    flagsalini = saldi.get(SLD_FLAGSALINI)[0];
    saldoini   = saldi.get_real(SLD_SALDO);
    pdaresca   = saldi.get_real(SLD_PDARESCA);
    paveresca  = saldi.get_real(SLD_PAVERESCA);
    if (flagsalini == 'D')
    {
      prgdare  = saldoini + pdaresca;
      prgavere = paveresca; 
    }
    else
    {
      prgdare  = pdaresca;
      prgavere = saldoini + paveresca;  
    }
  }
  return TRUE;
}