campo-sirio/ve/velib01.cpp

#include <clifo.h>

// Togliere quando si toglie il metodo mask()
#include <varmask.h>

#include <tabutil.h>

#include "velib01.h"

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

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

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

real lordo2netto(real& lordo, const real& iva, bool is_valuta)
{
  real netto;
  real imposta = 0.0;
  real imposta_rec = 0.0; 
  if (!iva.is_zero())
  {
    imposta = (lordo * iva) / (iva + 100.0); // Calcola l'imposta...
    imposta.ceil(is_valuta ? 3 : 0);
  }
  netto = lordo - imposta; // Questo e' l'importo netto
  imposta_rec = (netto * iva) / 100.0; // Ricalcola l'imposta con il nuovo imponibile
  imposta_rec.ceil(is_valuta ? 3 : 0);
  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, bool is_valuta)
{
  real lordo;
  real imposta = 0.0;
  if (!iva.is_zero())
  {
    imposta = (netto * iva) / 100.0; // Calcola l'imposta
    imposta.ceil(is_valuta ? 3 : 0);
  }
  lordo = imposta + netto; // prezzo lordo
  return lordo;
}

///////////////////////////////////////////////////////////
// Tipo documento
///////////////////////////////////////////////////////////

TTipo_documento::TTipo_documento(const char* tipodoc)
               : _rec(LF_TABCOM), _mask(NULL)
{
  if (tipodoc && *tipodoc)
    read(tipodoc);
}

TTipo_documento::TTipo_documento(const TRectype& rec)
               : _rec(rec), _mask(NULL)
{ }

TTipo_documento::~TTipo_documento()
{                    
  if (_mask != NULL)
    delete _mask;
}

int TTipo_documento::read(const char* tipodoc)
{                                   
  TTable t("%TIP");
  t.put("CODTAB", tipodoc);
  int err = t.read();
  if (err == NOERR)
    _rec = t.curr();
  return err;  
}

///////////////////////////////////////////////////////////
// Documento per vendite
///////////////////////////////////////////////////////////
 
TAssoc_array TDocumento::_tipi;

TDocumento::TDocumento()
          : _head(LF_DOC), _rows(LF_RIGHEDOC, "NRIGA")
{
}

TDocumento::TDocumento(char provv, int anno, const char* codnum, long numdoc)
          : _head(LF_DOC), _rows(LF_RIGHEDOC, "NRIGA")
{
  read(provv, anno, codnum, numdoc);
}

int TDocumento::read(const TRectype& rec)
{                           
  _head = rec;    // Inizializza i campi chiave in ogni caso
  
  TLocalisamfile doc(LF_DOC);
  int err = _head.read(doc);
  
  TRectype* key = new TRectype(LF_RIGHEDOC);
  key->put("CODNUM", doc.get("CODNUM"));
  key->put("ANNO",   doc.get("ANNO"));
  key->put("PROVV",  doc.get("PROVV"));
  key->put("NUMDOC", doc.get("NUMDOC"));
  
  if (err == NOERR)
    err = _rows.read(key);
  else
  {
    _head = rec;
    _rows.set_key(key);
  }
  return err;
}

int TDocumento::read(char provv, int anno, const char* codnum, long numdoc)
{                           
  CHECK(codnum && *codnum && anno > 0 && (provv == 'D' || provv == 'P') && numdoc > 0,
        "Codice documento non valido");
  
  TRectype rec(_head);
  
  rec.zero();
  rec.put("CODNUM", codnum);
  rec.put("ANNO",   anno);
  rec.put("PROVV",  provv);
  rec.put("NUMDOC", numdoc);

  return read(rec);
}

int TDocumento::write(bool re) const
{
  TLocalisamfile doc(LF_DOC);
  int err = re ? _head.rewrite(doc) : _head.write(doc);
  if (err != NOERR)
    err = re ? _head.write(doc) : _head.rewrite(doc);
  if (err == NOERR)
    err = _rows.write(re);
  return err;  
}

int TDocumento::remove() const
{
  TLocalisamfile doc(LF_DOC);
  int err = _head.remove(doc);
  if (err == NOERR)
    err = _rows.remove();
  return err;  
}

const TTipo_documento& TDocumento::tipo() const
{
  const char* tipodoc = _head.get("TIPODOC");
  CHECK(*tipodoc, "Tipo documento nullo");
  TTipo_documento* o = (TTipo_documento*)_tipi.objptr(tipodoc);
  if (o == NULL)
  {
    o = new TTipo_documento(tipodoc);
    _tipi.add(tipodoc, o);
  }
  return *o;
}

///////////////////////////////////////////////////////////
// Lista di documenti
///////////////////////////////////////////////////////////

