campo-sirio/src/tf/tf0100.cpp

#include "tf0.h"
// Le definizioni sono qua
#include "tf0100b.h"

#include <dongle.h>		// dongle()
#include <odbcrset.h>	// Oracle Recset


#include <mov.h>
#include <rmoviva.h>
#include <anagiu.h>
#include <comuni.h>
#include <cfven.h>
#include <nditte.h>
#include <unloc.h>
#include <causali.h>



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

// Le funzioni quelle belle 
TString getTipoDoc(int id)
{
	TString ret;
	switch(id)
	{
	case B_TIPO_AUTOFATT:
		ret = "AF";
		break;
	case B_TIPO_FATTACQ:
		ret = "FA";
		break;
	case B_TIPO_FATTFISC:
		ret = "FF";
		break;

	case B_TIPO_FATTVEN:
		ret = "FV";
		break;
	case B_TIPO_NOTC:
		ret = "NC";
		break;
	case B_TIPO_NOTD:
		ret = "ND";
		break;
	case B_TIPO_STORDOC:
		ret = "ST";
		break;
	/*
	case B_TIPO_BOLLADOG:
		ret = "BD";
		break;
	case B_TIPO_CORRNINC:
		ret = "CN";
		break;
	case B_TIPO_CORR:
		ret = "CR";
		break;
	case B_TIPO_FATTSC:
		ret = "FS";
		break;
	case B_TIPO_RICFIS:
		ret = "RF";
		break;

	case B_TIPO_RICFISNI:
		ret = "RN";
		break;
	case B_TIPO_SCONT:
		ret = "SC";
		break;
	case B_TIPO_SCONTNI:
		ret = "SN";
		break;
	*/
	default:
		ret = "ERR";
		break;
	}
	return ret;
}

int	getTipoDoc(TString id)
{
	int ret = -1;
			 if(id == "AF")	ret = B_TIPO_AUTOFATT;
	// else if(id == "BD")	ret = B_TIPO_BOLLADOG;
	// else if(id == "CN")	ret = B_TIPO_CORRNINC;
	// else if(id == "CR")	ret = B_TIPO_CORR;
	else if(id == "FA")	ret = B_TIPO_FATTACQ;
	else if(id == "FF")	ret = B_TIPO_FATTFISC;
	// else if(id == "FS")	ret = B_TIPO_FATTSC;
	else if(id == "FV")	ret = B_TIPO_FATTVEN;
	else if(id == "NC")	ret = B_TIPO_NOTC;
	else if(id == "ND")	ret = B_TIPO_NOTD;
	// else if(id == "RF")	ret = B_TIPO_RICFIS;
	// else if(id == "RN")	ret = B_TIPO_RICFISNI;
	// else if(id == "SC")	ret = B_TIPO_SCONT;
	// else if(id == "SN")	ret = B_TIPO_SCONTNI;
	else if(id == "ST")	ret = B_TIPO_STORDOC;
	return ret;
}

TRectype getTrasFatt(TString reg, TString codiva)
{
	TString key = reg; key << "|" << codiva;
	return cache().get(LF_TRASFATT, key);
}

TRectype getCli(TString tipocf, TString codcf)
{
	if(tipocf != "O")
	{
		TString key = tipocf; key << "|" << codcf;
		return cache().get(LF_CLIFO, key);
	}
	// Cliente occasionale!
	else
	{
		TRectype cli(LF_CLIFO);
		TRectype occas = cache().get(LF_OCCAS, codcf);
		cli.put("RAGSOC" , occas.get("RAGSOC"));
		cli.put("CODRFSO" , "");
		cli.put("PAIV" , occas.get("PAIV"));
		cli.put("COFI" , occas.get("COFI"));
		return cli;
	}
}

// Cerca una stringa all'interno di una SLIST (Potrebbe diventare una funzione di XVT.h)
static SLIST_ELT xvt_slist_find_str(SLIST list, const char* str)
{
  SLIST_ELT e = NULL;
  for (e = xvt_slist_get_first(list); e; e = xvt_slist_get_next(list, e))
  {
    const char* val = xvt_slist_get(list, e, NULL);
    if (xvt_str_compare_ignoring_case(str, val) == 0)
      break;
  }
  return e;
}

// Controlla se l'azienda ha un RFSO
static bool haveRFSO(TString& codrfso)
{
	codrfso = cache().get(LF_NDITTE, prefix().firm().codice(), "CODRFSO");
	if(codrfso == "") return false;
	return true;
}

/* Ritorno il tipo di documento
 * TD01: Fattura
 * TD04: Nota di credito
 * TD05: Nota di debito
 * NO-> TD07: Fattura semplificata
 * NO-> TD08: NC semplificata
 * TD10: Fatt di acquisto intra beni
 * TD11: Fatt di acquisto intra servizi
 */
static const char* decodTipo(TToken_string* strarr)
{
	TRectype mov = cache().get(LF_MOV, strarr->get(_numero));
	TCausale caus(mov.get("CODCAUS"), mov.get_int("ANNOIVA"));
	TString tipodoc; tipodoc << strarr->get(_codnum);
	// Le autofatture possono essere solo di tipo TDO1
	if(tipodoc == "AF")
		return "TD01";
	else if(tipodoc == "FA" || tipodoc == "FV")
	{
		// Potrebbe essere normale o intra
		if(!caus.intra())
			return "TD01";
		else
		{
			// Controlliamo se <20> di beni o servizi
			// Per capire se sono beni o servizi devo prendere il movimento, e trovare quale dei due ha un importo pi<70> alto
			TAssoc_array intraval;
			TRelation r_moviva(LF_RMOVIVA);
			TRectype filter(r_moviva.curr()); filter.put("NUMREG", strarr->get(_numero));
			TCursor c_moviva(&r_moviva, "", 1, &filter, &filter);
			for(c_moviva = 0; c_moviva.pos() < c_moviva.items(); ++c_moviva)
			{
				TRectype row = c_moviva.curr();
				real importo = row.get_real("IMPONIBILE");
				// La chiave deve essere formata da CODIVA, GRUPPO + CONTO + SOTTOCONTO
				TString keyAssoc; keyAssoc << row.get("CODIVA") << "|" << row.get("GRUPPO") << "|" << row.get("CONTO") << "|" << row.get("SOTTOCONTO");
				if(intraval.is_key(keyAssoc))
				{
					importo += *(real*)intraval.objptr(keyAssoc);
					intraval.add(keyAssoc, importo, true);
				}
				else
				{
					intraval.add(keyAssoc, importo);
				}
			}

			// Adesso che ho tutti i totali divisi per CODIVA e GCS vado a pescare il valore maggiore
			TString keyMax = "";
			real max = ZERO;
			TString_array keys;
			intraval.get_keys(keys);
			for(int i = 0; i < keys.items(); i++)
			{
				TString key = *(TString*)keys.objptr(i);
				real valItem = *(real*)intraval.objptr(key);
				if(valItem > max)
				{
					keyMax = key;
					max = valItem;
				}
			}
			
			// Una volta che ho trovato il nostro vincitore vado a prendere il tipo di fattura dal GCS
			TString keyPCon = keyMax.ssub(keyMax.find('|') + 1);
			if(cache().get(LF_PCON, keyPCon, "RICSER") == "1")
				return "TD11";
			else
				return "TD10";
		}
	}
	else if(tipodoc == "NC")
		return "TD04";
	else if(tipodoc == "ND")
		return "TD05";
	else 
		return tipodoc;
}

/* Salvo il record modificato in TFCustom */
bool saveRec(TToken_string row, bool esportato)
{
	// Devo inserire la riga in trasfatt
		TRectype rCust(LF_TRASFATT);
		if(strcmp(row.get(_spedita), "X") == 0)	// Controllo che non sia gi<67> stata spedita prima
		{
			TString key = row.get(_numero); key << "|"<< row.get(_aliquota);
			rCust = cache().get(LF_TRASFATT, key);
		}
		else
		{
			rCust.put("NUMREG",			row.get(_numero));
		}
		rCust.put("TIPO",				row.get(_tipocf));
		rCust.put("CODCF",			row.get(_codcf));
		rCust.put("OCCAS",			row.get(_occas));
		rCust.put("TIPODOC",		row.get(_codnum));
		rCust.put("NUMDOC",			row.get(_numdoc));
		rCust.put("DATAREG",		row.get(_datareg));
		rCust.put("DATADOC",		row.get(_datadoc));
		rCust.put("IMPONIBILE",	row.get(_imponibile));
		rCust.put("IMPOSTA",		row.get(_importoIVA));
		rCust.put("CODIVA",			row.get(_aliquota));
		rCust.put("AUTOFATT",		row.get(_autofatt));
		if(esportato)
		{
			rCust.put("TFINVIO",	true);
			rCust.put("TFDATA",		TDate(TODAY));
		}

		return rCust.write_rewrite(TLocalisamfile(LF_TRASFATT)) == NOERR;
}

