campo-sirio/ve/velib01.cpp

#include "velib.h"

/////////////////////////////////////////////////////////////
// TCodice_numerazione
/////////////////////////////////////////////////////////////

TCodice_numerazione::TCodice_numerazione(const char* codnum)
                   : TRectype(LF_TABCOM)
{
  settab("NUM");
  if (codnum && *codnum)
    read(codnum);
  else
    setempty(TRUE);  
}

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

TCodice_numerazione::~TCodice_numerazione()
{                    
}

const TString& TCodice_numerazione::tipo_doc(int i) const
{
  CHECK(i < MAX_TIPI_DOC, "Impossibbile tipo documento"); 
  const char * field = i < 17 ? "S2" : "S3";
  
  if (i > 16)
    i -= 17;
  return ((TString& ) get(field).mid(i << 2, 4)).trim();
}                                             

int TCodice_numerazione::ntipi_doc() const
{
  int l = get("S3").len(); 
  if (l > 0)
    return ((l - 1) >> 2) + 18;
  l = get("S2").len();
  return l ? (((l - 1) >> 2) + 1) : 0;
}
void TCodice_numerazione::complete_num(long num, TString& codnum) const
{
  codnum = prefisso();
  codnum << num;
  codnum << postfisso();
}

int TCodice_numerazione::read(const char* codnum)
{                                   
  *this = cache().get("%NUM", codnum);
  int err = empty() ? _iskeynotfound : NOERR; 
#ifdef DBG  
  if (err != NOERR)
    NFCHECK("Codice numerazione errato: %s", codnum);
#endif    
  return err;  
}

/////////////////////////////////////////////////////////////
// TSpesa_prest
/////////////////////////////////////////////////////////////

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)
  {
    const int err = read(codice);
#ifdef DBG
    if (err != NOERR)
       error_box(spesa ? "Spesa %s assente" : "Prestazione %s assente", codice);
#endif

  }
}

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

int TSpesa_prest::read(const char* codice)
{                      
  const TString8 cod = get("COD");
  *this = cache().get(cod, codice);
  return empty() ? _iskeynotfound : NOERR;
}

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