campo-sirio/ve/velib01.cpp

#include <tabutil.h>

#include "velib.h"

HIDDEN const real CENTO(100.0); // costante per evitare la chiamata dei costruttori real tante volte

TSpesa_prest::TSpesa_prest(const char* codice, char tipo)
       : TRectype(LF_TAB)
{    
  const bool spesa = tipo == RIGA_SPESEDOC;
  
  settab(spesa ? "SPP" : "PRS");
  if (codice && *codice)
    if (read(codice) != NOERR)
       error_box(spesa ? "Spesa %s assente" : "Prestazione %s assente", codice);
}

TSpesa_prest::TSpesa_prest(const TRectype& rec)
      : TRectype(rec)
{
}

int TSpesa_prest::read(const char* codice)
{                      
  zero();             
  TTable t(get("COD"));
  put("CODTAB", codice);
  TRectype r(*this);
  int err = TRectype::read(t);
  if (err != NOERR)
    *this = r;
  return err;  
}

TIVA::TIVA(const char* codice)
       : TRectype(LF_TABCOM)
{
  settab("IVA");
  if (codice && *codice)
    read(codice);
}

TIVA::TIVA(const TRectype& rec)
      : TRectype(rec)
{
}

int TIVA::read(const char* codice)
{                                   
  TTable t("%IVA");
  put("CODTAB", codice);
  int err = TRectype::read(t);
  if (err != NOERR)
    yesnofatal_box("Codice IVA assente : %s", codice);
  return err;  
}

///////////////////////////////////////////////////////////
// Funzioni per il calcolo dei prezzi netti/lordi
///////////////////////////////////////////////////////////

real lordo2netto(real& lordo, const TString& codiva, int ndec)
{
  TTable tabiva("%IVA");
  real aliquota = 0.0;
  
  tabiva.put("CODTAB", codiva);
  if (tabiva.read() == NOERR) aliquota = tabiva.get_real("R0");
  
  return lordo2netto(lordo,aliquota, ndec);
}

real netto2lordo(const real& netto, const TString& codiva, int ndec)
{
  TTable tabiva("%IVA");
  real aliquota = 0.0;
  
  tabiva.put("CODTAB", codiva);
  if (tabiva.read() == NOERR) aliquota = tabiva.get_real("R0");
  
  return netto2lordo(netto,aliquota, ndec);
}

real lordo2netto(real& lordo, const real& iva, int ndec)
{
  real netto;
  real imposta = 0.0;
  real imposta_rec = 0.0;
  if (!iva.is_zero())
  {
    imposta = (lordo * iva) / (iva + 100.0); // Calcola l'imposta...
    if (imposta < ZERO)
      imposta.floor(ndec);
    else
      imposta.ceil(ndec);
  }
  netto = lordo - imposta; // Questo e' l'importo netto
  imposta_rec = (netto * iva) / 100.0; // Ricalcola l'imposta con il nuovo imponibile
  if (imposta_rec < ZERO)
    imposta_rec.floor(ndec);
  else
    imposta_rec.ceil(ndec);
  if (imposta != imposta_rec) // In questo caso corregge l'importo lordo 
    lordo = netto + imposta_rec;
  return netto;
}

real netto2lordo(const real& netto, const real& iva, int ndec)
{
  real lordo;
  real imposta = 0.0;
  if (!iva.is_zero())
  {
    imposta = (netto * iva) / 100.0; // Calcola l'imposta
    if(imposta < ZERO)
      imposta.floor(ndec);
    else
      imposta.ceil(ndec);
  }
  lordo = imposta + netto; // prezzo lordo
  return lordo;
}

bool scontoexpr2perc(const char * exp, bool signal , TString & goodexp, real & val_perc )
{
  bool valid = TRUE;

  goodexp.cut(0);  
  // Elimina gli spazi molesti
//  work.strip_spaces( );
  if (exp && *exp)
  {
    TString80 num;
    bool dec = FALSE;      // Flag che indica se si attende l'inizio di un numero
    bool startnum = TRUE;  // Flag che indica se siamo all'inizio di un numero   
    int errorchar = ' ';
    
    val_perc = 1.0;
    // Flag che indica se sono nella parte decimale di un numero
    for (const char * s  = exp; *s  && errorchar == ' '; s++)
    { 
      const char c = *s;
      switch(c)
      {
      case '+': 
      case '-':
        // Se ero in in numero ...
        if( !startnum )
        {
          // Aggiunge il numero alla sequenza
          real newval( num );
          val_perc *= ( CENTO - newval ) / CENTO;
          goodexp << num;
        }
        // Inizia il nuovo numero
        num = (c == '-') ? "-" : "+";  
        startnum = TRUE;
        dec = FALSE;
        break;         
      case '0':  
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        num << c;
        startnum = FALSE;
        break;
      case '.':
      case ',':
        if(!dec)
        {
          if( startnum )
            num << '0';        // Se occorreva un numero ci metto lo 0
          num << '.';          // Interpreto la virgola come punto
          dec = TRUE;       
          startnum = TRUE;
        }
        else
          errorchar = c;        // Se siamo gi` nella parte decimale segnala un errore
        break;
      case ' ':
        break;
      default:
        errorchar = c;
        break;         
      }
    }
    // Controlla la validita`
    valid = errorchar == ' ';
    
    if (valid)
    {
      // Aggiunge l'ultimo numero preso
      real lastval( num ); 
      val_perc *= ( CENTO - lastval ) / CENTO;
      goodexp << num; // Assegna la nuova espressione formattata bene     
    }
    else
    {
      if (signal)          // Se richiesto segnala l'errore
        warning_box( "Espressione di sconto non valida. Errore sul carattere %c.", errorchar);
      val_perc = 1.0;  // Azzera la sequenza di percentuali
      goodexp = "";
    }
  }
  return valid;
}

real prezzo_scontato(const real& prezzo, const char * sconto)
{    
  real scontato = prezzo;
  
  if (sconto && *sconto)
  {
    TString80 exp;
    real val_sconto;
    scontoexpr2perc(sconto, FALSE , exp, val_sconto);

    scontato = val_sconto * prezzo;
  }               
  return scontato;
} 

real iva(real imponibile, const TIVA & iva,int ndec)   
{            
   real val = imponibile * iva.aliquota() / 100.0;
                  
   if (ndec < 20)
   {               
     if (val < ZERO)
       val.floor(ndec);
     else               
       val.ceil(ndec);
   }
   return val;
}