/////////////////////////////////////////////////////////////////////////////////////
// TTrFa_record
/////////////////////////////////////////////////////////////////////////////////////

// Imposta il valore di un campo variant
void TTrFa_record::set(const char* fld, const TVariant& var)
{
  CHECK(fld && *fld, "Null field name");

  if (var.is_null())
  {
    _fields.remove(fld);
  }
  else
  {
    TVariant* obj = (TVariant*)_fields.objptr(fld);
    if (obj != NULL)
      *obj = var;
    else
      _fields.add(fld, new TVariant(var));
  }
}

// Imposta il valore di un campo intero
void TTrFa_record::set(const char* fld, long val)
{
  const TVariant var(val);
  set(fld, var);
}

// Imposta il valore di un campo stringa
void TTrFa_record::set(const char* fld, const char* val)
{
  if (val == NULL)
    set(fld, NULL_VARIANT);
  else
  {
    const TVariant var(val);
    set(fld, var);
  }
}

// Imposta il valore di un campo stringa
void TTrFa_record::set(const char* fld, const TString& val)
{
  const TVariant var(val);
  set(fld, var);
}

// Imposta il valore di un campo numerico
void TTrFa_record::set(const char* fld, const real& val)
{
  const TVariant var(val);
  set(fld, var);
}

// Imposta il valore di un campo data in formato ISO
void TTrFa_record::set(const char* fld, const TDate& val)
{
  if (val.ok())
  {
    const TVariant var(val);
    set(fld, var);
  }
  else
    set(fld, "");
}

// Imposta il valore di un campo booleano
void TTrFa_record::set(const char* fld, bool var)
{
  set(fld, var ? "SI" : "NO");
}

// Legge il valore di un campo variant
const TVariant& TTrFa_record::get(const char* fld) const
{
  const TVariant* var = (const TVariant*)_fields.objptr(fld);
  return var ? *var : NULL_VARIANT;
}

// Converte un variant in una stringa valida per SQLite
const TString& TTrFa_record::var2str(const TString& fldname, const TVariant& var) const
{
  const TFieldtypes vt = var.type();
  if (vt == _realfld)
  {
    const TCurrency v(var.as_real(), "", ZERO, fldname.find("IMPONIBILE")>0 || fldname.find("IMPOSTA")>0);
    TString& tmp = get_tmp_string();
    tmp << '\'' << v.string() << '\''; 
		tmp.replace(',','.');
	return tmp;
  }
  if (vt == _datefld)
  {
    TString& tmp = get_tmp_string();
    tmp << '\'' <<  var.as_date().string(full, '-', full, full, amg_date) << '\'';
    return tmp;
  }

  const TString& str = var.as_string();

  bool apici = vt == _alfafld;
  if (apici && str[0] != '0' && real::is_natural(str))
    apici = false;
  
  if (!apici)
    return str;
  
  TString& tmp = get_tmp_string();
  tmp = str;
  for (int a = str.rfind('\''); a >= 0; a--)
  {
    if (tmp[a] == '\'')
      tmp.insert("'", a);
  }
  tmp.insert("'", 0);
  tmp << '\'';
  return tmp;
}

// Elimina il record in base ai campi chiave
bool TTrFa_record::remove()
{
  TString256 query;
  query << "DELETE FROM " << _table << " WHERE ";
  int nkf = 0;
  FOR_EACH_TOKEN(_key, fld)
  {
    const TVariant& var = get(fld);
    if (!var.is_null())
    {
      if (nkf++ > 0)
        query << " AND ";
      query << fld << '=' << var2str(fld, var) ;
    }
  }
  CHECKS(nkf >= 2, "Can't remove partial key on table ", (const char*)_table);
  query << ';';
  return xvt_sql_execute(_db, query, NULL, 0L) > 0;
}

// Callback per la sottostante funzione search()
static int tff_search_record(void* jolly, int cols, char** values, char** names)
{
  TTrFa_record& rec = *(TTrFa_record*)jolly;
  for (int i = 0; i < cols; i++)
    rec.set(names[i], values[i]);
  return 0;
}

// Carica un record in base ai campi chiave
bool TTrFa_record::search()
{
  CHECKS(_fields.items() >= _key.items(), "Can't search partial key on table ", _table);
  TString256 query;
  query << "SELECT * FROM " << _table << " WHERE ";
  FOR_EACH_TOKEN(_key, fld)
  {
    const TVariant& var = get(fld);
    if (!var.is_null())
      query << fld << '=' << var2str(fld, var) << " AND ";
  }
  query.rtrim(5);
  query << ';';
  return xvt_sql_execute(_db, query, tff_search_record, this) == 1;
}

// Carica un record in base ad un massimo di 3 campi chiave
bool TTrFa_record::search(const char* k1, const char* k2, const char* k3)
{
  _fields.destroy();

  set(_key.get(0), k1);
  set(_key.get(1), k2);
  if (k3 && *k3)
    set(_key.get(2), k3);

  return search();
}

// Aggiunge un record al db
bool TTrFa_record::insert()
{
  CHECKS(_fields.items() > _key.items(), "Can't insert empty record on table ", _table);

  TString query, values;
  query << "INSERT INTO " << _table << "\n(";
  FOR_EACH_ASSOC_OBJECT(_fields, obj, fld, itm)
  {
    const TVariant& var = get(fld);
    if (!var.is_null())
    {
      query << fld << ',';
      values << var2str(fld, var) << ',';
    }
  }
  query.rtrim(1); values.rtrim(1);
  query << ")\nVALUES (" << values << ");";
  return xvt_sql_execute(_db, query, NULL, 0L) == 1;
}

// Crea un record della tabella data ed imposta i nomi dei campi chiave
TTrFa_record::TTrFa_record(const char* table) : _table(table), _key(15, ',')
{
  _key = ini_get_string("./tff.ini", table, "INDEX_1");
  if (_key.empty()) 
  {
    // Cerco di costruire i nomi della chiave cercando la K, come in P1_KEYHEADERFATT
    TConfig cfg("tff.ini", table);
    TAssoc_array& fields = cfg.list_variables();
    FOR_EACH_ASSOC_STRING(fields, obj, key, str)
    {
      if (key[3] == 'K')
        _key.add(key);
    }
  }
  CHECKS(!_key.empty_items(), "Invalid primary key for table ", table);
}

/////////////////////////////////////////////////////////////////////////////////////
// TTrFa_cursors
/////////////////////////////////////////////////////////////////////////////////////
TTrFa_cursors::~TTrFa_cursors()
{
	if(c_rmoviva != NULL)
		delete c_rmoviva;
}

int TTrFa_cursors::next(TAssoc_array& recimposte, bool& ok, TString& tipocf, TString& codcf)
{
	// Azzero recimposte
	recimposte.destroy();
	// Return code
	return_code err;
	// Record
	TRectype record = _next(err, tipocf, codcf);
	if(record.get("NUMREG") == "42094")
		bool tolla = true;
	while(err < nextmov)
	{
		// Se ho trovato un record custom o non trovo il suo codiva tra i record custom lo salvo
		if(recimposte.is_key(record.get("CODIVA")))
		{
			// Prelevo il record salvato
			TRectype app = *(TRectype*)recimposte.objptr(record.get("CODIVA"));
			// Aggiorno i valori
			app.put("IMPONIBILE", app.get_real("IMPONIBILE") + record.get_real("IMPONIBILE"));
			app.put("IMPOSTA", app.get_real("IMPOSTA") + record.get_real("IMPOSTA"));
			// Lo reinserisco
			recimposte.add(record.get("CODIVA"), app, true);
		}
		else	// Inserisco per la prima volta
		{
			// Salvo il record nell'array
			recimposte.add(record.get("CODIVA"), record);
		}
		record = _next(err, tipocf, codcf);
	}
	ok = err != eof;
	return err;
}

/*
 * Questa funzione precarica un array associativo con il movimento diviso per codiva e lo ritorna
 */
