#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <lffiles.h>
#include <prefix.h>
#include <progind.h>
#include <recarray.h>
#include <utility.h>
#include <textset.h>

#include "../cg/cglib01.h"
#include "../cg/cglib03.h"

#include "tc0.h"
#include "tc9300a.h"

#include <anagr.h>
#include <anafis.h>
#include <clifo.h>
#include <comuni.h>
#include <mov.h>
#include <nditte.h>
#include <rmov.h>
#include <rmoviva.h>
#include <multirel.h>

#define SLF_MOV "23" 
#define ALIAS_REG		100
#define REG_OFFSET 1000000L
#define GIRO_OFFSET 2000000L

///////////////////////////////////////////////////////////
// TRiclassifica_cache
///////////////////////////////////////////////////////////

class TRiclassifica_cache : public TCache
{
	TLocalisamfile _multirel;
protected:
  virtual TObject* key2obj(const char* key);
public:
	const char * sdecode(const char* tab, const TString& cod);
	long decode(const char* tab, const TString& cod);
	const TString & sdecode_caufor(const TString& cod);
	const TString & sdecode_caureg(const TString& cod);
	const TString & sdecode_caugiro(const TString& cod);
	const TString & sdecode_contov(const TString& cod);
	const TString & sdecode_caucon(const TString& cod);
	const TString & sdecode_sezcon(const TString& cod);
	bool sdecode_rc(const TString& cod);
	TRiclassifica_cache() : _multirel(LF_MULTIREL) { _multirel.setkey(2);}
};

TObject* TRiclassifica_cache::key2obj(const char* key)
{
	TToken_string tok(key);
	TString8 tab, cod;
	tok.get(0,tab);
	tok.get(1, cod);
	_multirel.setkey(1);
	_multirel.put(MULTI_COD, tab);
	_multirel.put(MULTI_FIRST, cod);
	_multirel.put(MULTI_SECOND, "");
	int err = _multirel.read(_isgteq);
	if (err == NOERR && _multirel.get(MULTI_FIRST) == cod)
		return new TString(_multirel.get(MULTI_SECOND));
	return NULL;
}

long TRiclassifica_cache::decode(const char* tab, const TString& cod)
{
	TToken_string tok;
	tok.add(tab);
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	return (ric ? atol(*ric) : 0);
}

const TString & TRiclassifica_cache::sdecode_caufor(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).sleft(5);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_caureg(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(6, 5);
	}
	return codricl;
}

bool TRiclassifica_cache::sdecode_rc(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(5, 1);
	}
	return codricl.full();
}

const TString & TRiclassifica_cache::sdecode_caugiro(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(11, 5);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_caucon(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(28, 5);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_sezcon(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(33, 1);
	}
	return codricl;
}

const TString & TRiclassifica_cache::sdecode_contov(const TString& cod)
{
  TString & codricl = get_tmp_string();
	TToken_string tok;

	tok.add("SCCAU");
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	if (ric && *ric)
	{
		_multirel.setkey(1);
		_multirel.put(MULTI_COD, "SCCAU");
		_multirel.put(MULTI_FIRST, cod);
		_multirel.put(MULTI_SECOND, *ric);
		int err = _multirel.read(_isequal);
		if (err == NOERR)
			codricl = _multirel.get(MULTI_DATA).smid(16, 12);
	}
	return codricl;
}

const char * TRiclassifica_cache::sdecode(const char* tab, const TString& cod)
{
	TToken_string tok;
	tok.add(tab);
	tok.add(cod);
	const TString* ric = (const TString*) objptr(tok);
	return ric ? (const char *) *ric : "";
}

class TMovim_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a', 
								 const char* def = NULL);

public:
  TMovim_set();
};

void TMovim_set::add_field(const char* name, int from, int len, 
														char tipo, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TMovim_set::TMovim_set() : TAS400_recordset("AS400(217)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ESIVA", -1, 2, _alfafld);
  create_field("ESCOGE", -1, 4, _alfafld);
  create_field("ARGOMENTO", -1, 1, _alfafld);
  create_field("COMPETENZA", -1, 1, _alfafld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 3, _longzerofld);
  create_field("DATAOP", -1, 6, _longzerofld);
  create_field("CODCONTO", -1, 12, _alfafld);
  create_field("TIPOREG", -1, 2, _longzerofld);
  create_field("CODREG", -1, 2, _longzerofld);
  create_field("NUMPROT", -1, 7, _longzerofld);
  create_field("TIPOART", -1, 1, _longzerofld);
  create_field("TIPOMOV", -1, 1, _alfafld);
  create_field("CODCOST", -1, 3, _longzerofld);
  create_field("CODCAUS", -1, 5, _longzerofld);
  create_field("NUMDESC", -1, 1, _longzerofld);
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("IMPORTO", -1, 13, _longzerofld);
  create_field("SGNCONTIMP", -1, 1, _alfafld);
  create_field("ANNOTAZ", -1, 30, _alfafld);
  create_field("DATADOC", -1, 6, _longzerofld);
  create_field("NUMDOC", -1, 7, _alfafld);
  create_field("TIPOANAG", -1, 1, _alfafld);
  create_field("FLGSTO", -1, 1, _alfafld);
  create_field("LIBERO", -1, 20, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld, true, "\r\n");
}

class TIvamov_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a', 
								 const char* def = NULL);

public:
  TIvamov_set();
};

void TIvamov_set::add_field(const char* name, int from, int len, 
														char tipo, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TIvamov_set::TIvamov_set() : TAS400_recordset("AS400(171)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 2, _longzerofld);
  create_field("SGNIMPB", -1, 1, _alfafld);
  create_field("IMPONIBILE", -1, 13, _longzerofld);
  create_field("SGNIMPIVA", -1, 1, _alfafld);
  create_field("IMPOSTA", -1, 13, _longzerofld);
  create_field("CODCAUS", -1, 5, _longzerofld);
  create_field("CODIVA", -1, 3, _alfafld);
  create_field("FILLER", -1, 2, _alfafld);
  create_field("MERCIVEN", -1, 1, _alfafld);
  create_field("QUADROA", -1, 1, _alfafld);
  create_field("CODCOSTRIC", -1, 6, _alfafld);
  create_field("FLGES", -1, 1, _alfafld);
  create_field("DETRAIB", -1, 5, _longzerofld);
  create_field("CODTABPRODAG", -1, 3, _alfafld);
  create_field("CODIVACOMPAG", -1, 3, _alfafld);
  create_field("DATAFATTSOSP", -1, 1, _alfafld);
  create_field("MULTIPUNTO", -1, 2, _alfafld);
  create_field("LIBERO", -1, 22, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}

class TIntramov_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a', 
								 const char* def = NULL);

public:
  TIntramov_set();
};