int TLista_documenti::leggi(char tipo, long clifo,
                            const TDate& dd, const TDate& ad)
{       
  _documenti.destroy();

  TString filter(256);
  filter << '(' << CLI_TIPOCF << '=' << tipo << ")&&(" 
         << CLI_CODCF << '=' << clifo << ")";
  if (dd.ok() && dd > botime)       
    filter << "&&(ANSI(DATADOC)>=" << dd.string(ANSI) << ')';
  if (ad.ok() && ad < eotime)       
    filter << "&&(ANSI(DATADOC)<=" << ad.string(ANSI) << ')';
    
  return 0;  
}                            

///////////////////////////////////////////////////////////
// Cliente/Fornitore per vendite
///////////////////////////////////////////////////////////

void TLista_clifo::TClifo::init(const TRectype& rec)
{                              
  CHECK(rec.num() == LF_CFVEN, "E' necessario un cliente per vendite");
  _codice = rec.get_long(CLI_CODCF);
  _agente = rec.get_long(CLI_CODAG);
  _zona   = rec.get_long(CLI_CODZONA);
}

bool TLista_clifo::TClifo::read(char tipo, long cod)
{
  TRelation clifo(LF_CLIFO);
  clifo.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
  
  clifo.curr().put(CLI_TIPOCF, tipo);
  clifo.curr().put(CLI_CODCF, cod);
  if (clifo.read() == NOERR)
    init(clifo.curr(LF_CFVEN));
  else
    zero();  
  
  return ok();  
}

TLista_clifo::TClifo::TClifo(const TRectype& rec)
{
  if (rec.num() == LF_CFVEN)
    init(rec);
  else  
  {
    const char tipo = rec.get_char(CLI_TIPOCF);
    const long codice = rec.get_long(CLI_CODCF);
    read(tipo, codice);
  }
}   

int TLista_clifo::leggi(long dc, long ac, long da, long aa, long dz, long az)
{
  TRelation clifo(LF_CLIFO);
  clifo.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
  
  TRectype start(LF_CLIFO), stop(LF_CLIFO);
  
  start.put(CLI_TIPOCF, tipo()); 
  if (dc > 0) 
    start.put(CLI_CODCF, dc); 

  stop.put(CLI_TIPOCF, tipo()); 
  if (ac > 0) 
    stop.put(CLI_CODCF, ac);
  
  TString filter(32);
  if (da > 0) 
    filter << '(' << LF_CFVEN << "->" << CLI_CODAG << ">=" << da << ')';
  if (aa > 0) 
  {
    if (filter.not_empty()) filter << "&&";
    filter << '(' << LF_CFVEN << "->" << CLI_CODAG << "<=" << aa << ')';
  }
  if (dz > 0) 
  {
    if (filter.not_empty()) filter << "&&";
    filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << ">=" << dz << ')';
  }  
  if (az > 0) 
  {
    if (filter.not_empty()) filter << "&&";
    filter << '(' << LF_CFVEN << "->" << CLI_CODZONA << "<=" << az << ')';
  }  
  
  TCursor cur(&clifo, filter, 1, &start, &stop);
  for (cur = 0; cur.ok(); ++cur)
  {
    TClifo* c = new TClifo(cur.curr(LF_CFVEN));
    _clifo.add(c);
  }
  
  if (dc > 0 || ac > 0) ordina_per_codice(); else
  if (da > 0 || aa > 0) ordina_per_agente(); else
  if (dz > 0 || az > 0) ordina_per_zona();
  
  return _clifo.items();
}

int TLista_clifo::sort_by_code(const TObject** o1, const TObject** o2)
{
  TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
  TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
  const long d = c1->codice() - c2->codice();
  return d == 0L ? 0 : (d > 0 ? +1 : -1);
}

int TLista_clifo::sort_by_agent(const TObject** o1, const TObject** o2)
{
  TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
  TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
  const long d = c1->agente() - c2->agente();
  return d == 0L ? 0 : (d > 0 ? +1 : -1);
}

int TLista_clifo::sort_by_zone(const TObject** o1, const TObject** o2)
{
  TLista_clifo::TClifo* c1 = (TLista_clifo::TClifo*)*o1;
  TLista_clifo::TClifo* c2 = (TLista_clifo::TClifo*)*o2;
  const long d = c1->zona() - c2->zona();
  return d == 0L ? 0 : (d > 0 ? +1 : -1);
}

int TLista_clifo::ordina_per_codice()
{
  _clifo.sort(sort_by_code);
  return _clifo.items();
}

int TLista_clifo::ordina_per_agente()
{
  _clifo.sort(sort_by_agent);
  return _clifo.items();
}

int TLista_clifo::ordina_per_zona()
{
  _clifo.sort(sort_by_zone);
  return _clifo.items();
}

int TLista_clifo::find(long cod) const
{
  for (int i = items()-1; i >= 0; i--)
    if (clifo(i).codice() == cod) break;
  return i;  
}

int TLista_clifo::add(long cod)
{
  int pos = find(cod);
  if (pos < 0)
  {
    TClifo* c = new TClifo(tipo(), cod);
    pos = _clifo.add(c);
  }
  return pos;
}