TRectype TTrFa_cursors::_next(return_code& code, TString& tipocf, TString& codcf)
{
	TString numMov = c_rmoviva->get("23.NUMREG").as_string();
	// Record di ritorno
	TRectype retRec(LF_TRASFATT);
	// Controllo che non sia il primo record del movimento
	if(_newMov)
	{
		_newMov = false;
		// Se <20> un cliente occasionale passo "O"
		if(c_rmoviva->get("23.OCFPI").as_string() != "")
		{
			tipocf = "O";
			codcf = c_rmoviva->get("23.OCFPI").as_string();
		}
		else
		{
			tipocf = c_rmoviva->get("23.TIPO").as_string();
			codcf = c_rmoviva->get("23.CODCF").as_string();
		}
	}
	else
	{
		TString codiva;
		do
		{
			// Se ritorna false ho finito i records
			if(!c_rmoviva->move_next())
			{
				code = eof;
				return retRec;
			}
			else
			{
				// Controllo se ho cambiato movimento
				_newMov = numMov != c_rmoviva->get("23.NUMREG").as_string();
			}
		} // Ciclo finch<63> non trovo un nuovo movimento o trovo cod IVA gi<67> presi da cust
		while(!checkRecord(c_rmoviva) || (!_newMov && _alqCust.get_pos(codiva) > -1));
	}
	
	// Se ho cambiato movimento ritorno, legger<65> poi al prossimo giro
	if(_newMov)
	{
		_alqCust.cut(0);
		code = nextmov;
		return retRec;
	}
	else
		code = found;

	// Controllo dell'esistenza di un record custom in tasfatt
	retRec = getTrasFatt(c_rmoviva->get("23.NUMREG").as_string(), c_rmoviva->get("25.CODIVA").as_string());
	if(retRec.empty())
	{
		code = found;
		// Carico il record
		retRec.put("NUMREG",			c_rmoviva->get("23.NUMREG").as_int());
		retRec.put("TIPO",				c_rmoviva->get("23.TIPO").as_string());
		retRec.put("CODCF",				c_rmoviva->get("23.CODCF").as_string());
		retRec.put("OCCAS",				c_rmoviva->get("23.OCFPI").as_string());
		retRec.put("TIPODOC",			c_rmoviva->get("23.TIPODOC").as_string());
		retRec.put("NUMDOC",			c_rmoviva->get("23.NUMDOC").as_string());
		retRec.put("DATAREG",			c_rmoviva->get("23.DATAREG").as_date());
		retRec.put("DATADOC",			c_rmoviva->get("23.DATADOC").as_date());
		retRec.put("IMPONIBILE",	c_rmoviva->get("25.IMPONIBILE").as_real());
		retRec.put("IMPOSTA",			c_rmoviva->get("25.IMPOSTA").as_real());
		retRec.put("CODIVA",			c_rmoviva->get("25.CODIVA").as_string());
		retRec.put("TIPODET",			c_rmoviva->get("25.TIPODET").as_string());
	}
	else
	{
		_alqCust.add(c_rmoviva->get("25.CODIVA").as_string());
		code = foundcust;
	}
	return retRec;
}

/* Utilizzo questa funzione per filtrare al meglio i record, tutti i casi che devo omettere verranno rilevati e ritorneranno false
 * Nota bene: viene sfruttato un puntatore di TISA_Recordset per non creare nuovi oggetti e velocizzare la chiamata
 * a questo punto il programma non ha ancora creato un record di $trasfatt con i dati che mi interessano
 */
bool TTrFa_cursors::checkRecord(TISAM_recordset* rec)
{
	TString codiva = rec->get("25.CODIVA").as_string();
	
	// Tolgo i non soggetti
	TCodiceIVA cod(codiva);
	if(cod.tipo() == "NS")
		return false;

	// Clienti
	if(rec->get("23.TIPO").as_string() == "C")
	{
		// Tolgo tutti i movimenti di sola IVA e in reverse charge o di tipo 3 (Acquisto di beni e servizi di soggetti non residenti)
		TCausale caus(rec->get("23.CODCAUS").as_string());
		if(caus.soloiva() && (caus.reverse_charge() || caus.regime_speciale() == 3))
			return false;
	}

	return true;
}

int TTrFa_cursors::updateFilters(const char tipocf, const long codcf, TDate dal, TDate al, int cod)
{
	TString query = "USE RMOVIVA\n";  
	query << "SELECT (23.REG!=\"\")&&BETWEEN(23.DATAREG,#DADATAREG,#ADATAREG)&&(23.TIPO=\"" << tipocf << "\")";
	
	if(codcf > 0)
		query<<"&&STR((23.CODCF=#CODCF))";
	/*
	switch(cod)
	{
	case toSend:
		query<<"&&(23.TFINVIO!=\"X\")";
		break;
	case sent:
		query<<"&&(23.TFINVIO=\"X\")";
		break;
	default:
		break;
	}
	*/

	query << "\nJOIN MOV INTO NUMREG==NUMREG\n";
	 c_rmoviva = new TISAM_recordset(query);

	if(dal.empty()) dal = "20170101";	// Data in cui questo modulo <20> diventato valido
	if(al.empty()) al = TODAY;

	c_rmoviva->set_var("#DADATAREG", dal);
	c_rmoviva->set_var("#ADATAREG", al);

	if(codcf > 0)
		c_rmoviva->set_var("#CODCF", codcf);


	if(c_rmoviva->items() > ZERO)
	{
		_newMov = true;
		return c_rmoviva->items(); 
	}
	return -1;
}

/////////////////////////////////////////////////////////////////////////////////////
// TTrFa_mask
/////////////////////////////////////////////////////////////////////////////////////

TTrFa_mask::~TTrFa_mask() 
{ 
	TSheet_field& sheet = sfield(F_RIGHE); 
	if(!sheet.empty()) 
		sheet.destroy(); 
}

void TTrFa_mask::next_page(int p)
{
	TAutomask::next_page(p);
	if (_filter_changed)
	{
		TSheet_field & sf = sfield(F_RIGHE);
		if (curr_win() == sf.parent())
		{
			load_sheet();
			sf.force_update();
			_filter_changed = false;
		}
	}
}