void TIntramov_set::add_field(const char* name, int from, int len, 
														char tipo, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TIntramov_set::TIntramov_set() : TAS400_recordset("AS400(206)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("TIPOREC", -1, 1, _alfafld);
  create_field("ESERCIZIO", -1, 4, _longzerofld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMPROG", -1, 2, _longzerofld); 
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("IMPORTO", -1, 13, _longzerofld);
  create_field("SGNVAL", -1, 1, _alfafld);
  create_field("IMPVAL", -1, 13, _longzerofld);
  create_field("TRANSAZ", -1, 1, _longzerofld);
  create_field("NOMENC", -1, 8, _longzerofld);
  create_field("MASSA", -1, 10, _longzerofld);
  create_field("UNIT", -1, 10, _longzerofld);
  create_field("SGNSTAT", -1, 1, _alfafld);
  create_field("IMPVAL", -1, 13, _longzerofld);
  create_field("RGMCONS", -1, 1, _alfafld);
  create_field("MODTRASP", -1, 1, _longzerofld);
  create_field("PAPROV", -1, 2, _alfafld);
  create_field("PADEST", -1, 2, _alfafld);
  create_field("PROVINCIA", -1, 2, _alfafld);
  create_field("MESE", -1, 2, _longzerofld);
  create_field("TRIMESTRE", -1, 1, _longzerofld);
  create_field("ANNO", -1, 1, _longzerofld);
  create_field("SGNATTRIB", -1, 1, _alfafld);
  create_field("ESIVA", -1, 2, _longzerofld);
  create_field("CODCLIFO", -1, 6, _alfafld);
  create_field("LIBERO", -1, 20, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld, true, "\r\n");
}

/* non li abbiamo i ratei
class TRateimov_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int len = 0, char tipo = 'a', 
								 int from = -1, const char* def = NULL);

public:
  TRateimov_set();
};

void TRateimov_set::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TRateimov_set::TRateimov_set() : TAS400_recordset("AS400(222)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ESCOGEIN", -1, 4, _longzerofld);
  create_field("ESCOGEFI", -1, 4, _longzerofld);
  create_field("NUMPART", -1, 7, _longzerofld); 
  create_field("NUMPROG", -1, 3, _longzerofld);
  create_field("INRATRIS", -1, 8, _longzerofld);
  create_field("FIRATRIS", -1, 8, _longzerofld);
  create_field("CODCPART", -1, 6, _alfafld);
  create_field("CODCCONT", -1, 6, _alfafld);
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("IMPORTO", -1, 13, _longzerofld);
  create_field("SGNCNIMPT", -1, 1, _alfafld);
  create_field("CODCLIFO", -1, 6, _alfafld);
  create_field("DATADOC", -1, 8, _longzerofld);
  create_field("NUMDOC", -1, 7, _alfafld);
  create_field("ANNOTAZ", -1, 30, _alfafld);
  create_field("DATAOP", -1, 8, _longzerofld);
  create_field("CCOSTO", -1, 3, _longzerofld);
  create_field("LIBERO", -1, 20, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
*/

class TForsisp_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a', 
								 const char* def = NULL);

public:
  TForsisp_set();
};

