campo-sirio/lv/lvlib.cpp

#include "lvlib.h"
#include "lvrcondv.h"
#include "lvcondv.h"

#include "../cg/cglib01.h"
#include "../mg/clifogiac.h"

#include <config.h>
#include <recset.h>
#include <utility.h>

///////////////////////////////////////////////////////////
// Utilities
///////////////////////////////////////////////////////////

void lv_set_creation_info(TRectype& rec)
{
  rec.set_creation_info();
}

void lv_set_update_info(TRectype& rec)
{
  rec.set_modify_info();
}

//funzione che restituisce true se la data che gli passo <20> una festivit<69>
bool lv_is_holiday(const TDate& data)
{
  static TAssoc_array calendari;

  const int anno = data.year();
  
  TString16 key;
  key.format("%05ld%4d",prefix().get_codditta(),anno);

  TString* cal = (TString*)calendari.objptr(key);

  if (cal == NULL)
  {
    TConfig ini(CONFIG_DITTA);
    cal = new TString(366);
    calendari.add(key,cal);
    *cal = ini.get("CAL", "lv", anno);
    cal->left_just(366,'-');
  }

  const TDate primo(1,1,anno);
  const long index = data - primo;
  
  return (*cal)[index] == 'X';
}

//funzione che restituisce un codice contratto valido dato cliente, indirizzo di spedizione e data
long lv_find_contract(const long codcf, const long indsped, const TDate& data)
{
  TString query;
  query << "USE LVCONDV\n"
        << "SELECT BETWEEN(#DATA,DATAIN,DATASC)&&BETWEEN(CODINDSP,#INDSPED,#INDSPED)&&(PROPOSTA!=\"X\")\n"
        << "FROM CODCF=#CODCF\nTO CODCF=#CODCF";
  TISAM_recordset contr(query);
  contr.set_var("#DATA",data);
  contr.set_var("#INDSPED",indsped);
  contr.set_var("#CODCF",codcf);

  long cod = 0L;
  if (contr.move_first())
    cod = contr.get("CODCONT").as_int();

  if (cod == 0L)
  {
    query.cut(0);
    query << "USE LVCONDV\n"
          << "SELECT BETWEEN(#DATA,DATAIN,DATASC)&&(PROPOSTA!=\"X\")\n"
          << "FROM CODCF=#CODCF\nTO CODCF=#CODCF";
    TISAM_recordset contr(query);
    contr.set_var("#DATA",data);
    contr.set_var("#CODCF",codcf);

    if (contr.move_first())
      cod = contr.get("CODCONT").as_int();
  }

  return cod;
}

///////////////////////////////////////////////////////////
// TLaundry_contract
///////////////////////////////////////////////////////////

TRectype& TLaundry_contract::modify_row(const char* codart)
{ 
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  int err = rcondv.read();

  TRectype& riga = rcondv.curr();
  return riga;
}

// Ritorna la riga di contratto corrispondente a codart
const TRectype& TLaundry_contract::row(const char* codart) const
{
  TToken_string key;
  key.add(get(LVRCONDV_CODCF));
  key.add(get(LVRCONDV_CODCONT));
  key.add(codart);
  return cache().get(LF_LVRCONDV, key);
}

// Controlla se il contratto esiste veramente
bool TLaundry_contract::ok() const
{ return !empty(); }

bool TLaundry_contract::can_be_deleted() const
{
  const TString4 codnum = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");

  TString query;
  query << "USE DOC KEY 4 SELECT CODNUM=#CODNUM \n"
        << "FROM TIPOCF=C CODCF=#CODCF PROVV=D \n"
        << "TO TIPOCF=C CODCF=#CODCF PROVV=D \n";

  TISAM_recordset rset(query);

  rset.set_var("#CODNUM",TVariant(codnum));
  rset.set_var("#CODCF",get_long(LVCONDV_CODCF));
  
  return !rset.move_first();
}

//aggiunge una riga al contratto con quel codart
int TLaundry_contract::add_row(const char* codart)
{
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  return rcondv.rewrite_write();
}

//fa l'update di una riga del contratto
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const bool bol)
{
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  int err = rcondv.read();
  
  //se il record esiste
  if (err == NOERR)
  {
    rcondv.put(LVRCONDV_CODCF, codcf);
    rcondv.put(LVRCONDV_CODCONT, codcont);
    rcondv.put(LVRCONDV_CODART, codart);
    rcondv.put(fieldname, bol);
    err = rcondv.rewrite();
  }
  
  return err;
}

//fa l'update di una riga del contratto
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const char* str)
{
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  int err = rcondv.read();
  
  //se il record esiste
  if (err == NOERR)
  {
    rcondv.put(LVRCONDV_CODCF, codcf);
    rcondv.put(LVRCONDV_CODCONT, codcont);
    rcondv.put(LVRCONDV_CODART, codart);
    rcondv.put(fieldname, str);
    err = rcondv.rewrite();
  }
  
  return err;
}

//fa l'update di una riga del contratto
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const long nmr)
{
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  int err = rcondv.read();
  
  //se il record esiste
  if (err == NOERR)
  {
    rcondv.put(LVRCONDV_CODCF, codcf);
    rcondv.put(LVRCONDV_CODCONT, codcont);
    rcondv.put(LVRCONDV_CODART, codart);
    rcondv.put(fieldname, nmr);
    err = rcondv.rewrite();
  }
  
  return err;
}

//fa l'update di una riga del contratto
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const real nmr)
{
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  int err = rcondv.read();
  
  //se il record esiste
  if (err == NOERR)
  {
    rcondv.put(LVRCONDV_CODCF, codcf);
    rcondv.put(LVRCONDV_CODCONT, codcont);
    rcondv.put(LVRCONDV_CODART, codart);
    rcondv.put(fieldname, nmr);
    err = rcondv.rewrite();
  }
  
  return err;
}