bool TTrFa_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	
  switch (o.dlg())
  {
  case F_DATAINI:
    if (e == fe_init)
      o.set(ini_get_string(CONFIG_DITTA, "tf", "LastSend", "01-01-2017"));
		break;
	case F_DATAFIN:
		if (e == fe_init)
			o.set(TDate(TODAY));
		break;
	case DLG_ALL:
	if (e == fe_button)
	{
		TSheet_field& docs = sfield(F_RIGHE);
		TString_array& sht = docs.rows_array();
		const int items = sht.items();

		if (items > 0)
		{
			const TString4 select = *(sht.row(0).get(0)) == 'X' ? "" : "X";
			for (int i = 0; i < items; i++)
				sht.row(i).add(select, 0);
			docs.force_update();
		}
	}
	break;
	case F_RIGHE:
		if (e == se_notify_add)
    {
      TSheet_field& s = (TSheet_field&)o;
      TToken_string& row = s.row(jolly);
      row.add(nuovo_progr(), s.cid2index(A_NUMERO));
    } else
    if (e == se_query_del)
    {
      TSheet_field& s = (TSheet_field&)o;
      TToken_string& row = s.row(jolly);
      const TRecnotype progr = row.get_long(0);
      return progr >= MOV_CUSTOM;
    }
		break;
	case A_DATAREG:
		{
			// Mi interessa solo fe_edit
			if(e != fe_modify) break;
			// Controllo che la data sia < della data documento e l'esercizio sia quello richiesto
			TDate datareg = o.get(), datadoc = o.mask().get(A_DATADOC);
			if(datareg >= get_date(F_DATAINI) && datareg <= get_date(F_DATAFIN))
			{
				// Controllo la data del documento
				if(datadoc.ok())
				{
					if(datadoc > datareg)
					{
						error_box("La data del documento <20> antecedente a quella di registrazione");
						o.set("");
					}
				}
			}
			else
			{
				error_box("La data di registrazione non appartiene al periodo corrente");
				o.set("");
			}
		}
		break;
	case A_DATADOC:
		{
			// Mi interessa solo fe_edit
			if(e != fe_modify) break;
			TDate datareg = o.mask().get(A_DATAREG), datadoc = o.get();
			// Controllo la data di registrazione
			if(datareg.ok())
			{
				if(datadoc > datareg)
				{
					error_box("La data del documento <20> antecedente a quella di registrazione");
					o.set("");
				}
			}
		}
		break;
	case A_ALIQUOTA:
		if(e == fe_modify)
		{
			// Calcolo la natura
			o.mask().set(A_NATURA, natura(o.get()));
			// Se esiste un imponibile calcolo l'imposta
			real imponibile = o.mask().get(A_IMPONIBILE), imposta = ZERO;
			if(imponibile > 0)
			{
				imposta = imponibile * real(cache().get("%IVA", o.get(), "R0")) / 100;
				o.mask().set(A_IMPOSTA, imposta.round(2).string());
			}
		}
		break;
	case A_IMPONIBILE:
		if(e == fe_modify)
		{
			// Se esiste l'iva calcolo l'imposta
			real imponibile = o.get(), imposta = ZERO;
			TString codiva = o.mask().get(A_ALIQUOTA);
			if(codiva != "")
			{
				imposta = imponibile * real(cache().get("%IVA", codiva, "R0")) / 100;
				o.mask().set(A_IMPOSTA, imposta.round(2).string());
			}
		}
		break;
	case A_IMPOSTA:
		if(e == fe_modify)
		{
			// Controllo dell'esistenza sia di codiva che dell'imponibile e verifico che l'importo immesso sia corretto
			real imponibile = o.mask().get(A_IMPONIBILE), imposta = ZERO;
			TString codiva = o.mask().get(A_ALIQUOTA);
			if(codiva != "" && imponibile > ZERO)
			{
				imposta = imponibile * real(cache().get("%IVA", codiva, "R0")) / 100; imposta = imposta.round(2);
				// Controllo che l'aliquota calcolata sia == a quella che ho qua
				real impostaInserita = o.get();
				if(impostaInserita != imposta)
				{
					TString msg; 
					msg << "Attenzione!! Il valore immesso " << impostaInserita.string() << "<EFBFBD> non <20> corretto!\n";
					msg << "Valore corretto: " << imposta.string() << "<EFBFBD>\nVuoi proseguire?";
					if(!yesno_box(msg))
					{
						o.set(imposta.string());
					}
				}
			}
		}
	case A_TIPOCF:
	case A_CODCF:
	case A_OCFPI:
		{
			if(e != fe_modify) break;
			TString tipocf, codcf;
			// Controllo se <20> un cliente occasionale
			tipocf = "O";
			codcf	 = o.mask().get(A_OCFPI);
			if(codcf.empty())
			{
				tipocf = o.mask().get(A_TIPOCF);
				codcf  = o.mask().get(A_CODCF);
			}
			TRectype app = getCli(tipocf, codcf);
			o.mask().set(A_RAGSOC, app.get("RAGSOC"));
			o.mask().set(A_RFSO, app.get("CODRFSO"));
			o.mask().set(A_RAGSOCRFSO, getRFSO(app.get("CODRFSO")));
			o.mask().set(A_PAIV, app.get("PAIV"));
			o.mask().set(A_COFI, app.get("COFI"));

			// Controllo autofattura
			TString key; key << prefix().firm().get("TIPOA") << "|" << prefix().firm().get("CODANAGR");
			TString piva = cache().get(LF_ANAG, key, "PAIV");
			if(piva == app.get("PAIV"))
			{
				// Autofattura!
				o.mask().set(A_AUTOFATT, "X");
			}
		}
	case DLG_SAVEREC:
		if(e == fe_button)
			saveAll();
		break;
	case DLG_ARCHIVE:
		if(e == fe_button)
			checkAll();
		break;
	case DLG_EDIT:
		if(e == fe_button)
		{
			TSheet_field& sheet = sfield(F_RIGHE);
			if(sheet.items() > 0)
			{
				sheet.esporta();
			}
			else
			{
				warning_box("Impossibile esportare una griglia vuota");
			}
		}
		break;
  default: 
		break;
	}

	const short id = o.dlg();
	if (e == fe_modify && jolly == 1)
  {
    if (id >= START_SHEET && id < END_SHEET && id != A_FORZATA)
    {
      o.mask().set(A_FORZATA, true);
    }
	}
	if (e == fe_modify && jolly == 0)
	{
		if (id >= START_MASK && id <= END_MASK)
    {
      setFilterChanged();
    }
		if(id >= START_BOOLEAN && id <= END_BOOLEAN)
			saveConfig();
  }
  return true;
}
void TTrFa_mask::loadConfig()
{
	// Rilevo i tipi scelti
	TToken_string tipidoc(ini_get_string(CONFIG_DITTA, "tf", "TIPIDOC"));
	// Potrei fare un for su TToken_string ma non darebbe la possibilit<69> di flaggare tutto in caso di prima installazione
	for(int pos = 0; pos < tipidoc.items(); pos++)
	{
		set(getTipoDoc(tipidoc.get(pos)), "X");
	}
}
void TTrFa_mask::saveConfig()
{
	TToken_string tipidoc;
	for(int id = START_BOOLEAN; id <= END_BOOLEAN; id++)
	{
		if(get_bool(id))
		{
			tipidoc.add(getTipoDoc(id));
		}
	}
	ini_set_string(CONFIG_DITTA, "tf", "TIPIDOC", tipidoc);
}

/* salvo tutti i record modificati */
bool TTrFa_mask::saveAll()
{
	TSheet_field& sheet = sfield(F_RIGHE);
	//TString_array& strarr = sheet.rows_array();
	TString mod = "";
	FOR_EACH_SHEET_ROW(sheet, r, strarr)
	{
		strarr->get(_forzata, mod);
		if(mod == "X")
		{
			bool ok, retry = false;
			do 
			{
				ok = saveRec(*strarr);
				if(!ok)
				{
					TString msg = "Errore durante il salvataggio del movimento ";
					msg << "alla riga " << r << "\nRitentare?";
					retry = yesno_box(msg);
				}
			} while(retry && !ok);
			if(!ok)
				return false;
		}
	}
	return true;
}

bool TTrFa_mask::checkAll()
{
	// Controllo di avere uno sheet pieno
	if(!checkNotEmpty()) return true;

	if(yesno_box("Controllare tutti i C.F. P.IVA?"))
	{
		TExternal_app servizio("cg1 -2 L");
		servizio.run();
	}
	static TPrinter stampa;
	stampa.reset();
	stampa.open();
	TPrintrow riga;
	riga.put(TR("------------------ Controllo Errori TF -------------------"), 30);
	stampa.setheaderline(1, riga);
	riga.reset();
	riga.put("N.Registrazione", 0);
	riga.put("N.Documento", 20);
	riga.put("Tipo errore", 40);
	stampa.setheaderline(3, riga);
	riga.reset();
	riga.put(TR("Tutti i record errati sono stati segnati con il codice \"Errore\" e non verranno inviati"), 0);
	stampa.setheaderline(2, riga);
	riga.reset();
	stampa.setheaderline(4, riga);
	TSheet_field& sheet = sfield(F_RIGHE);
	FOR_EACH_SHEET_ROW(sheet, r, strarr)
	{
		checkRec(&stampa, *strarr);
	}
	stampa.close();
	return true;
}

inline void printError(TPrinter* stampa, TString movimento, TString documento, TString msgerr)
{
	TPrintrow riga;
	riga.put(movimento, 0);
	riga.put(documento, 20);
	riga.put(msgerr, 40);
	stampa->print(riga);
}

bool TTrFa_mask::checkRec(TPrinter* stampa, TToken_string rec)
{
	bool ok = true;
	TString numMov = rec.get(_numero), numDoc = rec.get(_numdoc);
	TString msgerr;
	TString coderr;
	// Controllo date ***********************************************************************************
	TDate reg = rec.get(_datareg), doc = rec.get(_datadoc);
	if(reg < doc)
	{
		ok = false;
		msgerr.cut(0) << "Data registrazione precedente alla data del documento";
		printError(stampa, numMov, numDoc, msgerr);
		coderr << "1;";
	}

	// Controllo aliquota, imponibile e imposta *********************************************************
	TCodiceIVA codiva(rec.get(_aliquota));
	TString nat = rec.get(_natura), realNat(natura(rec.get(_aliquota))); 
	nat.ltrim();	// Se vuoto arriva con uno spazio
	real imponibile = rec.get(_imponibile), imposta = rec.get(_importoIVA);
	if(nat != realNat)
	{
		msgerr.cut(0) << "Natura del movimento errata, valore dichiarato: " << nat << " valore corretto: " << realNat;
		printError(stampa, numMov, numDoc, msgerr);
		coderr << "2;";
	}
	
	real realImp = imponibile * codiva.percentuale() / CENTO;
	realImp.round(2);
	if(imposta != realImp)
	{
		msgerr.cut(0) << "Imposta errata, valore dichiarato: " << imposta.string() << " valore corretto: " << realImp.string();
		printError(stampa, numMov, numDoc, msgerr);
		coderr << "3;";
	}

	// Controllo Stato ***********************************************************************************
	/*
	TRectype clifo = getCli(rec.get(_tipocf), rec.get(_codcf));
	if(clifo.get("STATOCF") == "" && 
	*/
	// Flaggo il record con i messaggi di errore
	if(!ok)
	{
		rec.add("E",		_invio);
		rec.add(coderr, _coderr);
	}
	
	return ok;
}

