campo-sirio/lv/lvlib.cpp

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

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

#include <applicat.h>
#include <config.h>
#include <modaut.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';
}

HIDDEN short __lv_02_active = 0x3;
HIDDEN TFilename __lv_backup_path;

bool lv_is_02_active()
{
	if (__lv_02_active == 0x3)
	{
		__lv_02_active = main_app().has_module(L2AUT);

		if (__lv_02_active)
		{
			__lv_backup_path = ini_get_string(CONFIG_DITTA, "lv", "Backup");
			__lv_02_active = __lv_backup_path.full();
			if (__lv_02_active)
			{
				TFilename dir(__lv_backup_path);

				dir.add("com");
				dir.add("dir.gen");
				__lv_02_active = dir.exist() && dir.find(' ') < 0;
			}
		}
	}
	return __lv_02_active != 0;
}

const TFilename & lv_backup_path()
{
	lv_is_02_active(); // serve per inizializzare il valore
	return __lv_backup_path;
}
//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
///////////////////////////////////////////////////////////

int TRecmag_lavanderie::read(TBaseisamfile& f, word op, word lockop)
{
	_update_time = 0L;
	return TVariable_rectype::read(f, op, lockop);
}
int TRecmag_lavanderie::readat(TBaseisamfile& f, TRecnotype nrec, word lockop)
{
	_update_time = 0L;
	return TVariable_rectype::readat(f, nrec, lockop);
}

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"; */
	query="USE MOVMAG KEY 5\n";
  query << "FROM  TIPOCF='C'"
				<< " CODCF=" << codcf
				<< " CODINDSP=" << indsped
				<< " DATACOMP=" << imese.string()	<< "\n";
  query << "TO TIPOCF='C'"
				<< " CODCF=" << codcf
				<< " CODINDSP=" << indsped
			  << " DATACOMP="	<< oggi.string() << "\n";

  TISAM_recordset recmag(query);
	TString8 codcausmov;
	
	_consmese = ZERO;
  for (bool ok = recmag.move_first(); ok; ok = recmag.move_next())
  {
    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";
    
		codcausmov = recmag.get(MOVMAG_CODCAUS).as_string();
    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 : codcausmov);
      int sgn_consmese = tcaus.sgn(s_consmese);
      
			if (sgn_consmese != 0)
			{
				const real qta = ((TArticolo &)artrec).convert_to_um(recrmag.get(RMOVMAG_QUANT).as_real(), NULL, recrmag.get(RMOVMAG_UM).as_string());

				_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_tipocf(char tipocf)
{ 
	if (_tipocf != tipocf)
	{
		_tipocf = tipocf;
		remove_body(LF_CLIFOGIAC);
	}
}

void TArticolo_lavanderie::set_codcf(long codcf)
{ 
	if (_codcf != codcf)
	{
		_codcf = codcf;
		remove_body(LF_CLIFOGIAC);
	}
}

void TArticolo_lavanderie::set_indsped(int indsped)
{
	if (_indsped != indsped)
	{
		_indsped = indsped;
		remove_body(LF_CLIFOGIAC);
	}
}

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
{
	const int es = annoes > 0 ? annoes : esercizi().last_mag();
	const int esprec = esercizi().pred(annoes);
	
	if (esprec != 0)
	{
		const bool closed = esercizi()[esprec].chiusura_mag().ok();

		if (!closed)
		{
			((TArticolo_lavanderie*)this)->set_anno_lav(esprec);
			TRecord_array recarrprec = body(LF_CLIFOGIAC);

			((TArticolo_lavanderie*)this)->set_anno_lav(es);
			TRecord_array & recarr = body(LF_CLIFOGIAC);

			for (int r = 1; r <= recarr.rows(); r++)
			{
				TRecmag_lavanderie & rec = (TRecmag_lavanderie &) recarr[r];
				int r1;

				for (r1 = 1; r <= recarrprec.rows(); r++)
					if (rec.get(CLIFOGIAC_INDSPED) == recarrprec[r1].get(CLIFOGIAC_INDSPED) &&
							rec.get(CLIFOGIAC_CODART) == recarrprec[r1].get(CLIFOGIAC_CODART) &&
							rec.get(CLIFOGIAC_LIVELLO) == recarrprec[r1].get(CLIFOGIAC_LIVELLO))
							break;
				if (r1 <= recarrprec.rows())
				{
					TRecmag_lavanderie & rec = (TRecmag_lavanderie &) recarr[r];
					TRecmag_lavanderie & old = (TRecmag_lavanderie &) recarrprec[r1];
					::update_clifogiac(rec, old);
					recarrprec.destroy_row(r1, true);
				}
			}
			for (int rp = 1; rp <= recarrprec.rows(); rp++)
			{
				TRecmag_lavanderie & old = (TRecmag_lavanderie &) recarrprec[rp];
				const int r = recarr.add_row(old);
				TRecmag_lavanderie & rec = (TRecmag_lavanderie &) recarr[r];

				rec.put(CLIFOGIAC_ANNOES, annoes);
				::reset_clifogiac(rec, old, true);
			}
			return recarr;
		}
	}
	((TArticolo_lavanderie*)this)->set_anno_lav(es);
	TRecord_array & recarr = body(LF_CLIFOGIAC);

	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))
{
}


