campo-sirio/cg/cglib03.cpp

#include "cglib03.h"

#include <diction.h>
#include <recarray.h>

#include <rmoviva.h>

///////////////////////////////////
// classe TInteressi_IVA_table   //
// per la lettura versamenti e   //
// e interessi IVA dalla tabella //
///////////////////////////////////

TInteressi_IVA_table::TInteressi_IVA_table() : TTable("%VER")
{
}

TInteressi_IVA_table::~TInteressi_IVA_table()
{
}

int TInteressi_IVA_table::read(int anno, int mese)
{
  TString16 k; k.format("%04d%02d",anno,mese);
  zero();put("CODTAB",k);
  if (TTable::read(_isgteq) == NOERR)
  {
    const TString& cod = TTable::get("CODTAB");    
    if (cod > k && prev() != NOERR)
      zero();
  }
  else
    if (last() != NOERR)
      zero();
  return status();
}

real TInteressi_IVA_table::get(int what)
{
  TString4 fieldname;
  fieldname.format("R%d", what);
  return get_real(fieldname);
}

///////////////////////////////////////////////
// TRigaiva_array 
// Tabella per il calcolo degli imponibili Iva
///////////////////////////////////////////////

const TString& TRigaiva::descr_det() const
{
  TString& rig = get_tmp_string();
  switch (_tipodet)
  {
  case 1 : rig = TR("Indetraib. su op.es."); break;
  case 3 : rig = TR("Passaggi interni"); break;
  case 9 : rig = TR("Indetraibile art.19"); break;
  default: rig = TR("Detraibile"); break;
  }
  return rig;
}

bool TRigaiva_array::add_riga(const real& imponibile, const real& imposta, 
                              const real& imponibilep, const real& impostap, 
                              const char* codiva, int tipodet, int tipocr, 
                              bool intra, int tipoatt) 
{
  int i;
  for (i = items()-1; i >= 0; i--)
  {
    TRigaiva& r = riga(i);
    if (r._codiva==codiva && r._tipodet==tipodet && r._tipocr==tipocr && r._tipoatt==tipoatt)
    {
      r._imponibile  += imponibile;
      r._imposta     += imposta;
      r._imponibilep += imponibilep;
      r._impostap    += impostap;
      break;
    }
  }
  if (i < 0)
  {
    TRigaiva* r = new TRigaiva(imponibile,imposta,imponibilep,impostap,codiva,tipodet,tipocr,intra,tipoatt);
    add(r);
  }
  return i >= 0;
}

bool TRigaiva_array::add_riga(const TRectype& iva)
{
  const real impo  = iva.get_real(RMI_IMPONIBILE);
  const real impos = iva.get_real(RMI_IMPOSTA);
  bool ok = !impo.is_zero() || !impos.is_zero();
  if (ok)
  {
    real percind; 
    const char codind     = iva.get_char(RMI_TIPODET);
    const int tipodet     = codind2tipodet(codind, percind);
    const TString4 codiva = iva.get(RMI_CODIVA);
    const int tipocr      = iva.get_int (RMI_TIPOCR);
    const bool intra      = iva.get_bool(RMI_INTRA);
    const int tipoatt     = iva.get_int (RMI_TIPOATT);

    if (percind > ZERO && percind < CENTO)
    {
      const int dec = TCurrency::get_firm_dec();
      real impo_ind  = impo * percind / CENTO; impo_ind.round(dec);
      real impos_ind = impos * percind / CENTO; impos_ind.round(dec);
      const real impo_det  = impo - impo_ind;
      const real impos_det = impos - impos_ind;
  
      ok = add_riga(impo_det,impos_det,ZERO,ZERO,codiva,0,tipocr,intra,tipoatt);
      ok &= add_riga(impo_ind,impos_ind,ZERO,ZERO,codiva,tipodet,tipocr,intra,tipoatt);
    }
    else
    {
      ok = add_riga(impo,impos,ZERO,ZERO,codiva,tipodet,tipocr,intra,tipoatt);
    }
  }
  return ok;
}

///////////////////////////////////////////////
// TRiga_array 
///////////////////////////////////////////////
                               