bool TTrFa_mask::checkNotEmpty()
{
	TSheet_field& sheet = sfield(F_RIGHE);
	TString msg;

	if(sheet.empty())
		msg = "La tabella dei movimenti <20> vuota, vuoi caricarla con i filtri selezionati?";
	else if(_filter_changed)
		msg = "I filtri sono stati cambiati, vuoi ricaricare la tabella con i nuovi filtri selezionati?";

	if(msg.full() && yesno_box(msg))
	{
		_filter_changed = false;
		load_sheet();
	}
	return sheet.full();
}

TRecnotype TTrFa_mask::nuovo_progr() const
{
	static TRectype app(LF_TRASFATT);
	app.last(TLocalisamfile(LF_TRASFATT));
	// Lo inizializzo solo la prima volta poi incremento
	static TRecnotype numreg = app.get_long("NUMREG") > MOV_CUSTOM ? app.get_long("NUMREG") : MOV_CUSTOM;
	numreg++;
	return numreg;
}

void TTrFa_mask::load_sheet()
{
	const char tipo = get(F_TIPOCF)[0];
  const long codice = get_long(F_CODCF);
	TDate dal = get_date(F_DATAINI), al = get_date(F_DATAFIN);
	//TString key; key << "TIPOA=" << prefix().firm().get("TIPOA")<< ",CODANAGR=" << prefix().firm().get("CODANAGR");
	TString key; key << prefix().firm().get("TIPOA") << "|" << prefix().firm().get("CODANAGR");
	const TString pivaDitta = cache().get(LF_ANAG, key, "PAIV");
	const TString cofiDitta = cache().get(LF_ANAG, key, "COFI");
	
	TTrFa_cursors c;

	TSheet_field& sheet = sfield(F_RIGHE);
	TString_array& strarr = sheet.rows_array();
	
	sheet.hide();   // Nascondo lo sheet per guadagnare un 20% di velocit<69> di caricamento, le ottimizzazioni da PRO!
	if(!sheet.empty())
		sheet.destroy();
	TAssoc_array recimposte;
	int items = c.updateFilters(tipo, codice, dal, al, get_int(F_FATTSEL));
	for(bool ok = true; items > 0 && ok;)
	{
		TString tipocf, codcf;
		int err = c.next(recimposte, ok, tipocf, codcf);
		// Carico i clienti
		TRectype cli = getCli(tipocf, codcf);
		
		FOR_EACH_ASSOC_OBJECT(recimposte, h, iva, rec)
		{
			TToken_string* row = new TToken_string;
			TRectype movimento = *(TRectype*)rec;

			// Controllo che sia un tipo documento da leggere
			if(!get_bool(getTipoDoc(movimento.get("TIPODOC")))) continue;

			/* Siccome mi cambiano l'ordine ogni volta e non ho voglia di cambiare tutto ovunque 
			 * basta settare i valori negli enum e lo sheet
			 */
			TRectype isCust = getTrasFatt(movimento.get("NUMREG"), iva);
			
			row->add(isCust.get_bool("TFINVIO") ? "X" : "", _spedita);		// Spedita
			row->add("X");																								// Da spedire, sempre!
			row->add(isCust.full() ? "X" : "", _forzata);									// Modificato
			row->add(movimento.get_long("NUMREG"), _numero);							// Numero registrazione
			row->add(movimento.get_date("DATAREG"), _datareg);						// Data Registrazione
			row->add(movimento.get("TIPO"), _tipocf);											// Tipo Cli/For
			row->add(movimento.get("CODCF"), _codcf);											// Codice Cli/For
			row->add(movimento.get("OCCAS"), _occas);											// Codice Occasionale
			row->add(cli.get("RAGSOC"), _ragsoc);													// Ragione sociale
			row->add(cli.get("CODRFSO"), _rfso);													// Codice RF/SO
			row->add(getRFSO(cli.get("CODRFSO")), _ragsocrfso);						// Ragione Sociale RF/SO
			row->add(movimento.get("TIPODOC"), _codnum);									// Tipo documento
			row->add(movimento.get("NUMDOC"), _numdoc);										// Numero documento
			row->add(movimento.get_date("DATADOC"), _datadoc);						// Data documento
			row->add(natura(iva), _natura);																// NATURA!
			row->add(iva, _aliquota);																			// Codice aliquota!
			row->add(findDetraib(movimento.get("TIPODET")), _detraibile);	// Detraibilit<69>
			row->add(movimento.get_real("IMPONIBILE"), _imponibile);			// Imponibile
			row->add(movimento.get_real("IMPOSTA"), _importoIVA);					// Imposta
			row->add(revCharge(movimento.get("NUMREG")), _reverse);				// Rev.Charge
			
			/*
			 * Possono esistere movimenti custom dove il cliente ha una partita IVA propria 
			 * ma <EFBFBD> stato flaggato l'autofattura, quindi in trasfat <EFBFBD> presente il codice cliente con PIVA e CODFIS della ditta.
			 * Controllo sia il movimento che il cliente
			 */
			if(movimento.get("AUTOFATT") == "X" || pivaDitta == cli.get("PAIV"))	// Se <20> un autofattura
			{
				row->add("X",				_autofatt);															// AutoFatt
				row->add(pivaDitta, _paiv);																	// P.IVA
				row->add(cofiDitta, _codfis);																// Codice Fiscale
			}
			else
			{
				row->add("",							_autofatt);												// AutoFatt
				row->add(cli.get("PAIV"), _paiv);														// P.IVA
				row->add(cli.get("COFI"), _codfis);													// Codice Fiscale
			}

			strarr.add(row);
		}
		recimposte.destroy();
	}
	sheet.force_update();
	sheet.show();
}

TString TTrFa_mask::findDetraib(TString tipodet) const
{
	real perc = cache().get("%DET", tipodet, "R0");
	return perc.stringa(6,2);
}

const char * TTrFa_mask::natura(const TString& codiva) const
{
	const TRectype& ai = cache().get("%IVA", codiva);
	TString & natura = get_tmp_string(4);
	
	natura = ai.get("S12");
	return natura;
}

real TTrFa_mask::get_IVA(const TString& codiva) const
{
  const TRectype& ai = cache().get("%IVA", codiva);
  return ai.get_real("R0");
}

TString TTrFa_mask::revCharge(TString numreg) const 
{
	// Controllo se la causale ha il reverse charge, se il cliente non l'ha impostata giusta sono ARAZZI suoi
	TString key = numreg;
	TCausale caus(cache().get(LF_MOV, key, "CODCAUS"));
	return caus.reverse_charge() ? "X" : "";
}

TString TTrFa_mask::getRFSO(TString codrfso) const
{
	TString key; key << codrfso[0] << "|" << codrfso.mid(1);
	return cache().get(LF_ANAG, key, "RAGSOC");
}

TTrFa_mask::TTrFa_mask(TString msk) 
	: TAutomask(msk), _filter_changed(true) 
{ 
	loadConfig(); 
}

/////////////////////////////////////////////////////////////////////////////////////
// TTrFa_app
/////////////////////////////////////////////////////////////////////////////////////

void TTrFa_app::log(int severity, const char* msg)
{
  if (severity < 0)
  {
    _logTFF = msg;
  } else
  if (_log == NULL)
  {
    _log = new TLog_report;
    if (_logTFF.full())
    {
      TString txt;
      txt << _logTFF << ": " << msg;
      _log->log(severity, txt);
    }
    else
      _log->log(severity, msg);
  }
}

bool TTrFa_app::show_log()
{
  bool ok = true;
  if (_log)
  {
    _log->preview();
    delete _log;
    _log = NULL;
    ok = noyes_box(TR("Si desidera procedere con la generazione file xml?"));
  }
  return ok;
}

void TTrFa_app::set_IVA(const TString& codiva, TTrFa_record& tff) const
{/*
  const TRectype& ai = cache().get("%IVA", codiva);
  const real aliquota = ai.get("R0");
  tff.set("PI_ALIQUOTAIVA", aliquota);
	if (codiva.full())
  {
		if (aliquota.is_zero())
			tff.set("PI_NATURA", natura(codiva));
		else
			tff.set("PI_NATURA", "");
	}*/
}

void TTrFa_app::set_IVA(const TRiga_documento& rdoc, TTrFa_record& tff) const
{/*
	const TString8 codiva(rdoc.get(RDOC_CODIVA));
  const TRectype& ai = cache().get("%IVA", codiva);
  const real aliquota = ai.get("R0");
  tff.set("PI_ALIQUOTAIVA", aliquota);
	if (codiva.full())
  {
		if (aliquota.is_zero())
			tff.set("PI_NATURA", natura(codiva));
		else
			tff.set("PI_NATURA", "");
	}*/
}