TCausale_lavanderie::TCausale_lavanderie(const TRectype &r):
                     TRectype(r)
{
  CHECK(r.num() == LF_TABMOD, "Tipo record errato sulla causale di magazzino");
}            

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


public:
	TCausale_lavanderie & caus(const char* key);

	TCache_causali_lavanderie();
  virtual ~TCache_causali_lavanderie() { }
};


TCache_causali_lavanderie::TCache_causali_lavanderie()
							: TRecord_cache("LVCAU", 1)
{ 
  test_file_changes();   // Tieni d'occhio le modifiche sul file
  set_items_limit(83);   // Numero primo
}        

TCausale_lavanderie & TCache_causali_lavanderie::caus(const char* key)
{
	TString16 k;

	k << "LV||CAU|" << key;
	return (TCausale_lavanderie &)query(k);
}

TCausale_lavanderie & cached_causale_lavanderie(const char * codcaus)
{
	HIDDEN TCache_causali_lavanderie __cache_causali_lavanderie;

	return __cache_causali_lavanderie.caus(codcaus);
}


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

//SET_PROVV: metodo che setta il campo provv
void TDoc_key::set_provv(const char provv)
{
  add(provv, 0);
}

//SET_ANNO: metodo che setta il campo anno
void TDoc_key::set_anno(const int anno)
{
  add(anno, 1);
}

//SET_CODNUM: metodo che setta il campo codnum
void TDoc_key::set_codnum(const char* codnum)
{
  add(codnum, 2);
}