void TForsisp_set::add_field(const char* name, int from, int len, 
														char tipo, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TForsisp_set::TForsisp_set() : TAS400_recordset("AS400(304)")
{
  create_field("CODANAG", -1, 6, _alfafld);
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("TIPOANAG", -1, 1, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("INDIRIZZO", -1, 28, _alfafld);
  create_field("NUMERO", -1, 7, _alfafld); 
  create_field("COMUNE", -1, 35, _alfafld);
  create_field("CAP", -1, 5, _longzerofld);
  create_field("STATEST", -1, 35, _alfafld);
  create_field("TELEFONO", -1, 20, _alfafld);
  create_field("TELEFAX", -1, 20, _alfafld);
  create_field("TELEX", -1, 20, _alfafld);
  create_field("PREFISSO", -1, 4, _alfafld);
  create_field("FRAZIONE", -1, 35, _alfafld);
  create_field("PROVINCIA", -1, 2, _alfafld);
  create_field("TESTAZMUN", -1, 1, _alfafld);
  create_field("CODCOM", -1, 4, _alfafld);
  create_field("CODFRAZ", -1, 2, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}

class TClisisp_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int from = -1, int len = 0, char tipo = 'a', 
								 const char* def = NULL);

public:
  TClisisp_set();
};

void TClisisp_set::add_field(const char* name, int from, int len, 
														char tipo, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TClisisp_set::TClisisp_set() : TAS400_recordset("AS400(304)")
{
  create_field("CODANAG", -1, 6, _alfafld);
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("TIPOANAG", -1, 1, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("INDIRIZZO", -1, 28, _alfafld);
  create_field("NUMERO", -1, 7, _alfafld); 
  create_field("COMUNE", -1, 35, _alfafld);
  create_field("CAP", -1, 5, _longzerofld);
  create_field("STATEST", -1, 35, _alfafld);
  create_field("TELEFONO", -1, 20, _alfafld);
  create_field("TELEFAX", -1, 20, _alfafld);
  create_field("TELEX", -1, 20, _alfafld);
  create_field("PREFISSO", -1, 4, _alfafld);
  create_field("FRAZIONE", -1, 35, _alfafld);
  create_field("PROVINCIA", -1, 2, _alfafld);
  create_field("TESTAZMUN", -1, 1, _alfafld);
  create_field("CODCOM", -1, 4, _alfafld);
  create_field("CODFRAZ", -1, 2, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}

/*
class TMovplus_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int len = 0, char tipo = 'a', 
								 int from = -1, const char* def = NULL);

public:
  TMovplus_set();
};

void TMovplus_set::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TMovplus_set::TMovplus_set() 
             : TAS400_recordset("AS400(200)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ARGOMENTO", -1, 1, _alfafld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 3, _longzerofld);
  create_field("PROMEM", -1, 50, _alfafld);
  create_field("NOTEVAR", -1, 1, _alfafld);
  create_field("CODANCOIN", -1, 6, _alfafld);
  create_field("TIPOCOIN", -1, 1, _alfafld);
  create_field("PRIPCOIN", -1, 5, _longzerofld);
  create_field("LIBERO", -1, 47, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
*/

class TMovpart_set : public TAS400_recordset
{
protected:
  void add_field(const char* name = "Filler", int len = 0, char tipo = 'a', 
								 int from = -1, const char* def = NULL);

public:
  TMovpart_set();
};

void TMovpart_set::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TMovpart_set::TMovpart_set() : TAS400_recordset("AS400(322)")
{
  create_field("COFI", -1, 16, _alfafld);
  create_field("PAIV", -1, 11, _alfafld);
  create_field("RAGSOC", -1, 50, _alfafld);
  create_field("ARGOMENTO", -1, 1, _longzerofld);
  create_field("NUMPART", -1, 7, _longzerofld);
  create_field("NUMINT", -1, 3, _longzerofld);
  create_field("DATAOP", -1, 8, _longzerofld);
  create_field("CODSCONT", -1, 6, _alfafld);
  create_field("CODCLIFO", -1, 6, _alfafld);
  create_field("TIPOREG", -1, 2, _longzerofld);
  create_field("CODREG", -1, 2, _longzerofld);
  create_field("ANNODOC", -1, 4, _longzerofld);
  create_field("NUMDOC", -1, 7, _alfafld);
  create_field("NUMPROT", -1, 7, _longzerofld);
  create_field("DATADOC", -1, 8, _longzerofld);
  create_field("ANNOPAG", -1, 4, _longzerofld);
  create_field("TIPOMOV", -1, 1, _alfafld);
  create_field("CODCAUS", -1, 5, _longzerofld);
  create_field("CODPAG", -1, 6, _alfafld);
  create_field("DATASCAD", -1, 8, _longzerofld);
  create_field("IMPTMOV", -1, 12, _longzerofld);
  create_field("SGNIMPT", -1, 1, _alfafld);
  create_field("CODAG", -1, 3, _alfafld);
  create_field("CODVALEST", -1, 3, _alfafld);
  create_field("CAMBIO", -1, 9, _longzerofld);
  create_field("CODABICF", -1, 5, _longzerofld);
  create_field("CODCABCF", -1, 5, _longzerofld);
  create_field("CODABIAZ", -1, 5, _longzerofld);
  create_field("CODCABAZ", -1, 5, _longzerofld);
  create_field("NUMDOC2", -1, 7, _alfafld);
  create_field("NUMPROT2", -1, 7, _longzerofld);
  create_field("DATADOC2", -1, 8, _longzerofld);
  create_field("ANNOTAZ", -1, 30, _alfafld);
  create_field("TIPOPAG", -1, 1, _longzerofld);
  create_field("DTNEWSCAD", -1, 8, _longzerofld);
  create_field("IMPTSP", -1, 12, _longzerofld);
  create_field("CONTUNI", -1, 8, _longzerofld);
  create_field("IMPTIVA", -1, 12, _longzerofld);
  create_field("TIPOANAG", -1, 1, _alfafld);
  create_field("TIPOVAL", -1, 1, _alfafld);
  create_field("LIBERO", -1, 15, _alfafld);
  create_field("FINEREC", -1, 2, _alfafld,true,"\r\n");
}
 
class TInvioSispac_mask : public TAutomask
{
protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:

  TInvioSispac_mask();
  
  virtual ~TInvioSispac_mask(){};
};
  
TInvioSispac_mask::TInvioSispac_mask() :TAutomask ("tc9300a")
{
}  
  
bool TInvioSispac_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
	switch (o.dlg())
	{
	case F_CODDITTA:                               
		if (e==fe_init && o.empty())
		{
			set(F_CODDITTA, main_app().get_firm());
			((TEdit_field&) o).check();
			disable(F_CODDITTA);
		}	
		break;
	default:
		break;	
	}
  return TRUE;
}

class TInvioSispac : public TSkeleton_application
{                     
	TCursor*				   _cur;
  TInvioSispac_mask* 		 _msk;
	TConfig*					 _configfile;
  TDate							 _dataini, _datafin;
	TRiclassifica_cache *  _tabelle;

  
protected:
  virtual bool create(void);
  virtual bool destroy(void);
  virtual void main_loop() ;
  void invio_sispac();
  void sispac_cli();
  void sispac_for();
	void sispac_reverse_movim(long numreg, TMovim_set & recset, long firstmov, long lastmov,
														const TString & cofi, const TString & paiv,
														const TString & ragsoc, const TString & esiva,
														const TString &	annoes, bool comp);
	void sispac_reverse_giro(long numreg, TMovim_set & recset, long firstmov, long lastmov,
													 const TString & cofi, const TString & paiv,
													 const TString & ragsoc, const TString & esiva,
												   const TString &	annoes, bool comp);
  void sispac_movim();
	void sispac_reverse_moviva(long numreg, TIvamov_set & recset, const TString & cofi,
														 const TString & paiv, const TString & ragsoc);
  void sispac_moviva();
  void sispac_intramov();
	void sispac_movpart();
	void conferma(bool conf = true);
	const TString & scod2ricl(const char* tab, const TString& cod);
	const TString & scod2caucf(const TString& cod);
	const TString & scod2ricl(const char* tab, const TVariant& cod);
	const TString & scod2caureg(const TString& cod);
	const TString & scod2caugiro(const TString& cod);
	const TString & scod2caucon(const TString& cod);
	const TString & scod2sezcon(const TString& cod);
	const TString & scod2contov(const TString& cod);
	bool scod2rc(const TString& cod);
	const long cod2ricl(const char* tab, const TString& cod);

public:
	TConfig& config() {return *_configfile;};
  TInvioSispac() {} ;
  virtual ~TInvioSispac() {} ;
};  

// restituisce un riferimento all' applicazione
inline TInvioSispac& app() { return (TInvioSispac&) main_app();}

const TString & TInvioSispac::scod2ricl(const char* tab, const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
	{
		codricl = _tabelle->sdecode(tab, cod);
		if (codricl.blank())
			codricl = cod;
	}
  return codricl;
}
const TString & TInvioSispac::scod2caucf(const TString& cod)
{
	if (cod.full())
	 return _tabelle->sdecode_caufor(cod);
  return EMPTY_STRING;
}

const TString & TInvioSispac::scod2caureg(const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
		codricl = _tabelle->sdecode_caureg(cod);
  return codricl;
}

const TString & TInvioSispac::scod2caugiro(const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
		codricl = _tabelle->sdecode_caugiro(cod);
  return codricl;
}

const TString & TInvioSispac::scod2caucon(const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
		codricl = _tabelle->sdecode_caucon(cod);
  return codricl;
}


const TString & TInvioSispac::scod2sezcon(const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
		codricl = _tabelle->sdecode_sezcon(cod);
  return codricl;
}


const TString & TInvioSispac::scod2contov(const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
		codricl = _tabelle->sdecode_contov(cod);
  return codricl;
}

bool TInvioSispac::scod2rc(const TString& cod)
{
  TString & codricl = get_tmp_string();

	if (cod.full())
		return _tabelle->sdecode_rc(cod);
  return false;
}

const TString & TInvioSispac::scod2ricl(const char* tab, const TVariant& cod)
{
	return scod2ricl(tab, cod.as_string());
}

const long TInvioSispac::cod2ricl(const char* tab, const TString& cod)
{
  long codricl = 0;
	if (cod.full())
	{
		codricl = _tabelle->decode(tab, cod);
		if (codricl <= 0 &&	real::is_natural(cod))
			codricl = atol(cod);
	}
  return codricl;
}

void TInvioSispac::sispac_cli()
{
	TClisisp_set recset;
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF
				<< "\nFROM " << CLI_TIPOCF << "=C"
				<< "\nTO " << CLI_TIPOCF << "=C";

	TISAM_recordset input(query);
	TVariant var;
	TString fcomname;

	fcomname << LF_COMUNI << "." << COM_DENCOM;

	TProgind p(input.items(), TR("Esportazione Clienti"), true, true);

  for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		recset.new_rec();
		
		const long codcli = input.get(CLI_CODCF).as_int();
		
		var = format("%06d", codcli);
		recset.set("CODANAG", var);
		recset.set("COFI", input.get(CLI_COFI));
		recset.set("PAIV", input.get(CLI_PAIV));

		const int cflen = input.get(CLI_COFI).as_string().len();
		const int pilen = input.get(CLI_PAIV).as_string().len();

		if (cflen  > 11)
			var = "F";
		else
			if (cflen == 0 && pilen == 0)
				var = "P";
			else
				var = "D";
		recset.set("TIPOANAG", var);
		recset.set("RAGSOC", input.get(CLI_RAGSOC));
		recset.set("INDIRIZZO", input.get(CLI_INDCF));
		recset.set("NUMERO", input.get(CLI_CIVCF)); 
		TString loc(input.get(CLI_LOCCF).as_string());
		TString comune(input.get(fcomname).as_string());

		if (comune.full())
		{
			if (loc.full())
				loc << " - ";
			loc << comune;
		}
		var = comune;
		recset.set("COMUNE", var);
		recset.set("CAP", input.get(CLI_CAPCF));
		recset.set("FINEREC", "\r\n");
		p.addstatus(1L);;
		if (p.iscancelled())
			break;

  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/clisisp";
	recset.save_as(outputname);
}

void TInvioSispac::sispac_for()
{
	TForsisp_set recset;
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF
				<< "\nFROM " << CLI_TIPOCF << "=F"
				<< "\nTO " << CLI_TIPOCF << "=F";

	TISAM_recordset input(query);
	TVariant var;
	TString fcomname;

	fcomname << LF_COMUNI << "." << COM_DENCOM;

	TProgind p(input.items(), TR("Esportazione Fornitori"), true, true);

  for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		recset.new_rec();
		const long codfor = input.get(CLI_CODCF).as_int();
		
		var = format("%06d", codfor);
		recset.set("CODANAG", var);
		recset.set("COFI", input.get(CLI_COFI));
		recset.set("PAIV", input.get(CLI_PAIV));

		const int cflen = input.get(CLI_COFI).as_string().len();
		const int pilen = input.get(CLI_PAIV).as_string().len();

		if (cflen  > 11)
			var = "F";
		else
			if (cflen == 0 && pilen == 0)
				var = "P";
			else
				var = "D";
		recset.set("TIPOANAG", var);
		recset.set("RAGSOC", input.get(CLI_RAGSOC));
		recset.set("INDIRIZZO", input.get(CLI_INDCF));
		recset.set("NUMERO", input.get(CLI_CIVCF)); 
		TString loc(input.get(CLI_LOCCF).as_string());
		TString comune(input.get(fcomname).as_string());

		if (comune.full())
		{
			if (loc.full())
				loc << " - ";
			loc << comune;
		}
		var = comune;
		recset.set("COMUNE", var);
		recset.set("CAP", input.get(CLI_CAPCF));
		recset.set("FINEREC", "\r\n");
		p.addstatus(1L);;
		if (p.iscancelled())
			break;
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/forsisp";
	recset.save_as(outputname);
}

void TInvioSispac::sispac_reverse_movim(long numreg, TMovim_set & recset, long firstmov, long lastmov,
																				const TString & cofi, const TString & paiv,
																				const TString & ragsoc, const TString & esiva,
																				const TString &	annoes, bool comp)
{
	TString query;
	TString key;

	query << "USE " << LF_RMOV << " SELECT " <<  RMV_NUMREG << "==" << numreg 
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	TVariant treg;
	TVariant tpart;
	TArray tipoart;
	int rdare = 0;
	int ravere = 0;

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long codes = input.get(RMV_ANNOES).as_int();
		const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
		
		if (rowtype == "F")
			continue;
		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = esiva;
		recset.set("ESIVA", var);
		var = annoes;
		recset.set("ESCOGE", var);

		var = "V";
		treg = "03";
		recset.set("ARGOMENTO", var);
		var = "N";

		const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());

		if (comp)
			var = "1";
		recset.set("COMPETENZA", var);
		var = format("%07ld", input.get(RMV_NUMREG).as_int() + REG_OFFSET);
	  recset.set("NUMPART", var);
		var = format("%03ld", input.get(RMV_NUMRIG).as_int());
	  recset.set("NUMINT", var);
	  recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
		TString16 codice;
		long gruppo = input.get(RMV_GRUPPO).as_int();
		const long conto =	 input.get(RMV_CONTO).as_int();
		const long sottoconto =	input.get(RMV_SOTTOCONTO).as_int();
		TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 

		if (gruppo == 10)
			gruppo = 0;

		if (rowtype == "I") // verificare
			codice = scod2contov(ccaus);
		else
			if (input.get(RMV_TIPOC).as_string().full())
				codice.format("%01ld%02ld000%06ld", gruppo, conto, sottoconto);
			else
				codice.format("%01ld%02ld%03ld000000", gruppo, conto, sottoconto);
		var = codice;
		recset.set("CODCONTO", var);
		recset.set("TIPOREG", treg);
	  recset.set("CODREG", TVariant("01")); // in futuro campo su registro
		const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
		var = format("%07ld", prot);
	  recset.set("NUMPROT", var);
		const real  * v = (real *) tipoart.objptr(lastmov - firstmov); // qui

		if (v != NULL)
			recset.set("TIPOART", *v);

		TString8 codcaus = scod2caureg(ccaus);
		
		if (input.get(RMV_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = "R";
		if (codcaus == "00255")
			var = "S";
		recset.set("TIPOMOV", var);
		recset.set("CODCOST", TVariant("000"));
		var = codcaus;
		recset.set("CODCAUS", var);

		recset.set("NUMDESC", TVariant("0"));

		real importo = input.get(RMV_IMPORTO).as_real();

		if (rowtype == "T")
			importo += input.get(SLF_MOV "." MOV_RITFIS).as_real();
		var = "P";
		if (importo < ZERO)
		{
			importo = -importo;
			var = "N";
		}

		recset.set("SGNIMPT", var);
		importo *= CENTO;
		var = importo.string(13, 0, '0');
		recset.set("IMPORTO", var);
		const bool dare = input.get(RMV_SEZIONE).as_string() == "D";
		const char * s = dare ? "A" : "D";
		
		recset.set("SGNCONTIMP",  s);
		const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
		var = datadoc.string(brief, '\0', full, full, amg_date);
		recset.set("DATADOC", var);
		recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());

		const long codcf = input.get(SLF_MOV "." MOV_CODCF).as_int();

		var = "";
		if (codcf > 0L)
		{
			key = "C" ; key << "|" << codcf;
			const TRectype & clifo = cache().get(LF_CLIFO, key);
			const int cflen = clifo.get(CLI_COFI).len();

			if (cflen  > 11)
				var = "2";
		}
		recset.set("TIPOANAG", var);
		recset.set("FINEREC", "\r\n");
  }	
}

void TInvioSispac::sispac_reverse_giro(long numreg, TMovim_set & recset, long firstmov, long lastmov,
																			 const TString & cofi, const TString & paiv,
																			 const TString & ragsoc, const TString & esiva,
																		   const TString &	annoes, bool comp)
{
	TString query;
	TString key;

	query << "USE " << LF_RMOV << " SELECT " <<  RMV_NUMREG << "==" << numreg 
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	TVariant treg;
	TString codice_cf;
	TVariant tpart;
	TArray tipoart;
	int rdare = 0;
	int ravere = 0;

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long codes = input.get(RMV_ANNOES).as_int();
		const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
		
		if (rowtype == "F")
			continue;

		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = esiva;
		recset.set("ESIVA", var);
		var = annoes;
		recset.set("ESCOGE", var);

		var = "P";
		treg = "01";
		recset.set("ARGOMENTO", var);
		var = "N";

		const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());

		if (comp)
			var = "1";
		recset.set("COMPETENZA", var);
		var = format("%07ld", input.get(RMV_NUMREG).as_int() + GIRO_OFFSET);
	  recset.set("NUMPART", var);
		var = format("%03ld", input.get(RMV_NUMRIG).as_int());
	  recset.set("NUMINT", var);
	  recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
		TString16 codice;
		long gruppo = input.get(RMV_GRUPPO).as_int();
		const long conto =	 input.get(RMV_CONTO).as_int();
		const long sottoconto =	input.get(RMV_SOTTOCONTO).as_int();
		TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 

		if (gruppo == 10)
			gruppo = 0;
		
		if (rowtype == "I") // verificare
			codice = scod2contov(ccaus);
		else
			if (rowtype == "D" || rowtype == "N") // verificare
				codice = codice_cf;
			else
				if (input.get(RMV_TIPOC).as_string().full())
				{
					codice.format("%01ld%02ld000%06ld", gruppo, conto, sottoconto);
					codice_cf = codice;
				}
				else
					codice.format("%01ld%02ld%03ld000000", gruppo, conto, sottoconto);
		var = codice;
		recset.set("CODCONTO", var);
		recset.set("TIPOREG", treg);
	  recset.set("CODREG", TVariant("01")); // in futuro campo su registro
		const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
		var = format("%07ld", prot);
	  recset.set("NUMPROT", var);
		const real  * v = (real *) tipoart.objptr(lastmov - firstmov); // qui

		if (v != NULL)
			recset.set("TIPOART", *v);

		TString8 codcaus = scod2caugiro(ccaus);
		
		if (input.get(RMV_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = "R";
		if (codcaus == "00255")
			var = "S";
		recset.set("TIPOMOV", var);
		recset.set("CODCOST", TVariant("000"));
		var = codcaus;
		recset.set("CODCAUS", var);

		recset.set("NUMDESC", TVariant("0"));

		real importo = input.get(RMV_IMPORTO).as_real();

		if (rowtype == "T")
			importo += input.get(SLF_MOV "." MOV_RITFIS).as_real();
		var = "P";
		if (importo < ZERO)
		{
			importo = -importo;
			var = "N";
		}

		recset.set("SGNIMPT", var);
		importo *= CENTO;
		var = importo.string(13, 0, '0');
		recset.set("IMPORTO", var);
		recset.set("SGNCONTIMP", input.get(RMV_SEZIONE));
		const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
		var = datadoc.string(brief, '\0', full, full, amg_date);
		recset.set("DATADOC", var);
		recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());

		const long codcf = input.get(SLF_MOV "." MOV_CODCF).as_int();

		var = "";
		if (codcf > 0L)
		{
			key = "F" ; key << "|" << codcf;
			const TRectype & clifo = cache().get(LF_CLIFO, key);
			const int cflen = clifo.get(CLI_COFI).len();

			if (cflen  > 11)
				var = "2";
		}
		recset.set("TIPOANAG", var);
		recset.set("FINEREC", "\r\n");
  }	
}


void TInvioSispac::sispac_movim()
{
	TMovim_set recset;
	TString query;
	TString key;
	TEsercizi_contabili esc;
	long numregrev = -1L;

	key << prefix().get_codditta();

	const TRectype & ditta = cache().get(LF_NDITTE, key);
	
	key = ditta.get(NDT_TIPOA);
	key << "|" <<ditta.get_long(NDT_CODANAGR);

	const TRectype & anagr = cache().get(LF_ANAG, key);

	const TString16 paiv(anagr.get(ANA_PAIV));
	const TString16 cofi(anagr.get(ANA_COFI));
	const TString80 ragsoc(anagr.get(ANA_RAGSOC));
	TString4 esiva; esiva.format("%02d", _dataini.year() % 100) ;
	TString4 annoes; annoes << esiva << esiva ;

	query << "USE " << LF_RMOV << " SELECT BETWEEN(" <<  LF_MOV << "." << MOV_DATAREG << "," << _dataini.date2ansi() << "," << _datafin.date2ansi() << ")&&("
		    << LF_MOV << "." << MOV_INVIATO << "!=\"X\")"
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	TVariant treg;
	TVariant tpart;
	TArray tipoart;
	long lastmov = -1;
	long firstmov = -1;
	int rdare = 0;
	int ravere = 0;

	TProgind p(input.items() * 2, TR("Esportazione Movimenti"), true, true);

  for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		long nmov =input.get(RMV_NUMREG).as_int();
		TString4 sezione(input.get(RMV_SEZIONE).as_string());

		if (nmov != lastmov)
		{
			if (firstmov < 0)
				firstmov = nmov;
			if (lastmov > 0)
			{
				real v = ZERO;
				
				if (rdare == 1 && ravere > 1)
					v = UNO;
				else
				if (rdare > 1 && ravere == 1)
					v = 2.00;
				else
					if (rdare > 1 && ravere > 1)
						v = 3.00;
				tipoart.add(v, lastmov - firstmov);
			}
			lastmov = nmov;
			rdare = 0;
			ravere = 0;
		}
		if (sezione == "D")
			rdare++;
		else
			ravere++;
		p.addstatus(1L);;
		if (p.iscancelled())
			break;
	}
	if (lastmov > 0)
	{
		real v = ZERO;
		
		if (rdare == 1 && ravere > 1)
			v = UNO;
		else
		if (rdare > 1 && ravere == 1)
			v = 2.00;
		else
			if (rdare > 1 && ravere > 1)
				v = 3.00;
		tipoart.add(v, lastmov - firstmov);
	}

	lastmov = 0;
	int nrow = 0;
	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const long codes = input.get(RMV_ANNOES).as_int();
		const TString4 rowtype = input.get(RMV_ROWTYPE).as_string();
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 
		const long numreg = input.get(RMV_NUMREG).as_int();
		const TDate datareg(input.get(SLF_MOV "." MOV_DATAREG).as_date());
		const bool comp = codes  != esc.date2esc(datareg);
		TString4 sezione(input.get(RMV_SEZIONE).as_string());

		if (numreg != lastmov)
		{
			lastmov = numreg;
			nrow = 0;
		}
		if (numregrev < 0L && scod2rc(ccaus))
			numregrev = numreg;
		if (rowtype == "F")
			continue;
		if (numregrev > 0L && numreg != numregrev)
		{
			sispac_reverse_movim(numregrev, recset, firstmov, lastmov, cofi, paiv, ragsoc, esiva, annoes, comp);
			sispac_reverse_giro(numregrev, recset, firstmov, lastmov, cofi, paiv, ragsoc, esiva, annoes, comp);
			numregrev = -1L;
		}
		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = esiva;
		recset.set("ESIVA", var);
		var = annoes;
		recset.set("ESCOGE", var);
		const TString & reg = input.get(SLF_MOV "." MOV_REG).as_string();
		
		if (reg.blank())
		{
			var = "P";
			treg = "01";
		}
		else
		{
			TRegistro r(reg, input.get(SLF_MOV "." MOV_ANNOIVA).as_int());
			switch (r.iva())
			{
				case iva_vendite :
					if (r.corrispettivi())
					{
						var = "S";
						treg = "04";
					}
					else
					{
						var = "V";
						treg = "03";
					}
					break;
				case iva_acquisti :
					var = "A";
					treg = "02";
					break;
				default:
					var = "";
			treg = "01";
					break;
			}
		}
		const TString4 tipomov = var.as_string();
		recset.set("ARGOMENTO", var);
		var = "N";
		if (comp)
			var = "1";
		recset.set("COMPETENZA", var);
		var = format("%07ld", numreg);
	  recset.set("NUMPART", var);
		var = format("%03ld", ++nrow);
	  recset.set("NUMINT", var);
	  recset.set("DATAOP", datareg.string(brief, '\0', full, full, amg_date));
		TString16 codice;
		long gruppo = input.get(RMV_GRUPPO).as_int();
		const long conto =	 input.get(RMV_CONTO).as_int();
		const long sottoconto =	input.get(RMV_SOTTOCONTO).as_int();

		if (gruppo == 10)
			gruppo = 0;

		if (input.get(RMV_TIPOC).as_string().full())
			codice.format("%01ld%02ld000%06ld", gruppo, conto, sottoconto);
		else
			codice.format("%01ld%02ld%03ld000000", gruppo, conto, sottoconto);
		var = codice;
		recset.set("CODCONTO", var);
		recset.set("TIPOREG", treg);
	  recset.set("CODREG", TVariant("01")); // in futuro campo su registro
		const long prot = input.get(SLF_MOV "." MOV_PROTIVA).as_int();
		var = format("%07ld", prot);
	  recset.set("NUMPROT", var);
		const real  * v = (real *) tipoart.objptr(lastmov - firstmov); // qui

		if (v != NULL)
			recset.set("TIPOART", *v);

		TString8 codcaus = scod2ricl("SCCAU", ccaus); 
		const TString4 tipocf = input.get(RMV_TIPOC).as_string();
		const TString8 codcauscf = scod2caucf(ccaus);
		const TString8 codcauscon = scod2caucon(ccaus);
		const TString4 sezcon = scod2sezcon(ccaus);
		
		if (tipocf == "C" || tipocf == "F")
		{
			if (codcauscf.full())
				codcaus = codcauscf;
			else
				if (sezcon == sezione && codcauscon.full())
					codcaus = codcauscon;
		}
		else
			if (sezcon == sezione && codcauscon.full())
				codcaus = codcauscon;
		var = "R";
		if (codcaus == "00255")
			var = "S";
		recset.set("TIPOMOV", var);
		recset.set("CODCOST", TVariant("000"));
		var = codcaus;
		recset.set("CODCAUS", var);

		recset.set("NUMDESC", TVariant("0"));

		real importo = input.get(RMV_IMPORTO).as_real();
		real ritenute = input.get(SLF_MOV "." MOV_RITFIS).as_real();
		if (ritenute != ZERO && rowtype == "T")
			importo += ritenute;

		var = "P";
		if (importo < ZERO)
		{
			importo = -importo;
			var = "N";
		}

		recset.set("SGNIMPT", var);
		importo *= CENTO;
		var = importo.string(13, 0, '0');
		recset.set("IMPORTO", var);
		recset.set("SGNCONTIMP", input.get(RMV_SEZIONE));
		const TDate datadoc(input.get(SLF_MOV "." MOV_DATADOC).as_date());
		var = datadoc.string(brief, '\0', full, full, amg_date);
		recset.set("DATADOC", var);
		recset.set("NUMDOC", input.get(SLF_MOV "." MOV_NUMDOC).as_int());

		const long codcf = input.get(SLF_MOV "." MOV_CODCF).as_int();

		var = "";
		if (codcf > 0L)
		{
			key = tipomov == "A" ? "F" : "C" ; key << "|" << codcf;
			const TRectype & clifo = cache().get(LF_CLIFO, key);
			const int cflen = clifo.get(CLI_COFI).len();

			if (cflen  > 11)
				var = "2";
		}

		recset.set("TIPOANAG", var);
		recset.set("FINEREC", "\r\n");
		p.addstatus(1L);;
		if (p.iscancelled())
			break;
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/movim";
	recset.save_as(outputname);
}