int TTrFa_app::parse_line(const TString& line, TString& var, TString& val) const
{
  if (line.blank())
    return 0;

  if (line[0] == '[')
  {
    var = line.mid(1);
    var.rtrim(1);
    val.cut(0);
    return 1;
  }

  const int equal = line.find('=');
  if (equal < 6)
    return 0;
  var = line.left(equal); var.trim();
  val = line.mid(equal+1);  val.trim();
  return 2;
}

bool TTrFa_app::create_table(TScanner& tff, const TString& table)
{
  TString query, var, val;
  if (xvt_sql_table_exists(_db, table))
  {
    SLIST fields = xvt_sql_list_fields(_db, table);
    while (!tff.eof())
    {
      const TString& line = tff.line();
      const int n = parse_line(line, var, val);
      if (n <= 0)
        break;
      if (var.starts_with("INDEX_"))
        break;
      if (xvt_slist_find_str(fields, var) == NULL)
      {
        query.cut(0) << "ALTER TABLE " << table << " ADD COLUMN " << var << ' ' << val << " NOT NULL"; 
        if (val.find("INT") >= 0 || val.find("NUM") >= 0)
          query << " DEFAULT 0"; 
        else
          query << " DEFAULT ''";
        query << ";";
        xvt_sql_execute(_db, query, NULL, NULL); // Create table
      }
    }
    xvt_slist_destroy(fields);
  }
  else
  {
    query << "CREATE TABLE " << table << " (";
    while (!tff.eof())
    {
      const TString& line = tff.line();
      const int n = parse_line(line, var, val);
      if (n <= 0)
        break;
      if (n == 1)
      {
        tff.push(line);
        break;
      }
      if (var.starts_with("INDEX_"))
      {
        query.rtrim(1); // toglie ultima ,
        query << ");";
        xvt_sql_execute(_db, query, NULL, NULL); // Create table
        query.cut(0);
        query << "CREATE UNIQUE INDEX "
              << table << "_1 ON " << table 
              << " (" << val << ");";
        xvt_sql_execute(_db, query, NULL, NULL); // Create index
        break;
      }
      else
      {
        query << "\n " << var << ' ' << val << " NOT NULL";
        if (val.find("INT") >= 0 || val.find("NUM") >= 0)
          query << " DEFAULT 0";
        else
          query << " DEFAULT ''";
        query << ",";
      }
    }
  }

  return true;
}

bool TTrFa_app::create()
{
	open_files(LF_MOV, LF_RMOV, LF_RMOVIVA, LF_TABCOM, LF_ANAG, 
             LF_CLIFO, LF_OCCAS, LF_CFVEN, LF_NDITTE, 0);
	
	// Controllo preventivo dell'avvenuta conversione del tracciato record
  TRectype rmoviva(LF_RMOVIVA);

  //if (rmoviva.type("TFINVIO") != _boolfld)
    //return error_box(TR("Database non convertito per il Trasferimento Elettronico"));

  _ditta.init(LF_NDITTE, prefix().get_codditta());

  _dbname = prefix().get_studio();  // base direcotry
  _dbname.add("sql"); make_dir(_dbname);
  TString16 d; d.format("TF%05ld.db", prefix().get_codditta());
  _dbname.add(d);

	bool create = !_dbname.exist();
	_db = xvt_sql_open(_dbname, user(), "", _dbname.path());
	if (_db == NULL)
		return false;

	if(create)
	{
		createDB();
	}
  return TSkeleton_application::create();
}

// Sincronizzo il DB SQL con quello di campo
bool TTrFa_app::syncronizeDB()
{
	//xvt_sql_begin(_db);

	return true;
}

bool TTrFa_app::createDB()
{
	const TFilename ini = "tff.ini";
	bool ok = ini.exist();
	if (ok)
	{
		xvt_sql_begin(_db);
		TScanner TFF(ini);
		while (ok && !TFF.eof())
		{
			const TString& p = TFF.line();
			if (p.starts_with("[TF") && p.ends_with("F]"))
			{
				TString16 table = p; table.strip("[]");
				ok = create_table(TFF, table);
			}
		}
		if(ok)
		{
			// Aggiungo il valore di default in TFNUM
			TTrFa_record tfnum("TFNUM00F");
			tfnum.set("PJNKEY", "00001");
			tfnum.set("PJNINV", "0000000000");
			ok = tfnum.insert();
		}
		if (ok)
			xvt_sql_commit(_db);
		else
			xvt_sql_rollback(_db);
	}
	else
		return cantread_box(ini);
	
	return true;
}

bool TTrFa_app::send(TTrFa_mask* msk)
{
	// Controllo se <20> la prima esecuzione, in caso positivo chiedo se vuole controllare p.iva e cf
	bool first = ini_get_bool(CONFIG_DITTA, "tf", "FirstExec", true);
	if(first)
	{
		if(yesno_box("Stai eseguendo il programma per la prima volta,\nvuoi controllare di avere tutti i Codici Fiscali e Partite IVA corrette?"))
		{
			TExternal_app checkApp("cg1 -2 L");
			checkApp.run();
		}
		ini_set_bool(CONFIG_DITTA, "tf", "FirstExec", false);
	}
	// Mi carico i miei dati
	TSheet_field& sheet = msk->sfield(F_RIGHE);
	// Booleano per appendere i record nel db
	_append = false;
	// Controllo che non ci sia gi<67> una esportazione in attesa


	/***********************************************************************************************
	 * Esporto
	 ***********************************************************************************************/
	xvt_sql_begin(_db);
	// Testata
	if(!_append)	
		tff0100(sheet);	// Se devo appendere vuol dire che c'<27> gi<67>!
	// Anagrafica
	tff0400(sheet);
	// Documenti
	tff0700(sheet);

	if(false)
	{
		log(-1, "WTF!?");
		xvt_sql_rollback(_db);
		//return false;
	}
	if(xvt_sql_commit(_db))
	{
		message_box("Ho esportato correttamente!");
		// Imposto l'esportazione
		//setEsportato(sheet);
	}
	else
		message_box("Il commit non <20> andato a buon fine");
	return true;
}

TString TTrFa_app::getKey(TToken_string* strarr)
{
	return strarr->get_char(_tipocf) == 'C' ? DTE_PROVV : DTR_PROVV;
}

TString TTrFa_app::getHeader(TToken_string* strarr)
{
	/*
	// Chiave header (20): TIPOCF(1) + NANANANANA(10) + CODCF(6)
	TString header; header.format("%c3753N4108E%06ld", strarr->get_char(_tipocf), strarr->get_int(_codcf));
	return header;
	*/
	
	/* Devo crearmi una struttura dove immagazzino delle strutture di clienti e all'interno ci metto i numeratori che mi chiedono
	 * Cos<EFBFBD> facendo mando a puttane persino l'append che potevo tranquillamente implementare prima e creare fastidiose query per capire dove cazzo sto
	 */
	// Chiave header (20): TIPOCF(1) + CODCF(6)
	static long int idHeader = 0L;

	// Cerco/Aggiungo il Clifo all'std::map
	TString keyMap; keyMap << strarr->get_char(_tipocf) << strarr->get_int(_codcf);
	clifoDoc app;
	// Non <20> presente e lo inserisco
	if(mCliDoc.find(keyMap) == mCliDoc.end())
	{
		idHeader++;
		app.contCliFo = idHeader;
		app.countDoc	= 0L;
		mCliDoc.insert(std::pair<TString,clifoDoc>(keyMap, app));
	}
	// <20> presente lo prendo
	else
	{
		app = mCliDoc[keyMap];
	}
	TString header; header.format("%c%06ld", strarr->get_char(_tipocf), strarr->get_int(_codcf));
	// Ritorno l'header
	return header;
}

TString TTrFa_app::getBody(TToken_string* strarr, bool add)
{
	/*
	// Chiave body (20): TIPODOC(2) + DATADOC[YEAR](4) + NUMDOC(7) + AAA(3) + CODALIQUOTA(4)
	TDate datadoc(strarr->get(_datadoc));
	TString body; body.format("%02s%04d%07s%04s", strarr->get(_codnum), datadoc.year(), strarr->get(_numdoc), strarr->get(_aliquota));
	return body;
	*/

	/* Sembra che utilizzare identificatori chiari e sensati in questo mondo non <20> concesso, quindi adesso vi sbatto un bell'ID numerico
	 * Ok per OGNI cliente devo assegnarli un identificativo del numero della fattura
	 */
	TString keyMap; keyMap << strarr->get_char(_tipocf) << strarr->get_int(_codcf);

	clifoDoc app = mCliDoc[keyMap];
	if(add)
		app.countDoc += 1;
	mCliDoc[keyMap] = app;

	TString body; body.format("%010d%010d", app.contCliFo, app.countDoc);
	return body;
}