//fa l'update di una riga del contratto
int TLaundry_contract::update_row(const char* codart, const char* fieldname, const TDate& data)
{
  const long codcf   = get_int(LVRCONDV_CODCF);
  const long codcont = get_int(LVRCONDV_CODCONT);

  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF, codcf);
  rcondv.put(LVRCONDV_CODCONT, codcont);
  rcondv.put(LVRCONDV_CODART, codart);

  int err = rcondv.read();
  
  //se il record esiste
  if (err == NOERR)
  {
    rcondv.curr().zero();
    rcondv.put(LVRCONDV_CODCF, codcf);
    rcondv.put(LVRCONDV_CODCONT, codcont);
    rcondv.put(LVRCONDV_CODART, codart);
    rcondv.put(fieldname, data);
    err = rcondv.rewrite();
  }
  
  return err;
}

// Legge un contratto tramite la chiave primaria cliente+codice
bool TLaundry_contract::read(const long codcf, const long codcont)
{
  if (codcf > 0 && codcont > 0) // Campi obbligatori!
  {
    TString16 key; key.format("%ld|%ld", codcf, codcont);
    *((TRectype*)this) = cache().get(LF_LVCONDV, key);
  }
  else
    zero();
  return ok();
}

// Cerca il contratto in essere alla data di un certo cliente+indirizzo
bool TLaundry_contract::read(const long codcf, const long indsped, const TDate& data)
{
  const long codcont = lv_find_contract(codcf, indsped, data);
  return read(codcf, codcont);
}

// Inizializza un contratto vuoto: servira' una read successiva
TLaundry_contract::TLaundry_contract() : TRectype(LF_LVCONDV)
{ zero(); }

TLaundry_contract::TLaundry_contract(const TRectype & rec): TRectype(rec)
{
}
// Inizializza un contratto in base alla chiave primaria
TLaundry_contract::TLaundry_contract(const long codcf, const long codcont) 
                 : TRectype(LF_LVCONDV)
{ read(codcf, codcont); }

// Tenta di inizilizzare il contratto corrente di un cliente
TLaundry_contract::TLaundry_contract(const long codcf, const long indsped, const TDate& data)
                 : TRectype(LF_LVCONDV)
{ read(codcf, indsped, data); }

///////////////////////////////////////////////////////////
// TRecmag_lavanderie
///////////////////////////////////////////////////////////

void TRecmag_lavanderie::update()
{
	if (_update_time > 0L)
		return;

	_update_time = 1L;

  TString query, filter;
	const int anno = get_int(CLIFOGIAC_ANNOES);
	const TString4 tipocf(get(CLIFOGIAC_TIPOCF));
	const long codcf = get_long(CLIFOGIAC_CODCF);
  const int indsped = get_int(CLIFOGIAC_INDSPED);
	const TString80 codart(get(CLIFOGIAC_CODART));
	const TString80 livello(get(CLIFOGIAC_LIVELLO));
  const TDate oggi(TODAY);
  TDate imese;
	TEsercizi_contabili & esc = esercizi();
	const TArticolo & artrec = cached_article(codart);

	if (anno >= esc.date2esc(oggi))
	{
		imese = oggi;
		imese.set_day(1);
	}
	else
		imese = esc.esercizio(anno).fine();
  
  query="USE MOVMAG KEY 2\n";
  query << "SELECT (TIPOCF='C')&&(CODCF==" << codcf << ")&&(STR(CODINDSP==" << indsped << "))&&(BETWEEN(DATACOMP," << imese.date2ansi() << "," << oggi.date2ansi() << "))\n";
  query << "FROM ANNOES=" << anno << "\n";
  query << "TO ANNOES=" << anno << "\n";

  TISAM_recordset recmag(query);

  for (bool ok=recmag.move_first(); ok; ok=recmag.move_next())
  {
		const TDate datareg = recmag.get(MOVMAG_DATAREG).as_date();
    TString queryrmag="USE RMOVMAG\n";
		queryrmag << " SELECT (CODART=\"" << codart << "\")&&(LIVGIAC=\"" << livello << "\")\n";
		queryrmag << "FROM NUMREG=" << recmag.get(MOVMAG_NUMREG) << "\n"
              << "TO NUMREG=" << recmag.get(MOVMAG_NUMREG) << "\n";
    
    TISAM_recordset recrmag(queryrmag);

    for (bool ok=recrmag.move_first(); ok; ok=recrmag.move_next())
    {
      const TString& codcaus = recrmag.get(RMOVMAG_CODCAUS).as_string();
			const TCausale_magazzino & tcaus = cached_causale_magazzino(codcaus.full() ? codcaus : recmag.get(MOVMAG_CODCAUS).as_string());
      int sgn_consmese = tcaus.sgn(s_consmese);
      if (sgn_consmese != 0)
      {
        const TString4 um = recrmag.get(RMOVMAG_UM).as_string();
        const real qta = ((TArticolo &)artrec).convert_to_um(recrmag.get(RMOVMAG_QUANT).as_real(), NULL,um);

				_consmese += real(qta * sgn_consmese);
      }
    }
	}
}

int TRecmag_lavanderie::name2index(const char* fieldname) const
{
	if (strcmp(fieldname, "CONSMESE") == 0)
		return 0;
	return -1;
}

TFieldtypes TRecmag_lavanderie::type(const char* fieldname) const

{
  if (name2index(fieldname) >= 0)
    return _realfld; 
  return TRectype::type(fieldname);
}


int TRecmag_lavanderie::length(const char* fieldname) const

{
  if (name2index(fieldname) >= 0)
    return 15;
  return TRectype::length(fieldname);
}


int TRecmag_lavanderie::ndec(const char* fieldname) const
{
  if (name2index(fieldname) >= 0)
    return 5; 
  return TRectype::ndec(fieldname);
}

bool TRecmag_lavanderie::exist(const char* fieldname) const
{                   
  if (name2index(fieldname) >= 0)
    return true;
  return TRectype::exist(fieldname);
}