//SET_NDOC: metodo che setta il campo ndoc
void TDoc_key::set_ndoc(const long ndoc)
{
  add(ndoc, 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 real TBuono_prelievo_row::qta_ritirata() const
{
  return _rdoc.get_real(RDOC_QTAGG1);
}

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

//QTA_CONSEGNATA: metodo che restituisce la quantit<69> effettivamente consegnata
const real TBuono_prelievo_row::qta_consegnata() const
{
  return _rdoc.get_real(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 real 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 real qta)
{
  _rdoc.put(RDOC_QTA, qta);
}

//SET_QTA_CONSEGNATA: metodo che setta la quantita consegnata
void TBuono_prelievo_row::set_qta_consegnata(const real 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 real qtacong)
{
  _rdoc.put("CONGPRE", qtacong);
}

//SET_CONG_ATT: metodo che setta il valore del conguaglio attuale
void TBuono_prelievo_row::set_cong_att(const real 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 real 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
{
  if(get(PACCHI_ANNULLATO)[0] == 'S')
    return true;
  return false;
}

//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)
{
  const char annullato = ann ? 'S' : 'N';
  put(PACCHI_ANNULLATO, annullato);
}
  
//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()
{  
  if(get(PACCHI_ANNULLATO)[0] == 'S')
    return true;
  return false;
}

//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(TRiga_documento& rdoc, const bool aggiorna, const bool reading)
{
  //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_long(RDOC_MOVMAG) != 0L && !reading)
  {
    dotmp -= vartmp; 
    dotazione -= vardot;
  }

  /*if(aggiorna)
  {
    rdoc.put("DOTOD", dotazione);
    rdoc.put("DOTMP", dotmp);
  }*/
  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);
  const TDocumento& doc = rdoc.doc();

  TArticolo_lavanderie& artrec = cached_article_laundry(codart, 'C', doc.get_long(DOC_CODCF), doc.get_long(DOC_CODINDSP));	
  //fisso l'anno esercizio
  TEsercizi_contabili& esc = esercizi();
  const int last_esc = esc.last();

  //estraggo il record corrispondente su LF_CLIFOGIAC	
  const TRecmag_lavanderie& reclav = artrec.find_rec(last_esc);     

  real dotod = reclav.get_real(CLIFOGIAC_DOTOD);      
  real dotmp = reclav.get_real(CLIFOGIAC_DOTTM);

  real giac = odierna ? dotod : dotmp;
  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;
}
bool TLV_report::get_usr_val(const TString& name, TVariant& var) const
{
  if (name == "#NEXTCONS")
  {
    TRecordset& recset = *recordset();
    const long clifo = recset.get("CODCF").as_int();
    const long contr = recset.get("CODCONT").as_int();
    const TDate dtcons = recset.get("DTCONS").as_date();
    if (clifo > 0 && contr > 0 && dtcons.ok())
    {
      // Scrivere qui il calcolo della prossima data di consegna ...
      // ... al momento non sono capace di farlo!
      TDate next_dtcons = dtcons;
      next_dtcons += 7;
      var = next_dtcons;
      return true;
    }
  }
  return TDocument_report::get_usr_val(name, var);
}

TCursor* TLV_recordset::cursor() const
{
	bool to_create = !valid_cursor();
	TCursor * c = TISAM_recordset::cursor();
	
	if (to_create && c != NULL && relation()->log2ind(LF_CLIFOGIAC) >= 0)
	{
		TLocalisamfile & clifogiac = relation()->lfile(LF_CLIFOGIAC);

		clifogiac.set_curr(new TRecmag_lavanderie);
	}
	return c;
}

bool TLV_report::set_recordset(const TString& sql)
{
	if (sql.starts_with("US", true))
	{
	  TLV_recordset* rex = new TLV_recordset(sql);

		TReport::set_recordset(rex);
		return rex != NULL;
	}
	return TDocument_report::set_recordset(sql);
}

                                          ///////////////////////////////
                                          ////    TDOC_INVENTARIO    ////
                                          ///////////////////////////////

//CHIAVE: metodo che restituisce la chiave del documento
const TToken_string& TDoc_inventario::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 restiruisce la data documento
const TDate TDoc_inventario::datadoc() const
{
  return get_date(DOC_DATADOC);
}

//FIND_OR_CREATE_ROW: metodo che cerca una riga con un certo codart e se non esiste la crea
TDoc_inventario_row TDoc_inventario::find_or_create_row(const char* codart)
{
  //scorro tutte le righe documento; se ne trovo una con quel codart
  //allora la restituisco
  for(int i = 1; i <= rows(); i++)
  {
    TRiga_documento& row = (*(TDocumento*)this)[i];
    const TString& cod = row.get(RDOC_CODART);

    if(cod == codart)
    {
      TDoc_inventario_row rinv(row);
      return rinv;
    }
  }

  //se sono arrivato qui non ho trovato neanche una riga con quel codart;
  //in queto caso ne aggiungo una
  TRiga_documento& row = (*(TDocumento*)this).new_row("21");
  TDoc_inventario_row rinv(row);
  return rinv;
}

void TDoc_inventario::set_difinv(const bool difinv)
{
  put("DIFFINV", difinv);
}

                                          ///////////////////////////////////
                                          ////    TDOC_INVENTARIO_ROW    ////
                                          ///////////////////////////////////

//CODART: metodo che restituisce il codice articolo della riga documento
const TString& TDoc_inventario_row::codart() const
{
  return _rinv.get(RDOC_CODART);
}

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

  return str;
}

//QTA: metodo che restiruisce la quantit<69> salvata sulla riga
const real TDoc_inventario_row::qta() const
{
  return _rinv.get_real(RDOC_QTA);
}

//UM: metodo che restiruisce l'unit<69> di misura utilizzata sulla riga documento
const TString& TDoc_inventario_row::um() const
{
  return _rinv.get(RDOC_UMQTA);
}

//NUM_PACCHI: metodo che resituisce il numero dei pacchi presenti per quell'articolo
const int TDoc_inventario_row::num_pacchi() const
{
  return _rinv.get_int(RDOC_NCOLLI);
}

//COD_PACCHI: metodo che restiuisce l'elenco dei pacchi salvati su quella riga
const TToken_string& TDoc_inventario_row::cod_pacchi() const
{
  TToken_string& tmp = get_tmp_string();
  tmp = _rinv.get("CODPACCHI");

  return tmp;
}

//MAGAZZINO: metodo che restituisce il codice del magazzino/deposito
const TString& TDoc_inventario_row::magazzino() const
{
  return _rinv.get(RDOC_CODMAG);
}

//MAGAZZINOC: metodo che restituisce il codice del magazzino/deposito collegato
const TString& TDoc_inventario_row::magazzinoc() const
{
  return _rinv.get(RDOC_CODMAGC);
}

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

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

//SET_QTA_RITIRATA: metodo che setta la quantit<69> ritirata sulla riga
void TDoc_inventario_row::set_qta(const real qta)
{
  _rinv.put(RDOC_QTA, qta);
}

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

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

//SET_COD_PACCHI: metodo che setta l'elenco dei pacchi salvati su quella riga
void TDoc_inventario_row::set_cod_pacchi(const char* codpacchi)
{
  _rinv.put("CODPACCHI", codpacchi);
}

//SET_MAGAZZINO: metodo che setta il codice del magazzino/deposito
void TDoc_inventario_row::set_magazzino(const char* mag)
{
  _rinv.put(RDOC_CODMAG, mag);
}

//SET_MAGAZZINOC: metodo che setta il codice del magazzino/deposito collegato
void TDoc_inventario_row::set_magazzinoc(const char* magc)
{
  _rinv.put(RDOC_CODMAGC, magc);
}