bool TTrFa_app::tff0100(TSheet_field& sheet)
{
	const char* const paese = "IT";
	static const TFirm& firm = prefix().firm();

	// Controllo la presenza di clienti e fornitori
	// Scandisco in maniera ignorante sperando di beccare subito un cliente e un fornitore
	bool cli = false, fo = false;
	FOR_EACH_SHEET_ROW(sheet, r, strarr)
	{
		if(strarr->get_char(_tipocf) == 'C')
			cli = true;
		else
			fo = true;
		if(cli & fo) break;
	}
	// Metto qua il numero di telefono per dopo
	TString80 tel; tel << firm.get(NDT_PTEL) << firm.get(NDT_TEL);
	bool ok = true;
	if(cli)
	{
		TTrFa_record dte("TFF0100F");
		dte.set("P1_KEYPRGINVIO",			DTE_PROVV);
		dte.set("P1_TRASMITTPAESE",		paese);
		dte.set("P1_TRASMITTCOD",			_cofi);
		dte.set("P1_TIPOINVIO",				"DTE");
		dte.set("P1_TELEFONO",				tel);
		dte.set("P1_MAIL",						firm.get(NDT_MAIL));
		dte.set("P1_GESTIONE",				"");
		ok = dte.insert();
		if(!ok) return false;
		ok = tff0200(DTE_PROVV);
		if(!ok) return false;
	}
	if(fo)
	{
		TTrFa_record dtr("TFF0100F");
		dtr.set("P1_KEYPRGINVIO",			DTR_PROVV);
		dtr.set("P1_TRASMITTPAESE",		paese);
		dtr.set("P1_TRASMITTCOD",			_cofi);
		dtr.set("P1_TIPOINVIO",				"DTR");
		dtr.set("P1_TELEFONO",				tel);
		dtr.set("P1_MAIL",						firm.get(NDT_MAIL));
		dtr.set("P1_GESTIONE",				"");
		ok = dtr.insert();
		if(!ok) return false;
		ok = tff0200(DTR_PROVV);
		if(!ok) return false;
	}
	return ok;
}

bool TTrFa_app::tff0200(TString key)
{
	/********************************************************************************************************************
	 * Cedeprest																																																				*
	 ********************************************************************************************************************/
	// <CedentePrestatore>
	TTrFa_record tff0200f("TFF0200F");
	tff0200f.set("P2_KEYPRGINVIO", key);
  
	if (_ditta.partita_IVA().full())
	{
		tff0200f.set("P2_FISCIVAPAESE", _ditta.stato_partita_IVA()); // Sempre IT
		tff0200f.set("P2_FISCIVACOD",		_ditta.partita_IVA());
	}
	tff0200f.set("P2_CODFISCALE",			_ditta.codice_fiscale());
	if (_ditta.fisica())
	{
		tff0200f.set("P2_ANANOME",			_ditta.nome());
		tff0200f.set("P2_ANACOGNOME",		_ditta.cognome());
	}
	else
	{
		tff0200f.set("P2_ANADENOMIN",		_ditta.ragione_sociale());
	}

	// DatiSede
	tff0200f.set("P2_SEDEIND",				_ditta.via_residenza());
	tff0200f.set("P2_SEDENRCIVICO",		_ditta.civico_residenza());
	tff0200f.set("P2_SEDECAP",				_ditta.CAP_residenza());
	tff0200f.set("P2_SEDECOMUNE",			_ditta.comune_residenza());
	if(_ditta.italiano())	// Campo ritornerebbe "EE" se estero
		tff0200f.set("P2_SEDEPROV",				_ditta.provincia_residenza());
	tff0200f.set("P2_SEDENAZ",				_ditta.stato_residenza());

	myrfso = "";
	if(haveRFSO(myrfso))
	{
		TRectype r_ana = cache().get(LF_ANAG, TString(myrfso[0]) << myrfso.sub(1));

		if(r_ana.get_char("TIPORFSO") == 'S') // Stabile Organizzazione
		{
			tff0200f.set("P2_STABORGIND",				r_ana.get("INDRES"));
			tff0200f.set("P2_STABORGNRCIVICO",	r_ana.get("CIVRES"));
			tff0200f.set("P2_STABORGCAP",				r_ana.get("CAPRES"));
			TRectype r_comune = cache().get(LF_COMUNI, TString("|") << r_ana.get("COMRES"));
			tff0200f.set("P2_STABORGCOMUNE",		r_comune.get("DENCOM"));
			tff0200f.set("P2_STABORGPROV",			r_comune.get("PROVCOM"));
			tff0200f.set("P2_STABORGNAZ",				"IT");
		}
		else // Rappresentante Fiscale
		{
			bool ok = tff0300(key, r_ana);
			if(!ok) return false;
		}
	}
	tff0200f.set("P2_GESTIONE",     "");
	return tff0200f.insert();
}
bool TTrFa_app::tff0300(TString key, TRectype r_ana)
{
	TTrFa_record tff0300f("TFF0300F");
	tff0300f.set("P3_KEYPRGINVIO",			key);
	TString stato = r_ana.get("STATOPAIV") == "" ? "IT" : r_ana.get("STATOPAIV");
	tff0300f.set("P3_FISCIVAPAESE",			stato);
	tff0300f.set("P3_FISCIVACODICE",		r_ana.get("PAIV"));
					
	if(r_ana.get_char("TIPOA") == 'G')
	{
		tff0300f.set("P3_ANADENOMI",			r_ana.get("RAGSOC"));
	}
	else
	{
		TString nomCom = r_ana.get("RAGSOC");
		tff0300f.set("P3_ANANOME",				nomCom.sub(30));
		tff0300f.set("P3_ANACOGNOME",			nomCom.sub(0,30));
	}
	tff0300f.set("P3_GESTIONE",					"D");
	return tff0300f.insert();
}

bool TTrFa_app::tff0400(TSheet_field& sheet)
{
	// Siccome non siamo in grado di fare delle join devo in qualche modo evitare di caricare clienti gi<67> caricati quindi mi salvo tutto in un bel TToken_string e controllo
	// Era troppo complicato fare una join codice cliente con i documenti per prendere solo quelli valorizzati.
	TToken_string clifoSent = "";
	bool ok = true;
	TProgress_monitor p(sheet.items(),"Caricamento Clienti/Fornitori");
	FOR_EACH_SHEET_ROW(sheet, r, strarr)
	{
		if(!p.add_status())
			return false;
		if(strcmp(strarr->get(_invio), "X") != 0)	continue; // Non mi interessa se non <20> selezionata
		
		// Controllo il clifo, se non c'<27> lo aggiungo altrimenti salto sto giro
		TString checkClifo; checkClifo << strarr->get_char(_tipocf) << strarr->get_long(_codcf);
		if(clifoSent.get_pos(checkClifo) < 0)
			clifoSent.add(checkClifo);
		else
			continue;
	
		TAnagrafica cedeprest(LF_CLIFO, strarr->get_char(_tipocf), strarr->get_long(_codcf));
		TString keyCedPrest; keyCedPrest << strarr->get_char(_tipocf) << "|" << strarr->get_long(_codcf);
		TRectype r_cedeprest = cache().get(LF_CLIFO, keyCedPrest);
		TString statocli = cache().get("%STA", r_cedeprest.get("STATOCF"), "S10");
		// Se rimane vuoto <20> italiano
		if(statocli == "")
			statocli = "IT";

		TTrFa_record tff0400f("TFF0400F");
		tff0400f.set("P4_KEYPRGINVIO",		getKey(strarr));
		tff0400f.set("P4_KEYHEADERFATT",	getHeader(strarr));

		// Autofattura
		if(strcmp(strarr->get(_autofatt),"X") == 0)
		{
			tff0400f.set("P4_FISCIVAPAESE", _ditta.stato_partita_IVA());
			tff0400f.set("P4_FISCIVACOD",   _ditta.partita_IVA());
			tff0400f.set("P4_CODFISC",			_ditta.codice_fiscale());
		}
		else	// Fattura normale
		{
			if (cedeprest.stato_partita_IVA().full() && cedeprest.partita_IVA().full())
			{
				tff0400f.set("P4_FISCIVAPAESE", cedeprest.stato_partita_IVA());
				tff0400f.set("P4_FISCIVACOD",   cedeprest.partita_IVA());
			}
			else
			{
				tff0400f.set("P4_CODFISC", cedeprest.codice_fiscale());
			}
		}

		if (cedeprest.fisica())
		{
			tff0400f.set("P4_ANANOME",    cedeprest.nome());
			tff0400f.set("P4_ANACOGNOME", cedeprest.cognome());
		}
		else
		{
			tff0400f.set("P4_ANADENOM",   cedeprest.ragione_sociale());
		} 
		// DatiSede
		tff0400f.set("P4_SEDEIND",      cedeprest.via_residenza());
		tff0400f.set("P4_SEDENRCIVICO", cedeprest.civico_residenza());
		tff0400f.set("P4_SEDECAP",      cedeprest.CAP_residenza());
		tff0400f.set("P4_SEDECOMUNE",   cedeprest.comune_residenza());
		tff0400f.set("P4_SEDEPROV",     cedeprest.provincia_residenza());
		tff0400f.set("P4_SEDENAZ",      statocli);
		tff0400f.set("P4_GESTIONE",     "D");
		ok = tff0400f.insert();
		
		// Controllo dopo l'inserimento del tff0400
		if(!ok) return false;

		TString rfso = strarr->get(_rfso);
		if(rfso.full())
		{
			TRectype r_ana = cache().get(LF_ANAG, TString(myrfso[0]) << rfso.sub(1));
			ok = tff3100(strarr, r_ana);
		}
		
		// E dopo l'inserimento del tff3100
		if(!ok) return false;
	}
	return ok;
}