const TString & TRecmag_lavanderie::get_str(const char* fieldname) const
{ 
	const int index = name2index(fieldname);

	if (index >= 0)
		((TRecmag_lavanderie *)this)->update();
	switch (index)
	{
		case  0: return get_tmp_string() = _consmese.string();
		default: break;
	}
//    rec.put(CLIFOGIAC_DOTOD, oldrec.get(CLIFOGIAC_DOTOD));
//    rec.put(CLIFOGIAC_DOTIN, oldrec.get(CLIFOGIAC_DOTIN));

	return TVariable_rectype::get_str(fieldname);
}

TRecmag_lavanderie::TRecmag_lavanderie()
                  : TVariable_rectype(LF_CLIFOGIAC)
{
}

TObject* TRecmag_lavanderie::dup() const
{
  TRecmag_lavanderie* o = new TRecmag_lavanderie(*this);
  return o;
}

///////////////////////////////////////////////////////////
// TArticolo_lavanderie
///////////////////////////////////////////////////////////

const TString & TArticolo_lavanderie::get_str(const char* fieldname) const
{ 
  if (*fieldname != '#')
    return TRectype::get_str(fieldname);
  char * fname = (char *) fieldname + 1;
  const int logicnum = atoi(fname);
  if (logicnum != LF_CLIFOGIAC)
		return TArticolo_giacenza_data::get_str(fieldname);

  const char * op1 =  strchr(fname, '_');
  int index = 0;
  if (op1)
  {
    op1=op1+1;
    fname = (char *) op1;
    if (*op1 == '#')
      index = atoi(fname + 1);             
  }
  const char * op2 = strchr(fname, '_');
  if (op2) 
  {
    op2=op2+1;
    fname = (char *) op2 + 1;
  }
  const char * op3 = strchr(fname, '_');
  if (op3) 
  {
    op3=op3+1;
    fname = (char *) op3 + 1;
  }
  const char * op4 = strchr(fname, '_');
  if (op4) 
  {
    op4=op4+1;
    fname = (char *) op2 + 1;
  }
  const char * op5 = strchr(fname, '_');
  if (op5)
    op5=op5+1;
  const char * op6 = strstr(fname, "->"); 
  CHECKS(op6, "Can't find '->' in string ", fieldname);
  op6=op6+2;
       
  if (logicnum == LF_CLIFOGIAC && op2 && op3 && op4)
	{
		((TArticolo_lavanderie *)this)->set_tipocf(*op2);
		((TArticolo_lavanderie *)this)->set_codcf(atol(op3));
		((TArticolo_lavanderie *)this)->set_indsped(atol(op4));
    if (index == 0)
      index = find_clifomag(op1, op5);
    if (index > 0)
      return clifomag(op1).row(index).get(op4);
	}
  return EMPTY_STRING;
}

void TArticolo_lavanderie::set_body_key(TRectype & rowrec)
{
  const int logicnum = rowrec.num();
  const char * cod = (const char *) codice();
  
  switch (logicnum)
  { 
    case LF_CLIFOGIAC:
      rowrec.put(CLIFOGIAC_ANNOES, _anno_lav);
      rowrec.put(CLIFOGIAC_CODART, cod);
      rowrec.put(CLIFOGIAC_TIPOCF, _tipocf);
      rowrec.put(CLIFOGIAC_CODCF, _codcf);
      rowrec.put(CLIFOGIAC_INDSPED, _indsped);
      break;
    default:
      TArticolo_giacenza_data::set_body_key(rowrec);
      break;
  }
}

void TArticolo_lavanderie::set_anno_lav (int anno)
{
  if (_anno_lav != anno)
    remove_body(LF_CLIFOGIAC);
  _anno_lav = anno;
}

TRectype * TArticolo_lavanderie::new_body_record(int logicnum)
{
	if (logicnum == LF_CLIFOGIAC)
		return new TRecmag_lavanderie();
	return new TRectype(logicnum ? logicnum : TArticolo_giacenza_data::num());
}

int TArticolo_lavanderie::find_clifomag(TRecord_array& rclifomag, const char * livello, int from) const

{
  const int last = rclifomag.last_row();

  if (last > 0 && from < last)
  {
    const int livello_len = livello ? strlen(livello) : 0;   
    
    if (livello_len == 0)
      return from + 1;

    for (int i = rclifomag.succ_row(from); i <= last; i = rclifomag.succ_row(i))
    {
      const TRectype & rec = rclifomag.row(i);
    
			if (livello_len == 0 || rec.get(CLIFOGIAC_LIVELLO).compare(livello, livello_len) == 0)
				return i;
    }
  }
  return -1;
}

int TArticolo_lavanderie::find_clifomag(int annoes, const char * livello, int from) const
{
  TRecord_array & rclifomag = clifomag(annoes);
  return find_clifomag(rclifomag, livello, from);  
}

TRecord_array & TArticolo_lavanderie::clifomag(int annoes) const
{
	((TArticolo_lavanderie*)this)->set_anno_lav(annoes > 0 ? annoes : esercizi().last_mag());
	TRecord_array & recarr = body(LF_CLIFOGIAC);

	if (recarr.rows() == 0)
	{
		TString query;
		const char * cod = (const char *) codice();
		const int esprec = esercizi().pred(annoes);

		query << "USE " << LF_CLIFOGIAC << "\n";
		query << "FROM " << CLIFOGIAC_ANNOES << '=' << esprec << ' '
									 << CLIFOGIAC_TIPOCF << '=' << _tipocf << ' '
									 << CLIFOGIAC_CODCF << '=' << _codcf << ' '
									 << CLIFOGIAC_INDSPED << '=' << _indsped << ' '
									 << CLIFOGIAC_CODART << '=' << cod << '\n';
		query << "TO " << CLIFOGIAC_ANNOES << '=' << esprec << ' '
									 << CLIFOGIAC_TIPOCF << '=' << _tipocf << ' '
									 << CLIFOGIAC_CODCF << '=' << _codcf << ' '
									 << CLIFOGIAC_INDSPED << '=' << _indsped << ' '
 									 << CLIFOGIAC_CODART << '=' << cod << '\n';

		TISAM_recordset recmag(query);
		for (bool ok=recmag.move_first(); ok; ok=recmag.move_next())
		{
			const TRecmag_lavanderie oldrec(recmag.cursor()->curr());
			const int r = recarr.add_row(oldrec);
			TRecmag_lavanderie & rec = (TRecmag_lavanderie &) recarr[r];

			rec.put(CLIFOGIAC_ANNOES, annoes);
			::reset_clifogiac(rec, oldrec);
		}
	}
	return recarr;
}
const TRecmag_lavanderie & TArticolo_lavanderie::find_rec(int annoes) const
{
	static TRecmag_lavanderie __rec;
	const int i = find_clifomag(annoes);

	if (i >= 0)
		return (const TRecmag_lavanderie &) clifomag(annoes).row(i);

  __rec.zero();
  return __rec;
}

