campo-sirio/pr/prlib01.cpp

#include "prlib.h"
#include "provv.h"
#include <doc.h>

// TProvvigioni_agente


TProvvigioni_agente::TProvvigioni_agente()
{
  _rows = new TRecord_array(LF_PROVV,PROV_NRIGA);
}

TProvvigioni_agente::TProvvigioni_agente(const char* agente)
{
  _rows = new TRecord_array(LF_PROVV,PROV_NRIGA);
  read(agente);
}

TProvvigioni_agente::~TProvvigioni_agente()
{
  delete _rows;
}

int TProvvigioni_agente::read(const char* agente)
{
  int err = NOERR;
  TRectype rec(LF_PROVV);

  rec.put(PROV_CODAGE,agente);
  _agente = agente;
  _rate.destroy();
  _rows->destroy_rows();
  err = _rows->read(rec); // Legge tutte le righe provvigionali di codesto agente

  if (err != NOERR)
    return err;
    
  const int rows = _rows->rows();
  int anno;
  long ndoc;
  TString key,codnum;
  for (int i = 1; i <= rows; i++)  // Compila l'assoc_array per documenti/rate
  {
    TRectype& r = _rows->row(i,FALSE);
    anno = r.get_int(DOC_ANNO);
    codnum = r.get(DOC_CODNUM);
    ndoc = r.get_long(DOC_NDOC);
    key.format("%4d%4s%7ld",anno,(const char*)codnum,ndoc); // Compone la chiave

    const bool exist = _rate.is_key(key);  // Guarda se esiste gia' questo documento
    TRate_doc  com_rata(r);
    TRate_doc& rd = exist ? (TRate_doc&) _rate[key] : com_rata;
    TRata* rt = new TRata(r);
    rd.add_rata(rt);

    _rate.add(key,rd,exist); // Sostituisce/aggiunge l'elemento
  }
  
  // Dopo aver letto le righe, ordina le rate per ogni documento
  for (TRate_doc* rd = (TRate_doc*) _rate.first_item(); rd != NULL; rd = (TRate_doc*) _rate.succ_item())
    rd->sort_rate();

  return err;
}

void TProvvigioni_agente::rate2rows()
{
  _rows->destroy_rows();
  // Setta la chiave del TRecord_array
  TRectype* chiave = new TRectype(LF_PROVV);
  chiave->put(PROV_CODAGE, _agente);
  _rows->set_key(chiave);
  // Scorre gli elementi di _rate (TDoc_rate) uno ad uno
  // per settare le righe provvigionali 
  TString_array kl;
  const int items = documenti(kl); // Prende l'elenco dei documenti
  kl.sort();                       // ordina per documento
  int nrow = 1;
  for (int i = 0; i < items; i++)
  {
    TRate_doc& rd = (TRate_doc&)_rate[kl.row(i)];
    const int ritems = rd.items(); // Ciclo per rate di questo documento
    for (int j = 0; j < ritems; j++)
    {
      TRata& rt        =  rd[j];
      TRectype* record =  new TRectype(LF_PROVV);
      record->put(PROV_CODAGE,_agente);
      record->put(PROV_NRIGA,nrow++);
      record->put(PROV_ANNO,rd.anno());
      record->put(PROV_CODNUM,rd.codnum());
      record->put(PROV_NDOC,rd.ndoc());
      record->put(PROV_NRATA,rt.rata());
      record->put(PROV_GENERATA,rt.generata());
      record->put(PROV_SALDATA,rt.saldata());
      record->put(PROV_TIPOPAGPR,rt.tipopagpr());
      record->put(PROV_DATADOC,rd.datadoc());
      record->put(PROV_IMPDOC,rd.impdoc());
      record->put(PROV_IMPPRDOC,rd.impprdoc());
      record->put(PROV_IMPNETDOC,rd.impnet());
      record->put(PROV_CODCLI,rd.codcf());
      record->put(PROV_TIPOPAG,rd.tipo());
      record->put(PROV_CODVAL,rd.codval());
      record->put(PROV_DATACAMBIO,rd.datacam());
      record->put(PROV_CAMBIO,rd.cambio());
      record->put(PROV_DATASCAD,rt.datascad());
      record->put(PROV_IMPRATA,rt.imprata());
      record->put(PROV_IMPPROVV,rt.impprovv());
      record->put(PROV_PAGATO,rt.pagato());
      record->put(PROV_PROVVPAG,rt.provvpag());
      record->put(PROV_PAGMAT,rt.pagmat());
      record->put(PROV_PROVVMAT,rt.provvmat());
      _rows->add_row(record);
    }
  }
}

int TProvvigioni_agente::write(bool rows)
{ 
  if (!rows)
    rate2rows();
  return _rows->write();
}

int TProvvigioni_agente::rewrite(bool rows)
{
  if (!rows)
    rate2rows();
  return _rows->rewrite();
}

int TProvvigioni_agente::remove(bool rows)
{
  if (!rows)
    rate2rows();
  return _rows->remove();
}

TRate_doc& TProvvigioni_agente::rate(int anno, const char* codnum, long ndoc, bool create)
{
  TString k;
  
  k.format("%4d%4s%7ld",anno,codnum,ndoc);
  return rate(k,create);
}