bool TTrFa_app::tff0700(TSheet_field& sheet)
{

	/********************************************************************************************************************
		* Fattura																																																					*
		********************************************************************************************************************/
	// Mentre per i clienti <20> una porcata per le fatture non posso fare altrimenti, potrebbe essere che i clienti mettono righe in fondo customizzate spezzando fatture
	TToken_string fattSent = "";
	bool ok = true;
	TProgress_monitor p(sheet.items(), "Caricamento Fatture");

	TString oldKey = "";
	int numRiga;

	FOR_EACH_SHEET_ROW(sheet, r, strarr)
	{
		if(!p.add_status())
			return false;
		if(strcmp(strarr->get(_invio), "X") != 0)	continue; // Non mi interessa se non <20> selezionata

		TString checkFatt; checkFatt << strarr->get_char(_tipocf) << strarr->get_long(_codcf) <<  strarr->get(_numdoc);
		if(fattSent.get_pos(checkFatt) < 0)
		{	
			fattSent.add(checkFatt);
			
			// <DatiFatturaBody>
			TTrFa_record tff0700f("TFF0700F");
			tff0700f.set("P7_KEYPRGINVIO",		getKey(strarr));
			tff0700f.set("P7_KEYHEADERFATT",	getHeader(strarr));
			tff0700f.set("P7_KEYBODYFATT",		getBody(strarr));

			tff0700f.set("P7_TIPODOC",				decodTipo(strarr));
			tff0700f.set("P7_DATA",						toDate(strarr->get(_datadoc)));
			tff0700f.set("P7_NUMERO",					strarr->get(_numdoc));
			tff0700f.set("P7_DATAREG",				toDate(strarr->get(_datareg)));	// Obbligatoria nei DTR
			tff0700f.set("P7_GESTIONE",				"");
			ok = tff0700f.insert();

			// Controllo dopo l'inserimento del tff0700f
			if(!ok) return false;
		}
		// In qualsiasi caso va messa la riga ma prima elaboro il numero della riga!
		TString newKey = getBody(strarr, false);
		if(oldKey != newKey)
		{
			 numRiga = 1;
			 oldKey = newKey;
		}
		else
			numRiga++;
		ok = tff2200(strarr, numRiga);
		
		// E dopo l'inserimento del tff2200
		if(!ok) return false;
	}
	return ok;
}

bool TTrFa_app::tff2200(TToken_string* strarr, int nriga)
{
	TTrFa_record tff2200f("TFF2200F");
	tff2200f.set("PL_KEYPRGINVIO",		getKey(strarr));
	tff2200f.set("PL_KEYHEADERFATT",	getHeader(strarr));
	tff2200f.set("PL_KEYBODYFATT",		getBody(strarr, false));
	TString numriga; numriga.format("%020d", nriga);
	tff2200f.set("PL_KEYBODYDETT",		numriga);

	tff2200f.set("PL_IMPONIBILE",			real(strarr->get(_imponibile)));	// Se li converto in real una volta passati vengono parsati da var2str nel formato che vuole l'agenzia delle entrate
	tff2200f.set("PL_IMPOSTA",				real(strarr->get(_importoIVA)));
	tff2200f.set("PL_ALIQUOTAIVA",		strarr->get(_aliquota));
	tff2200f.set("PL_NATURA",					strarr->get(_natura));
	real det(strarr->get(_detraibile)); 
	// Nella conversione la vigola viene persa e 100,00 diventa 10.000 quindi divido 
	det /= CENTO;
	if(det > ZERO)
	{
		tff2200f.set("PL_DETRAIBILE",   det);
	}
	else if(false)	// Sempre disabilitato!
	{
		tff2200f.set("PL_DEDUCIBILE",   "SI");
	}

	tff2200f.set("PL_GESTIONE", "D");
	return tff2200f.insert();
}

bool TTrFa_app::tff3100(TToken_string* strarr, TRectype r_ana)
{
		TTrFa_record tff3100f("TFF3100F");
		tff3100f.set("PH_KEYPRGINVIO",		getKey(strarr));
		tff3100f.set("PH_KEYHEADERFATT",	getHeader(strarr));
		if(_append)
			tff3100f.remove();
			
		if(r_ana.get_char("TIPORFSO") == 'S') // Stabile Organizzazione
		{
			tff3100f.set("PH_STABORGIND",				r_ana.get("INDRES"));
			tff3100f.set("PH_STABORGNRCIVICO",	r_ana.get("CIVRES"));
			tff3100f.set("PH_STABORGCAP",				r_ana.get("CAPRES"));
			TRectype r_comune = cache().get(LF_COMUNI, TString("|") << r_ana.get("COMRES"));
			tff3100f.set("PH_STABORGCOMUNE",		r_comune.get("DENCOM"));
			tff3100f.set("PH_STABORGPROV",			r_comune.get("PROVCOM"));
			tff3100f.set("PH_STABORGNAZ",				"IT");
		}
		else // Rappresentante Fiscale
		{
			// La P.IVA del rappresentante fiscale deve essere in AT quindi non faccio alcun controllo, 
			// se il valore nullo perch<63> Extra CEE non <20> un errore di campo (Anche perch<63> che senso ha un RF extra CEE?)
			TString stato = r_ana.get("STATOPAIV") == "" ? "IT" : r_ana.get("STATOPAIV");
			tff3100f.set("PH_FISCIVAPAESE",			stato);
			tff3100f.set("PH_FISCIVACODICE",		r_ana.get("PAIV"));
					
			if(r_ana.get_char("TIPOA") == 'G')
			{
				tff3100f.set("PH_ANADENOMI",			r_ana.get("RAGSOC"));
			}
			else
			{
				TString nomCom = r_ana.get("RAGSOC");
				tff3100f.set("PH_ANANOME",				nomCom.sub(30));
				tff3100f.set("PH_ANACOGNOME",			nomCom.sub(0,30));
			}
		}
		tff3100f.set("PH_GESTIONE",						"D");
		return tff3100f.insert();
}

bool TTrFa_app::setEsportato(TSheet_field& sheet)
{
	bool ok = true;
	TProgress_monitor p(sheet.items(),"Segno l'esportazione sui records");
	FOR_EACH_SHEET_ROW(sheet, r, strarr)
	{
		if(!p.add_status())
			return false;
		if(strcmp(strarr->get(_invio), "X") != 0)	continue; // Non mi interessa se non <20> selezionata
		if(strcmp(strarr->get(_forzata), "X") == 0)
		{
			ok = saveRec(*strarr, true);
			if(!ok) return false;
		}
		else
		{
			TRectype row = cache().get(LF_RMOV, TString(strarr->get(_numero)));
			row.put("TFINVIO",		"X");
			row.put("TFDATA",			TDate(TODAY).string());
			ok = row.rewrite(TLocalisamfile(LF_RMOV)) == NOERR;
			if(!ok) return false;
		}
	}
	return ok;
}

void TTrFa_app::main_loop()
{
  TTrFa_mask msk("tf0100a");
	
  while (msk.run() == K_ENTER) 
  {
		if(msk.checkNotEmpty())
			send(&msk);
  }
}

bool TTrFa_app::destroy()
{
  if (_cofi.full())
    ini_set_string(CONFIG_DITTA, "pa", "TRASMITTCOD", _cofi);

  xvt_sql_close(_db); _db = NULL;
  return TSkeleton_application::destroy();
}

int tf0100(int argc, char* argv[])
{
  TTrFa_app t2t;
  t2t.run(argc, argv, TR("Trasferimento Fatture Elettroniche"));
  return 0;
}