TArticolo_lavanderie::TArticolo_lavanderie(const char* codice, const char tipocf, const long codcf, const int indsped)
										 : TArticolo_giacenza_data(codice), _anno_lav(0),
										   _tipocf(tipocf), _codcf(codcf), _indsped(indsped)

{
  add_file(LF_CLIFOGIAC ,"NRIGA");
}

TArticolo_lavanderie::TArticolo_lavanderie(const TRectype & rec, const char tipocf, const long codcf, const int indsped)
										 : TArticolo_giacenza_data(rec), _anno_lav(0),
										   _tipocf(tipocf), _codcf(codcf), _indsped(indsped)

{
  add_file(LF_CLIFOGIAC ,"NRIGA");
}

///////////////////////////////////////////////////////////
// TCache_articoli_lavanderie
///////////////////////////////////////////////////////////

class TCache_articoli_lavanderie : public TRecord_cache
{
protected:
  virtual TObject* rec2obj(const TRectype& rec) const { return new TArticolo_lavanderie(rec);}

public:
  TArticolo_lavanderie& lav(const char* key) { return (TArticolo_lavanderie&)query(key); }

	TCache_articoli_lavanderie();
  virtual ~TCache_articoli_lavanderie() { }
};

TCache_articoli_lavanderie::TCache_articoli_lavanderie()
												   : TRecord_cache(LF_ANAMAG, 1)
{ 
  test_file_changes();   // Tieni d'occhio le modifiche sul file
  set_items_limit(256);  // Standard
}        

TArticolo_lavanderie & cached_article_laundry(const char * codart, const char tipocf, const long codcf, const int indsped)
{
	HIDDEN TCache_articoli_lavanderie __cache_articoli_lavanderie;

	TArticolo_lavanderie & art = __cache_articoli_lavanderie.lav(codart);
	
	art.set_tipocf(tipocf);
	art.set_codcf(codcf);
	art.set_indsped(indsped);
	return art;
}

///////////////////////////////////////////////////////////
// TLavanderie_calendar
///////////////////////////////////////////////////////////

// Serve per aggiungere le feste dei Patroni
void TLavanderie_calendar::set_holiday(const TDate & date, bool holiday)
{
	if (_year == date.year())
	{
		const TDate inizio(1, 1, _year);
		long ndays = date - inizio;

		_days.set(ndays, holiday);
	}
}

bool TLavanderie_calendar::is_holiday(const TDate& date) const
{
	if (_year == date.year())
	{
		const TDate inizio(1, 1, _year);
		long ndays = date - inizio;
		
		return _days[ndays];
	}
	return false;
}

int TLavanderie_calendar::read(int year)
{
	if (year != 0)
		_year = year;

	TConfig cfg(CONFIG_DITTA);
	const TString val = cfg.get("CAL", "lv", _year);
	
	if (val.full())
	{
		const int len = val.len();
		for (int i = 0; i < len; i++)
			_days.set(i, val[i] == 'X');
	}
	else
	{
		const TDate inizio(1, 1, _year);
		const TDate fine(31, 12, _year);
		TDate data(inizio);

		for (int i = 0;  data <= fine; ++data, i++)
			_days.set(i, data.is_holiday());
	}
  
  return NOERR;
}

int TLavanderie_calendar::write() const
{
	TString val(366);
	const TDate inizio(1, 1, _year);
	const TDate fine(31, 12, _year);
	TDate data(inizio);
  TConfig cfg(CONFIG_DITTA);

	for (int i = 0;  data <= fine; ++data, i++)
		val << (_days[i] ? 'X' : '-');
	cfg.set("CAL", val, "lv", true, _year);
	return NOERR;
}

int TLavanderie_calendar::remove() const
{
	TString val(366);
  TConfig cfg(CONFIG_DITTA);
	const TDate inizio(1, 1, _year);
	const TDate fine(31, 12, _year);
	TDate data(inizio);

	for (int i = 0;  data <= fine; ++data, i++)
		val << data.is_holiday() ? 'X' : '-';
	cfg.set("CAL", val, "lv", true, _year);
  return NOERR;
}

TLavanderie_calendar::TLavanderie_calendar(const int year) : _year(year)
{
	read();
}


///////////////////////////////////
////    TCausale_lavanderie    ////
///////////////////////////////////

TCausale_lavanderie::TCausale_lavanderie(const char * codice):
                    TRectype(cache().get("&CAU", codice)), _rit(caurit()), _cons(caucon())
{
}



                                 ////////////////////////
                                 ////    TDOC_KEY    ////
                                 ////////////////////////

//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
const char TDoc_key::provv()
{
  return get(0)[0];
}

//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti
const int TDoc_key::anno()
{
  return get_int(1);
}

//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
const char* TDoc_key::codnum()
{
  return get(2);
}

//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti
const long TDoc_key::ndoc()
{
  return get_int(3);
}

//metodi costruttori
TDoc_key::TDoc_key(const int anno, const TString& codnum, const long ndoc, const char provv)
{
  add(provv);
  add(anno);
  add(codnum);
  add(ndoc);
}

                                 /////////////////////////
                                 ////    TRDOC_KEY    ////
                                 /////////////////////////