void TInvioSispac::sispac_reverse_moviva(long numreg, TIvamov_set & recset, const TString & cofi,
																				 const TString & paiv, const TString & ragsoc)
{
	TString query;
	TString key;

	query << "USE " << LF_RMOVIVA << " SELECT " << RMV_NUMREG << "==" << numreg <<
				"\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = format("%07ld", input.get(RMI_NUMREG).as_int() + REG_OFFSET);
	  recset.set("NUMPART", var);
		var = format("%03ld", input.get(RMI_NUMRIG).as_int());
	  recset.set("NUMINT", var);
		
		real imponibile = input.get(RMI_IMPONIBILE).as_real();

		var = "P";
		if (imponibile < ZERO)
		{
			imponibile = -imponibile;
			var = "N";
		}

		recset.set("SGNIMPB", var);
		imponibile *= CENTO;
		var = imponibile.string(13, 0, '0');
		recset.set("IMPONIBILE", var);

		real imposta = input.get(RMI_IMPOSTA).as_real();

		var = "P";
		if (imposta < ZERO)
		{
			imposta = -imposta;
			var = "N";
		}

		recset.set("SGNIMPIVA", var);
		imposta *= CENTO;
		var = imposta.string(13, 0, '0');
		recset.set("IMPOSTA", var);
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 
		TString8 codcaus = scod2caureg(ccaus); 
		
		if (input.get(RMI_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = codcaus;
		recset.set("CODCAUS", var);

		const TString8 civa(input.get(RMI_CODIVA).as_string()); 
		TString8 codiva = scod2ricl("SCIVA", civa); 

		var = codiva;
		recset.set("CODIVA", var);
		recset.set("FILLER", TVariant("00"));
		TVariant var1("M");

		var = "";
		if (codcaus == "00100")
		{
			var = "S";
			var1 = "S";
		}
		else
			if (codcaus == "00110")
			{
				var = "N";
				var1 = "N";
			}
			else
				if (codcaus == "00200" ||	codcaus == "00220" ||
						codcaus == "00255" ||	codcaus == "00301")
					var1 ="M";

 		recset.set("MERCIVEN", var1);
		recset.set("QUADROA", var);
		int tipodet;
		TCausale cau(ccaus, _dataini.year());
		const real percdetr = (CENTO - indetraibile_al(input.get(RMI_TIPODET).as_string(), cau, _dataini.year(), tipodet)) * CENTO;

		var = percdetr.string(5, 0, '0');
		recset.set("DETRAIB", percdetr);
		recset.set("FINEREC", "\r\n");
	}
}

  void TInvioSispac::sispac_moviva()
{
	TIvamov_set recset;
	TString query;
	TString key;
	TEsercizi_contabili esc;
	long numregrev = -1L;

	key << prefix().get_codditta();

	const TRectype & ditta = cache().get(LF_NDITTE, key);
	
	key = ditta.get(NDT_TIPOA);
	key << "|" <<ditta.get_long(NDT_CODANAGR);

	const TRectype & anagr = cache().get(LF_ANAG, key);

	const TString16 paiv(anagr.get(ANA_PAIV));
	const TString16 cofi(anagr.get(ANA_COFI));
	const TString80 ragsoc(anagr.get(ANA_RAGSOC));
	const int esiva = _dataini.year() % 100 ;
	TString4 annoes; annoes << esiva << esiva ;

	query << "USE " << LF_RMOVIVA << " SELECT BETWEEN(" <<  LF_MOV << "." << MOV_DATAREG << "," << _dataini.date2ansi() << "," << _datafin.date2ansi() << ")&&("
		    << LF_MOV << "." << MOV_INVIATO << "!=\"X\")"
				<< "\nJOIN " << LF_MOV << " INTO " << MOV_NUMREG << "==" << RMV_NUMREG;

	TISAM_recordset input(query);
	TVariant var;
	int lastmov = 0;
	int nrow = 0;

	TProgind p(input.items(), TR("Esportazione Movimenti IVA"), true, true); // qui

	for (bool ok = input.move_first(); ok ; ok = input.move_next())
  {
		const TString8 ccaus(input.get(SLF_MOV "." MOV_CODCAUS).as_string()); 
		const long numreg = input.get(RMI_NUMREG).as_int();

		if (numreg != lastmov)
		{
			lastmov = numreg;
			nrow = 0;
		}
		TString16 key;

		key << numreg <<"|1";
		if (cache().get(LF_RMOV, key).empty())
			continue;

		if (scod2rc(ccaus))
			numregrev = numreg;
		if (numregrev > 0L && numreg != numregrev)
		{
			sispac_reverse_moviva(numregrev, recset, cofi, paiv, ragsoc);
			numregrev = -1L;
		}
		recset.new_rec();
		var = cofi;
		recset.set("COFI", var);
		var = paiv;
		recset.set("PAIV", var);
		var = ragsoc;
		recset.set("RAGSOC", var);
		var = format("%07ld", numreg);
	  recset.set("NUMPART", var);
		var = format("%03ld", ++nrow);
	  recset.set("NUMINT", var);
		
		real imponibile = input.get(RMI_IMPONIBILE).as_real();

		var = "P";
		if (imponibile < ZERO)
		{
			imponibile = -imponibile;
			var = "N";
		}

		recset.set("SGNIMPB", var);
		imponibile *= CENTO;
		var = imponibile.string(13, 0, '0');
		recset.set("IMPONIBILE", var);

		real imposta = input.get(RMI_IMPOSTA).as_real();

		var = "P";
		if (imposta < ZERO)
		{
			imposta = -imposta;
			var = "N";
		}

		recset.set("SGNIMPIVA", var);
		imposta *= CENTO;
		var = imposta.string(13, 0, '0');
		recset.set("IMPOSTA", var);
		TString8 codcaus = scod2ricl("SCCAU", ccaus); 
		
		if (input.get(RMI_TIPOC).as_string().full())
		{
			const TString8 codcauscf = scod2caucf(ccaus);
			if (codcauscf.full())
				codcaus = codcauscf;
		}
		var = codcaus;
		recset.set("CODCAUS", var);

		const TString8 civa(input.get(RMI_CODIVA).as_string()); 
		TString8 codiva = scod2ricl("SCIVA", civa); 

		var = codiva;
		recset.set("CODIVA", var);
		recset.set("FILLER", TVariant("00"));
		TVariant var1("N");
		TString8 codreg(input.get(SLF_MOV "." MOV_REG).as_string());

		if (codreg.full())
		{
			TRegistro reg(codreg, input.get(SLF_MOV "." MOV_ANNOES).as_int());
			if (reg.iva() == iva_vendite)
				var1 = "M";
		}

		var = "";
		if (codcaus == "00100")
		{
			var = "S";
			var1 = "S";
		}
		else
			if (codcaus == "00110")
			{
				var = "N";
				var1 = "N";
			}
			else
				if (codcaus == "00200" ||	codcaus == "00220" ||
						codcaus == "00255" ||	codcaus == "00301")
					var1 ="M";

 		recset.set("MERCIVEN", var1);
		recset.set("QUADROA", var);
		int tipodet;
		TCausale cau(ccaus, _dataini.year());
		const real percdetr = (CENTO - indetraibile_al(input.get(RMI_TIPODET).as_string(), cau, _dataini.year(), tipodet)) * CENTO;

		var = percdetr.string(5, 0, '0');
		recset.set("DETRAIB", percdetr);
		recset.set("FINEREC", "\r\n");
		p.addstatus(1L);;
		if (p.iscancelled())
			break;

  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "/ivamov";
	recset.save_as(outputname);
}

void TInvioSispac::sispac_intramov()
{
	TIntramov_set recset;
/*
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF << "\n"
				<< "FROM " << CLI_TIPOCF << "=F\n"
				<< "TO " << CLI_TIPOCF << "=F";

	TISAM_recordset input(query);
	TVariant var;

  for (bool ok = input.move_first(); ok ; input.move_next())
  {
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "intramov";
	recset.save_as(outputname); */
}

void TInvioSispac::sispac_movpart()
{
	TMovpart_set recset;
/*
	TString query;

	query << "USE " << LF_CLIFO
		    << "\nJOIN " << LF_COMUNI << " INTO  " << COM_STATO << "==" << CLI_STATOCF << " " << COM_COM << "==" << CLI_COMCF << "\n"
				<< "FROM " << CLI_TIPOCF << "=F\n"
				<< "TO " << CLI_TIPOCF << "=F";

	TISAM_recordset input(query);
	TVariant var;

  for (bool ok = input.move_first(); ok ; input.move_next())
  {
  }	

	TFilename outputname = _configfile->get("PATH", "OPZIONI");
	
	outputname << "movpart";
	recset.save_as(outputname);
	*/
}

void TInvioSispac::conferma(bool conf)
{
	TString query;

	query << "USE " << LF_MOV << "KEY 2"
		    << "\nFROM " << RMV_DATAREG << "=" << _dataini.date2ansi()
		    << "\nTO " << RMV_DATAREG << "=" << _datafin.date2ansi();

	TISAM_recordset mov(query);

	if (mov.items() > 0L)
	{
		TProgind pi(mov.items(), conf ? TR("Conferma movimenti") : TR("Ripristino movimenti"), true, true);
		TLocalisamfile cgmov(LF_MOV);
	
		for (bool ok = mov.move_first(); ok; ok = mov.move_next())
		{
			if (!pi.addstatus(1))
				break;

			const long numreg = mov.get(MOV_NUMREG).as_int();

			cgmov.put(MOV_NUMREG, numreg);
			if (cgmov.read(_isequal, _lock) == NOERR)
			{
				cgmov.put(MOV_INVIATO, conf);
				cgmov.rewrite();
			}
		}
	}
}

void TInvioSispac::invio_sispac()
{
	if (_msk->get_bool(F_CLIFOR))
	{
		sispac_cli();
		sispac_for();
	}
	if (_msk->get_bool(F_RIPRISTIN0))
		conferma(false);
	if (_msk->get_bool(F_MOVCONT))
	{
		sispac_movim();
		sispac_moviva();
		sispac_intramov();
		sispac_movpart();
		if (yesno_box(TR("Confermare il traferimento")))
		{
	  	_configfile->set("NUMEROINVIO", _msk->get(F_NUMEROINVIO),"OPZIONI");
			_configfile->set("DATA", _msk->get_date(F_DATAFIN),"OPZIONI");
			conferma();
		}
	}	
}

bool TInvioSispac::create()
{
  _msk = new TInvioSispac_mask();
	
	TFilename configname = "tc9300conf.ini";
	
	configname.custom_path();
	_configfile = new TConfig(configname);
	_tabelle = new TRiclassifica_cache;
  return TSkeleton_application::create();
}

bool TInvioSispac::destroy()
{ 
	delete _configfile;
	delete _msk;
	delete _tabelle;
  return TSkeleton_application::destroy();
}

void TInvioSispac::main_loop()
{
	_msk->set(F_NUMEROINVIO, _configfile->get_int("NUMEROINVIO","OPZIONI")+1);
	_msk->set(F_DATAINI, _configfile->get("DATA","OPZIONI"));
	_msk->set(F_DESTINAZIONE, _configfile->get("PATH","OPZIONI"));
  while (_msk->run() != K_QUIT)
  {                                  
  	_configfile->set("PATH", _msk->get(F_DESTINAZIONE),"OPZIONI");
  	_dataini = _msk->get_date(F_DATAINI);
  	_datafin = _msk->get_date(F_DATAFIN);
		invio_sispac();
		_msk->set(F_NUMEROINVIO, _configfile->get_int("NUMEROINVIO","OPZIONI")+1);
		_msk->set(F_DESTINAZIONE, _configfile->get("PATH","OPZIONI"));
	}	
}

int tc9300(int argc, char **argv) 
{
  TInvioSispac a;
  a.run(argc, argv, "Invio dati contabilità Sispac/Cosmo");
  return 0;
}