bool TRiga_array::add_riga(const real& imponibile, const real& imposta, 
                           const real& implordo, const real& imponibilep, 
                           const real& impostap, const real& implordop, 
                           const char* codiva) 
{
  bool found = false;
  for (int i = 0; i < items(); i++)
  {
    TRiga& r = riga(i);
    if (r._codiva==codiva) 
    {
      found = TRUE;
      r._imponibile  += imponibile;
      r._imposta     += imposta;
      r._implordo    += implordo;  
      r._imponibilep += imponibilep;
      r._impostap    += impostap;
      r._implordop   += implordop;
    }
  }
  if (!found)
  {                                                
    TRiga* r = new TRiga(imponibile,imposta,implordo,imponibilep,impostap,implordop,codiva);
    add(r);
  }
  return found;
}

///////////////////////////////////////////////
// TDociva_array
///////////////////////////////////////////////

bool TDociva_array::add_riga(const char* _descrdociva, const real& _importo,const int _natdoc) 
{
  bool found = FALSE;
  for (int i = 0; i < items(); i++)
  {
    TDociva& r = riga(i);
    if (r._descrdoc==_descrdociva) 
    {
      found = TRUE;
      if ((r._ndoc == 1)||(r._ndoc == 2)||(r._ndoc == 9))//||(r._ndoc == 4))
        r._totdociva += _importo;
    }
  }
  if (!found)
  {
    if ((_natdoc == 1)||(_natdoc == 2)||(_natdoc == 9))//||(_natdoc == 4))
    {
      TDociva* r = new TDociva(_descrdociva,_importo,_natdoc);
      add(r);
    }
  }
  return found; 
}  

bool TTipodoc_array::add_riga(const char* tipodoc, const char* descrdoc, const real& totdoc) 
{
  bool found = FALSE;
  for (int i = 0; i < items(); i++)
  {
    TTipodoc& r = (TTipodoc&)(*this)[i];
    if (r._tipodoc==tipodoc) 
    {
      found = TRUE;
      r._totdoc += totdoc;
    }
  }
  if (!found)
  {
    TTipodoc* r = new TTipodoc(tipodoc,descrdoc,totdoc);
    add(r);
  }
  return found;
}

///////////////////////////////////////////////////////////
// Arrotondamenti iva 
///////////////////////////////////////////////////////////

TRound_mode TIva_round::_def_mode = rm_unknown;
int TIva_round::_def_decimals = 0;

void TIva_round::set_default_mode(TRound_mode m, int d)
{
  _def_mode = _mode = m;
  _def_decimals = _decimals = d;
}

void TIva_round::set_mode(TRound_mode m, int d)
{
  _mode = m;
  _decimals = d;
}

void TIva_round::set_default_iva_mode(int year, bool declaration, long ditta)
{                               
  if (year < 1990)
    year = TDate(TODAY).year();

  if (year >= 2002 && is_euro_value(NULL))
  {
    if (ditta <= 0)
      ditta = prefix().get_codditta();
    TString16 key; key.format("%05ld%04d", ditta, year);
    const TRectype& lia = cache().get("%LIA", key);
    const int dec = lia.get_int(declaration ? "I2" : "I1");
    set_default_mode(rm_round, dec);
  }
  else
    set_default_mode(rm_millelire, -3);
}
  
void TIva_round::round(real& n) const
{
  CHECK(_mode != rm_unknown, "Non <20> stato impostato il metodo di arrotondamento");
  switch (_mode)
  {
  case rm_ceil: 
    n.ceil(_decimals); 
    break;
  case rm_millelire: 
    n -= 0.0001; // Le 500 lire vanno arrontondate per difetto
  default: 
    n.round(_decimals); 
    break;
  }
}

TIva_round::TIva_round()
{
  _mode = _def_mode;
  _decimals = _def_decimals;
}  

int codind2tipodet(const char codind, real& perc)
{
  int tipodet = 0;
  perc = ZERO;
  if (isalnum(codind))
  {
    const char strind[2] = { codind, '\0' };
    const TRectype& rec = cache().get("%DET", strind);
    if (rec.empty())
    {
      if (strchr("139", codind) != NULL) // Clausola di salvaguardia
      {
        tipodet = codind-'0';
        perc = CENTO;
      }
    }
    else
    {
      tipodet = rec.get_int("I0");
      if (tipodet > 0)
        perc = rec.get_real("R0");
    }
  }
  return tipodet;
}

// Anticamente TIPODET conteneva in tipo di indetraibilita,
// ora invece trattasi di un codice di indetraibilita'
// associato ad un motivo ed una percentuale di indetraibilita'
int get_tipodet_from_rmi(const TRectype& rmi, real& percind)
{
  return codind2tipodet(rmi.get_char(RMI_TIPODET), percind);
}