//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
const char TRdoc_key::provv()
{
  return get(0)[0];
}

//ANNO: metodo che restituisce l'anno dalla TToken_string chiave dei documenti
const int TRdoc_key::anno()
{
  return get_int(1);
}

//CODNUM: metodo che restituisce il codnum dalla TToken_string chiave dei documenti
const char* TRdoc_key::codnum()
{
  return get(2);
}

//NDOC: metodo che restituisce il numero documento dalla TToken_string chiave dei documenti
const long TRdoc_key::ndoc()
{
  return get_int(3);
}

const int TRdoc_key::nriga()
{
  return get_int(4);
}

//metodi costruttori
TRdoc_key::TRdoc_key(const int anno, const TString& codnum, const long ndoc, const int nriga, const char provv)
{
  add(provv);
  add(anno);
  add(codnum);
  add(ndoc);
  add(nriga);
}

                                 /////////////////////////////////////////////////////
                                 ////    TBUONO_PRELIEVO & TBUONO_PRELIEVO_ROW    ////
                                 /////////////////////////////////////////////////////


//classe TBuono_prelievo

//CHIAVE: metodo che restituisce una TToken_string (da castare a TDoc_key) che contiene la chiave del documento
const TToken_string& TBuono_prelievo::chiave() const
{
  TToken_string& k = get_tmp_string();
  k.add(get(DOC_PROVV));
  k.add(get(DOC_ANNO));
  k.add(get(DOC_CODNUM));
  k.add(get(DOC_NDOC));
  return k;
}

//DATADOC: metodo che restituisce la data del documento
const TDate TBuono_prelievo::datadoc() const
{
  return get_date(DOC_DATADOC);
}

//CODCONT: metodo che restituisce il codice contratto
const long TBuono_prelievo::codcont() const
{
  return get_long(DOC_CODCONT);
}

//SET_DATAPRCO: metodo che setta la data di prevista consegna
void TBuono_prelievo::set_dataprco(const TDate& data)
{
  put("DATAPRCO", data);
}

//SET_ITINERARIO: metodo che setta il codice dell'itinerario
void TBuono_prelievo::set_itinerario(const int coditi)
{
  put("CODITI", coditi);
}

//SET_CONRTATTO: metodo che setta il codice contratto
void TBuono_prelievo::set_contratto(const int codcont)
{
  put("CODCONT", codcont);
}

//classe TBuono_prelievo_row

//EVASO: metodo che indica se la riga in questione ha il flag di evaso a true
const bool TBuono_prelievo_row::evaso() const
{
  return _rdoc.get_bool(RDOC_RIGAEVASA);
}

//CODART: metodo che restiuisce il codice articolo di quella riga
const TString& TBuono_prelievo_row::codart() const
{
  return _rdoc.get(RDOC_CODART);
}

//DESART: metodo che restituisce la descrizione dell'articolo
const TString& TBuono_prelievo_row::desart() const
{
  TString& str = get_tmp_string();
  str = _rdoc.get(RDOC_DESCR);
  
  if (_rdoc.get_bool(RDOC_DESCLUNGA))
    str << _rdoc.get(RDOC_DESCEST);

  return str;
}

//CAUSALE: metodo che restituisce il codice della causale della riga
const TString& TBuono_prelievo_row::causale() const
{
  return _rdoc.get(RDOC_CODAGG1);
}

//QTA_RITIRATA: metodo che restituisce la quantit<69> ritirata
const long TBuono_prelievo_row::qta_ritirata() const
{
  return _rdoc.get_long(RDOC_QTAGG1);
}

//QTA_DACONS: metodo che restituisce la quantit<69> da consegnare
const long TBuono_prelievo_row::qta_dacons() const
{
  return _rdoc.get_long(RDOC_QTA);
}

//QTA_CONSEGNATA: metodo che restituisce la quantit<69> effettivamente consegnata
const long TBuono_prelievo_row::qta_consegnata() const
{
  return _rdoc.get_long(RDOC_QTAEVASA);
}

//NUM_PACCHI: metodo che restituisce il numero dei pacchi consegnati
const int TBuono_prelievo_row::num_pacchi() const
{
  return _rdoc.get_int(RDOC_NCOLLI);
}

//PREZZO:metodo che restituisce il prezzo dell'articolo selezionato
const real TBuono_prelievo_row::prezzo() const
{
  return _rdoc.get_real(RDOC_PREZZO);
}

//CONG_PRE: metodo che restituisce il valore del conguaglio al momento dell'inizio delle operazioni
const long TBuono_prelievo_row::cong_pre() const
{
  return _rdoc.get_long("CONGPRE");
}

//CONG_ATT: metodo che restituisce il valore del conguaglio al termine dell'operazione attuale
const long TBuono_prelievo_row::cong_att() const
{
  return _rdoc.get_long("CONGATT");
}

//RIFBCON: metodo che restituisce i riferimenti al buono di consegna associato
const TToken_string& TBuono_prelievo_row::rifbcon() const
{
  TToken_string& kdoc = get_tmp_string();
  kdoc = _rdoc.get("RIFBCON");
  return kdoc;
}

//RIFBRIT: metodo che restituisce i riferimenti al buono di ritiro associato
const TToken_string& TBuono_prelievo_row::rifbrit() const
{
  TToken_string& kdoc = get_tmp_string();
  kdoc = _rdoc.get("RIFBRIT");
  return kdoc;
}

//DATAEVA: metodo che restituisce la data di evasione di que<75><65>a riga
const TDate& TBuono_prelievo_row::dataeva() const
{
  TDate& data = _rdoc.get_date("DATAEVA");
  if (!data.ok())
    data = NULLDATE;
  return data;
}

//SET_EVASO: metodo che setta il contenuto del flag evaso
void TBuono_prelievo_row::set_evaso(const bool evaso)
{
  _rdoc.put(RDOC_RIGAEVASA, evaso);
}