TRate_doc& TProvvigioni_agente::rate(const char* key, bool create)
{
  const bool exist = _rate.is_key(key);
  if (!exist)
  {
    if (create)
    {
      TRectype r(LF_PROVV);
      TString  k(key);
      r.put(PROV_ANNO,k.sub(0,4));
      r.put(PROV_CODNUM,k.sub(4,8));
      r.put(PROV_NDOC,k.sub(8));
      TRate_doc* rd = new TRate_doc(r);
      _rate.add(key,rd);
    }
    else
      fatal_box("Impossibile trovare l'elemento %s tra le righe provvigionali",key);
  }
  return (TRate_doc&) _rate[key];
}

void TProvvigioni_agente::remove_rate(int anno, const char* codnum, long ndoc)
{
  TString k;
  
  k.format("%4d%4s%7ld",anno,codnum,ndoc);
  remove_rate(k);
}

void TProvvigioni_agente::remove_rate(const char* key)
{
  const bool exist = _rate.is_key(key);
  if (exist)
    _rate.remove(key);
  else
    fatal_box("Impossibile trovare l'elemento %s tra le righe provvigionali", key);
}

/////////////////////////////////////////////////////////////////////////////////
// TRate_doc
/////////////////////////////////////////////////////////////////////////////////

TRate_doc::TRate_doc(TRectype& rec)
{
  set(rec); // bleah!
}

bool TRate_doc::ok_provvigione()
{
  real totprov;
  const int its = items();

  for (int i = 0; i < its; i++) // Somma le provvigioni di tutte le rate
    totprov += row(i).impprovv();
    
  return totprov <= _impprdoc; // controlla che tale somma e' compresa nel totale provvigione del documento 
}

void TRate_doc::set(TRectype& rec)
{
  CHECK(rec.num() == LF_PROVV,"Il record non ha il tracciato di LF_PROVV");
  _anno       = rec.get_int(PROV_ANNO);
  _codnum     = rec.get(PROV_CODNUM);
  _codval     = rec.get(PROV_CODVAL);
  _ndoc       = rec.get_long(PROV_NDOC);
  _codcf      = rec.get_long(PROV_CODCLI);
  _datadoc    = rec.get_date(PROV_DATADOC);
  _datacambio = rec.get_date(PROV_DATACAMBIO);
  _tipopag    = rec.get_char(PROV_TIPOPAG);
  _impdoc     = rec.get_real(PROV_IMPDOC);
  _impprdoc   = rec.get_real(PROV_IMPPRDOC);
  _impnetdoc  = rec.get_real(PROV_IMPNETDOC);
  _cambio     = rec.get_real(PROV_CAMBIO);
}

void TRate_doc::set(TToken_string& t)
{
  CHECK(t.items() >= 12, "Numero di items non valido");
  _anno       = t.get_int(0);
  _codnum     = t.get(1);
  _ndoc       = t.get_long(2);
  _datadoc    = t.get(3);
  _impdoc     = t.get(4);
  _impprdoc   = t.get(5);
  _impnetdoc  = t.get(6);
  _codcf      = t.get_long(7); 
  _tipopag    = t.get_char(8);
  _codval     = t.get(9); 
  _cambio     = t.get(10); 
  _datacambio = t.get(11); 
}

/////////////////////////////////////////////////////////////////////////////////
// TRata
/////////////////////////////////////////////////////////////////////////////////
int TRata::compare(const TSortable& s) const
{
  const TRata& r = (const TRata&) s;
  
  if (_nrata > r.rata()) 
    return 1; // Numero maggiore
  else
    if (_nrata < r.rata());
      return -1; // Numero minore
  
  return 0; // Stesso numero di rata
}

void TRata::set(TToken_string& t)
{
  CHECK(t.items() == 10, "Troppi pochi elementi nella token string");
  _nrata    = t.get_int(0);
  _datascad = t.get(1);
  _imprata  = t.get(2);
  _impprovv = t.get(3);
  _pagmat   = t.get(4);
  _provvmat = t.get(5);
  _pagato   = t.get(6);
  _provvpag = t.get(7);
  _saldata  = t.get(8)[0] == 'X' ? TRUE : FALSE;
  _tipopagpr = t.get_int(9);
}

void TRata::set(TRectype& rec)
{
  CHECK(rec.num() == LF_PROVV,"Il record non ha il tracciato di LF_PROVV");
  _datascad = rec.get_date(PROV_DATASCAD);
  _imprata  = rec.get_real(PROV_IMPRATA);
  _impprovv = rec.get_real(PROV_IMPPROVV);
  _pagato   = rec.get_real(PROV_PAGATO);
  _provvpag = rec.get_real(PROV_PROVVPAG);
  _pagmat   = rec.get_real(PROV_PAGMAT);
  _provvmat = rec.get_real(PROV_PROVVMAT);
  _saldata  = rec.get_bool(PROV_SALDATA);
  _nrata    = rec.get_int(PROV_NRATA);
  _generata = rec.get_char(PROV_GENERATA);
  _tipopagpr = rec.get_int(PROV_TIPOPAGPR);
}

TRata::TRata(TRectype& rec)
{
  set(rec);
}