//SET_CODART: metodo che setta il codice articolo
void TBuono_prelievo_row::set_codart(const char* codart)
{
  _rdoc.put(RDOC_CODART, codart);
}

//SET_DESART: metodo che setta la descrizione
void TBuono_prelievo_row::set_desart(const TString& desart)
{
  if (desart.len() > 50)
  {
    _rdoc.put(RDOC_DESCR, desart.left(50));
    _rdoc.put(RDOC_DESCLUNGA, true);
    _rdoc.put(RDOC_DESCEST, desart.mid(50));
  }
  else
    _rdoc.put(RDOC_DESCR, desart);
}

//SET_CAUSALE: metodo che setta la causale sulla riga
void TBuono_prelievo_row::set_causale(const char* causale)
{
  _rdoc.put(RDOC_CODAGG1, causale);
}

//SET_QTA_RITIRATA: metodo che setta la quantit<69> ritirata sulla riga
void TBuono_prelievo_row::set_qta_ritirata(const long qta)
{
  _rdoc.put(RDOC_QTAGG1, qta);
}

//SET_QTA_DACONS: metodo che setta la quyantit<69> da consegnare
void TBuono_prelievo_row::set_qta_dacons(const long qta)
{
  _rdoc.put(RDOC_QTA, qta);
}

//SET_QTA_CONSEGNATA: metodo che setta la quantita consegnata
void TBuono_prelievo_row::set_qta_consegnata(const long qta)
{
  _rdoc.put(RDOC_QTAEVASA, qta);
}

//SET_NUM_PACCHI: metodo che setta il numero dei pacchi
void TBuono_prelievo_row::set_num_pacchi(const int numpacchi)
{
  _rdoc.put(RDOC_NCOLLI, numpacchi);
}

//SET_CODIVA: metodo che setta il codice IVA
void TBuono_prelievo_row::set_codiva(const char* codiva)
{
  _rdoc.put(RDOC_CODIVA, codiva);
}

//SET_UM: metodo che setta l'unit<69> di misura
void TBuono_prelievo_row::set_um(const char* um)
{
  _rdoc.put(RDOC_UMQTA, um);
}

//SET_PREZZO: metodo che setta il prezzo
void TBuono_prelievo_row::set_prezzo(const real prezzo)
{
  _rdoc.put(RDOC_PREZZO, prezzo);
}


//SET_MAG: metodo che setta il magazzino
void TBuono_prelievo_row::set_mag(const char* mag)
{
  _rdoc.put(RDOC_CODMAG, mag);
}

//SET_MAGC: metodo che setta il magazzino collegato
void TBuono_prelievo_row::set_magc(const char* magc)
{
  _rdoc.put(RDOC_CODMAG, magc);
}

//SET_CONG_PRE: metodo che setta il valore del conguaglio precedente
void TBuono_prelievo_row::set_cong_pre(const long qtacong)
{
  _rdoc.put("CONGPRE", qtacong);
}

//SET_CONG_ATT: metodo che setta il valore del conguaglio attuale
void TBuono_prelievo_row::set_cong_att(const long qtacong)
{
  _rdoc.put("CONGATT", qtacong);
}

//SET_RIFBCON: metodo che setta i riferimenti al buono di consegna associato
void TBuono_prelievo_row::set_rifbcon(const TToken_string& keybcon)
{
  TString str = keybcon;
  str.replace('|', ' ');
  _rdoc.put("RIFBCON", str);
}

//SET_RIFBRIT: metodo che setta i riferimenti al buono di ritiro associato
void TBuono_prelievo_row::set_rifbrit(const TToken_string& keybrit)
{
  TString str = keybrit;
  str.replace('|', ' ');
  _rdoc.put("RIFBRIT", str);
}

//SET_DATAEVA: metodo che setta la data di evasione di quella riga
void TBuono_prelievo_row::set_dataeva(const TDate& data)
{
  _rdoc.put("DATAEVA", data);
}

//ADD_QTA_CONSEGNATA: metodo che somma una quantita alla quantit<69> presente in una riga documento
void TBuono_prelievo_row::add_qta_consegnata(const long qta)
{
  _rdoc.add(RDOC_QTAEVASA, qta);
}

//ADD_PACCHI: metodo che aggiunge un certo numero di pacchi al numero presente sulla riga
void TBuono_prelievo_row::add_pacchi(const int nmr)
{
  _rdoc.add(RDOC_NCOLLI, nmr);
}


                                 ///////////////////////////
                                 ////    TRIGA_PACCO    ////
                                 ///////////////////////////

//READ: cerca una riga pacco in base alla chiave primaria
bool TRiga_pacco::read(const TString& codpacco, const long codriga)
{
  int err = _iskeynotfound;
  if (codpacco.full()) // Campo obbligatorio!
  {
    TLocalisamfile pacchi(LF_PACCHI);
    put(PACCHI_CODPACCO, codpacco);
    put(PACCHI_CODRIGA, codriga);

    err = TRectype::read(pacchi);    
  }
  
  if (err != NOERR)
    zero();

  return err == NOERR;
}

//CODPACCO: metodo che restituisce il codice univoco del pacco
const TString& TRiga_pacco::codpacco() const
{
  return get(PACCHI_CODPACCO);
}

//KEY: metodo che restiuisce la chiave univoca del record analizzato (per le lavanderie CODRIGA sempre 1)
const TToken_string& TRiga_pacco::key() const
{
  TToken_string& k = get_tmp_string();
  k.add(get(PACCHI_CODPACCO));
  k.add(get(PACCHI_CODRIGA));
  return k;
}

//ARTICOLO: metodo che restituisce il codice articolo specificato in questa riga
const TString& TRiga_pacco::articolo() const
{
  return get(PACCHI_CODART);
}

//QUANTITA: metodo che restituisce il numero dei pezzi nella confezione
const real TRiga_pacco::quantita() const
{
  return get_real(PACCHI_QTA);
}

//UM: metodo che restituisce l'unit<69> di misura
const TString& TRiga_pacco::um() const
{
  return get(PACCHI_UM);
}

//DATA: metodo che restituisce la data in cui il pacco <20> creato
const TDate TRiga_pacco::data() const
{
    return get_date(PACCHI_DATA);
}

//CLIENTE; metodo che restituisce il codice del cliente a cui <20> stato assegnato il pacco
const long TRiga_pacco::cliente() const
{
  return get_long(PACCHI_CODCF);
}

//DATA: metodo che restituisce la data in cui il pacco <20> stato assegnato a qualcuno
const TDate TRiga_pacco::databo() const
{
    return get_date(PACCHI_DATABO);
}

//ANNULLATO: metodo che ritorna true se il pacco <20> stato annullato
const bool TRiga_pacco::annullato() const
{
  return get_bool(PACCHI_ANNULLATO);
}

//RIGABOLLA: metodo che restituisce una TToken_string contenete alla riga del documento che ha consegnato il pacco
const TToken_string& TRiga_pacco::rigabolla() const
{
  TToken_string& bolla = get_tmp_string();
  bolla.add(get_char(PACCHI_PROVV));
  bolla.add(get_int(PACCHI_ANNO));
  bolla.add(get(PACCHI_CODNUM));
  bolla.add(get_int(PACCHI_NDOC));
  bolla.add(get_int(PACCHI_IDRIGA));

  return bolla;
}

//MOVMAG: metodo che restituisce i riferimenti al movimento di magazzino generato dal pacco
const long TRiga_pacco::movmag() const
{
  return get_long(PACCHI_MGNUMREG);
}

//SET_KEY: metodo che setta la chiave (da usare su un TRiga_pacco vuota)
void TRiga_pacco::set_key(const char* codpacco, const int codriga)
{
  put(PACCHI_CODPACCO, codpacco);
  put(PACCHI_CODRIGA, codriga);
}

//SET_ARTICOLO: metodo che setta il codice articolo sul record corrente
void TRiga_pacco::set_articolo(const char* codart)
{
  put(PACCHI_CODART, codart); 
}

//SET_QUANTITA: metodo che setta la quantita sul record corrente
void TRiga_pacco::set_quantita(const real qta)
{
  put(PACCHI_QTA, qta);
}

//SET_UM: metodo che setta l'unit<69> di misura
void TRiga_pacco::set_um(const char* um)
{
  put(PACCHI_UM, um);
}

//SET_DATA: metodo che setta la data di creazione del record corrente
void TRiga_pacco::set_data(const TDate& data)
{
  put(PACCHI_DATA, data);
}

//SET_CLIENTE: metodo che setta il codice cliente sul record corrente
void TRiga_pacco::set_cliente(const long codcf)
{
  put(PACCHI_CODCF, codcf);
}

//SET_DATA: metodo che setta la data di evasione sul record corrente
void TRiga_pacco::set_databo(const TDate& data)
{
  put(PACCHI_DATABO, data);
}

//SET_ANNULLATO: metodo che setta il flag di annullato
void TRiga_pacco::set_annullato(const bool ann)
{
  put(PACCHI_ANNULLATO, ann);
}
  
//SET_RIGABOLLA: metodo che setta i riferimenti alla riga di bolla che evade il pacco sul record corrente
void TRiga_pacco::set_rigabolla(const int anno, const char* codnum, const long ndoc, const long idriga)
{
  put(PACCHI_PROVV, 'D');
  put(PACCHI_ANNO, anno);
  put(PACCHI_CODNUM, codnum);
  put(PACCHI_NDOC, ndoc);
  put(PACCHI_IDRIGA, idriga);
}

//SET_MOVMAG: metodo che setta il movimento di magazzino generato dal pacco
void TRiga_pacco::set_movmag(const long movmag)
{
  put(PACCHI_MGNUMREG, movmag);
}

//IS_ANNULATO: metodo che restituisce "true" se il campo annullato sul record attuale <20> 'S'
bool TRiga_pacco::is_annullato()
{
  return get_bool(PACCHI_ANNULLATO);
}

//IS_ASSOCIATO: metodo che restitusce "true" se il campo cliente <20> valorizzato
bool TRiga_pacco::is_associato()
{
  return get_int(PACCHI_CODCF) && 1;
}
//Metodi costruttori
TRiga_pacco::TRiga_pacco(const TRectype& rec)
           : TRectype(rec)
{
}

TRiga_pacco::TRiga_pacco(const TRiga_pacco& rpacco)
           : TRectype(rpacco)
{
}

TRiga_pacco::TRiga_pacco(const char* codpacco, const long codriga)
           : TRectype(LF_PACCHI)
{
  read(codpacco, codriga);
}

TRiga_pacco::TRiga_pacco()
           : TRectype(LF_PACCHI)
{
  zero();
}


                            ////////////////////////////////////
                            ////    CLASSE TGIAC_PER_CLI    ////
                            ////////////////////////////////////

//GIACART_OD: metodo che restituisce un puntatore al real che contiene il valore
//della dotazione odierna per un determinato articolo
real& TGiac_per_cli::giacart_od(const TString& codart)
{
  real *giac = (real*)_odierna.objptr(codart);
  if (giac == NULL)
  {
    giac = new real(giac_in_mag(codart, true));
    _odierna.add(codart,giac);
  }
  return *giac;
};

//GIACART_TMP: metodo che restituisce un puntatore al real che contiene il valore
//della dotazione temporanea per un determinato articolo
real& TGiac_per_cli::giacart_tmp(const TString& codart)
{
  real *giac = (real*)_temporanea.objptr(codart);
  if (giac == NULL)
  {
    giac = new real(giac_in_mag(codart, false));
    _temporanea.add(codart,giac);
  }
  return *giac;
};

//GIAC_IN_MAG: questo metodo restituisce le quantit<69> presenti sul file 166 (clifogiac)
//restituendo il valore salvato in dotazione odierna se odierna == true,
//oppure il valore salvato in dotazione temporanea se odierna = false
long TGiac_per_cli::giac_in_mag(const TString& codart, bool odierna) const
{
  //recupero i valori delle dotazioni odierne e temporanee dal magazzino del cliente
  TLocalisamfile magcli(LF_CLIFOGIAC);
  magcli.put(CLIFOGIAC_ANNOES,  _year);
  magcli.put(CLIFOGIAC_TIPOCF,  'C');
  magcli.put(CLIFOGIAC_CODCF,   _clifo);
  magcli.put(CLIFOGIAC_INDSPED, _indsped);
  magcli.put(CLIFOGIAC_CODART,  codart);
  magcli.put(CLIFOGIAC_NRIGA,  1);

  //leggo il record corrispondente
  if (magcli.read() == NOERR)
      return magcli.get_long( odierna ? CLIFOGIAC_DOTOD : CLIFOGIAC_DOTTM);
  else
  {
    magcli.put(CLIFOGIAC_ANNOES,  _year);
    magcli.put(CLIFOGIAC_TIPOCF,  'C');
    magcli.put(CLIFOGIAC_CODCF,   _clifo);
    magcli.put(CLIFOGIAC_INDSPED, 0);
    magcli.put(CLIFOGIAC_CODART,  codart);
    magcli.put(CLIFOGIAC_NRIGA,  1);

    //leggo il record corrispondente
    if (magcli.read() == NOERR)
      return magcli.get_long( odierna ? CLIFOGIAC_DOTOD : CLIFOGIAC_DOTTM);
  }
  return 0;
}

//PRESET: metodo che carica la coppia cliente - contratto
bool TGiac_per_cli::preset(const TDocumento& doc)
{
  //estraggo i dati di interesse dal documento
  _clifo = doc.get_long(DOC_CODCF);
  _cont = doc.get_long(DOC_CODCONT);
  _year = doc.get_date(DOC_DATADOC).year();
  _indsped = doc.get_long(DOC_CODINDSP);

  return true;
}

//RESET: metodo che distrugge i due TAssoc_array e carica la coppia cliente - contratto
bool TGiac_per_cli::reset(const TDocumento& doc)
{
  preset(doc);

  //distruggo i due TAssoc_array
  _odierna.destroy();
  _temporanea.destroy();

  return true;
}

//LOAD_ROW: questo metodo popola e aggiorna i TAssoc_array
bool TGiac_per_cli::load_row(const TRiga_documento& rdoc)
{
  //recupero il documento e la sua maschera a partire dalla riga documento
  const TDocumento& doc = rdoc.doc();
	real vardot;
	real vartmp;
  
  //se sul documento leggo o il cliente o il contratto o l'indirizzo di spedizione 
  //diversi da quelli che avevo salvato vuol dire che ho cambiato uno dei due, 
  //e quindi le giacenze non vanno pi<70> bene; in tal caso resetto i TAssoc_array e riparto
  if (doc.get_long(DOC_CODCF) != _clifo || doc.get_long(DOC_CODCONT) != _cont || doc.get_long(DOC_CODINDSP) != _indsped)
    reset(doc);
    
  real& dotazione = giacart_od(rdoc.get(RDOC_CODART));
  real& dotmp = giacart_tmp(rdoc.get(RDOC_CODART));

	//instanzio una cache sulla tabella delle causali
  const TString4 causale = rdoc.get(RDOC_CODAGG1);
  const TCausale_lavanderie cau(causale);
  
  //movimento o meno la dotazione temporanea a seconda di cosa prevede la causale
  if (cau.is_ritiro())
  {
    const TCausale_magazzino& rit = cau.causale_ritiro();
		const real & ritirato = rdoc.get_real(RDOC_QTAGG1);
		int st = rit.sgn(s_dottm);
		int so = rit.sgn(s_dotod);
		
		vartmp += real(st) * ritirato;
		vardot += real(so) * ritirato;
	}
  if (cau.is_consegna())
  {
    const TCausale_magazzino& con = cau.causale_consegna();
		const real & consegnato = rdoc.get_real(RDOC_QTA);
		int st = con.sgn(s_dottm);
		int so = con.sgn(s_dotod);
		
		vartmp += real(st) * consegnato;
		vardot += real(so) * consegnato;
	}

  if (rdoc.get_int(RDOC_MOVMAG) != ZERO)
  {
    dotmp -= vartmp; 
    dotazione -= vardot;
  }
  return true;
}

//GIAC_ATT: questo metodo restituisce il valore della dotazione da scrivere a video in base ai valori
//di consegnato e ritirato; ATTENZIONE: restituisce la dotazione odierna se odierna = true,
//restituisce la dotazione temporanea se odierna = false
real TGiac_per_cli::giac_att(TRiga_documento& rdoc, bool odierna)
{
  const TString& codart = rdoc.get(RDOC_CODART);

  real giac = odierna ? giacart_od(codart) : giacart_tmp(codart);
  real saldo;
  
	//instanzio una cache sulla tabella delle causali
  TString4 causale = rdoc.get(RDOC_CODAGG1);
  const TCausale_lavanderie cau(causale);
  
  //movimento o meno la dotazione temporanea/odierna a seconda di cosa prevede la causale
  if (cau.is_ritiro())
  {
    const TCausale_magazzino& rit = cau.causale_ritiro();
		const int s = rit.sgn(odierna ? s_dotod : s_dottm);

		saldo += real(s) * rdoc.get_real(RDOC_QTAGG1);
	}
  if (cau.is_consegna())
  {
    const TCausale_magazzino& con = cau.causale_consegna();
		const int s = con.sgn(odierna ? s_dotod : s_dottm);

    saldo += real(s) * rdoc.get_real(RDOC_QTA);
	}
  giac += saldo;

  return giac;
}

//costruttore
TGiac_per_cli::TGiac_per_cli()
{
  //estraggo i dati di interesse dal documento
  _clifo = 0;
  _cont = 0;
  _year = 0;
  _indsped = 0;
}