#include <applicat.h>
#include <automask.h>
#include <filetext.h>
#include <progind.h>
#include <recarray.h>
#include <reprint.h>
#include <reputils.h>
#include <utility.h>

#include "tc1.h"
#include "tc1100a.h"

#include <clifo.h>
#include <pconti.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>
#include <multirel.h>

#define ALIAS_REG		100
// restituisce un riferimento all' applicazione

///////////////////////////////////////////////////////////
// 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);
	TRiclassifica_cache() : _multirel(LF_MULTIREL) {}
};

TObject* TRiclassifica_cache::key2obj(const char* key)
{
	TToken_string tok(key);
	TString8 tab, cod;
	tok.get(0,tab);
	tok.get(1, cod);
	_multirel.put(MULTI_COD, tab);
	_multirel.put(MULTI_FIRST, cod);
	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 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 TInvio;

inline TInvio& app() { return (TInvio&) main_app();}
 
class TInvio_file: public TFile_text
{
protected:
  virtual void validate(TCursor& cur,TRecord_text &rec, TToken_string &val, TString& str);

public:
	const TString& bill2ricl(const char t, int gr, int co, long so);
  TInvio_file(const TString& file_name);
  virtual ~TInvio_file() { }
};

TInvio_file::TInvio_file(const TString& file_name)
          : TFile_text(file_name, "tc1100a.ini")
{
}

class TInvio_mask : public TAutomask
{
protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:

  TInvio_mask();
  
  virtual ~TInvio_mask(){};
};
  
TInvio_mask::TInvio_mask() :TAutomask ("tc1100a")
{
}  
  
bool TInvio_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 TInvio : public TSkeleton_application
{                     
	TCursor*				   _cur;
  TInvio_mask* 			 _msk;
  TInvio_file*			 _trasfile;
	TLog_report *      _log;
	TRiclassifica_cache * _tabelle;
	TRecord_cache*		 _conti;
  long 							 _nrecords, _nrecsfattvend, _nrecsfattacqu, _nrecsmocontab;
  int								 _nfiles;
  long							 _nrecsdettaglio;
  TString16					 _descrdettaglio;
  TDate							 _dataini, _datafin;
  bool							 _totale, _finemov;
  
protected:
  virtual bool create(void);
  virtual bool destroy(void);
  virtual void main_loop() ;
  void invio_zucchetti();
  long i_zucchetti_causali(const bool invio = TRUE);
  long i_zucchetti_clifor(const bool invio = TRUE);
  long i_zucchetti_conti(const bool invio = TRUE);
  long i_zucchetti_movcont(const bool invio = TRUE);
  long i_zucchetti_moviva(const char acqven, const bool invio = TRUE);
  void i_zucchetti_testa_dettaglio(const TString16& descr, const long nrecs);
  void i_zucchetti_coda_dettaglio(const TString16& descr, const long nrecs);
  void i_zucchetti_testa();
  void i_zucchetti_coda();
public:
  int get_nfiles() {return _nfiles;}
  long get_nrecords() {return _nrecords;}
  long get_nrecsdettaglio() {return _nrecsdettaglio;}
  TString16& get_descrdettaglio() {return _descrdettaglio;}
  const bool totale() {return _totale;}
  const bool finemov() {return _finemov;}
	TRecord_cache& conti() {return *_conti;}
	TRiclassifica_cache & tabelle() {	return * _tabelle;}
	void log(int sev, const char* msg);

  TInvio() {} ;
  virtual ~TInvio() {} ;
};  

void TInvio::log(int sev, const char* msg)
{ 
	if (_log != NULL)
	{
		if (sev > 0)
		{
			TString m;
			m << TR(" Errore : ") << msg;
			_log->log(sev, m); 
		}
		else
			_log->log(sev, msg);
	}
}


const TString& TInvio_file::bill2ricl(const char t, int gr, int co, long so)
{
  TString & codricl = get_tmp_string();

	if (gr > 0&& co >0 && so > 0)
	{
		if (t <= ' ')
		{
			TToken_string cod("ZUCONTI");
			cod.add(gr);
			cod.add(co);
			cod.add(so);

			// Provo il sottoconto ma se non riesco provo con conto e poi anche gruppo
			for (int c = 3; c > 0 && codricl <= 0; c--)
			{
				codricl = atol(app().conti().get(cod, "CODICE"));
				cod.add(0, c);
			}
			if (codricl <= 0)
			{
				TString msg;
				msg << TR("Conto") << " " << gr << " " << co << " " << so  << " :" << TR("Non presente in tabella");
				app().log(2, msg);
			}
		}
		else
			codricl.format("%d",so);
	}
	return codricl;
}
// gestione dei messaggi estesi nei campi
void TInvio_file::validate(TCursor& cur,TRecord_text &rec, TToken_string &s, TString& str)
{
  const TString code(s.get(0));
  TString valore;
  if (code == "_FISSO")
  {
    // gestione dei campi fissi per i record delle riba
    // sintassi: _FISSO,!<valore>
    // dove: <valore> è la stringa fissa da emettere
    TString in(s.get());
    CHECK(in[0]=='!',"Macro _FISSO senza carattere '!'");
    in.ltrim(1);
    in.trim();
    valore = in;
  } 
  else if (code == "_ANNO")
  {
    TDate data(str);
    int anno = data.year();
    valore.format("%ld", anno);
  } 
  else if (code == "_MESE")
  {
    TDate data(str);
    int mese = data.month();
    valore.format("%ld", mese);
  } 
  else if (code == "_SEZIONE")
  {
		const TRectype & rmov = cur.curr(LF_RMOV);
		const char sezione = s.get()[0];  	
		const char sezriga = rmov.get_char(RMV_SEZIONE);		

		valore = str;
		if (sezione != sezriga)
			valore = "";
		else
		{
			const int gr = rmov.get_int(RMV_GRUPPO);
			const int co = rmov.get_int(RMV_CONTO);
			const long so = rmov.get_int(RMV_SOTTOCONTO);
			const char t = rmov.get_char(RMV_TIPOC);
			valore = bill2ricl(t, gr, co, so);
		}
  }
  else if (code == "_CAUSALE")
  {
		valore = app().tabelle().sdecode("ZUCAU", str);
		if (valore.blank())
			valore = str;
  } 
  else if (code == "_IVA" || code == "_NORMA")
  {
		valore = app().tabelle().sdecode("ZUIVA", str);
		if (code == "_NORMA")
		{
			valore = cache().get("&ZIV", str, "S7");
			if (valore.blank())
				valore = str.mid(2);
		}
		else
			if (valore.blank())
				valore = str.left(2);
  } 
  else if (code == "_BANCA")
	{
		valore = app().tabelle().sdecode("ZUBAN", str);
		if (valore.blank())
		{
			valore = str.mid(2, 3);
			valore << str.mid(7, 3);
		}

	}
  else if (code == "_NUMFILES")
  {                                       
  	const int nfiles = app().get_nfiles();
  	valore.format("%ld", nfiles);
  }
  else if (code == "_NUMRECORDS")
  {                 
  	const long nrecords = app().get_nrecords(); 
  	valore.format("%ld", nrecords);
  }
  else if (code == "_NUMRECORDSDETTAGLIO")
  {                 
  	const long nrecords = app().get_nrecsdettaglio(); 
  	valore.format("%ld", nrecords);
  }
  else if (code == "_TIPOFILE")
  {                 
  	valore = app().get_descrdettaglio();
  }
  else if (code == "_OPZIONI")
  {
 		TString in(s.get()); 	
		TFilename configname = "tc1100conf.ini";
		TConfig configfile(configname);
 		valore = configfile.get(in, "OPZIONI");
  }
  else if (code == "_OGGI")
  {
    TDate data(TODAY);
  	valore = data.string(full, '-', full, full, amg_date);
  	valore.strip("-");
  } 
  else if (code == "_CODIFICA")
  {
  	const char tipocf = str[0];
  	if (tipocf == 'C')
  		valore = "P";
  	else
  		valore = "R";
  } 
  else if (code == "_NUMDOC")
  {
  	if (cur.file("REG").get("I0") == 1)
  		valore = cur.curr().get(MOV_NUMDOC);
  	else
  		valore = cur.curr().get(MOV_PROTIVA);	
  }
  else if (code == "_SEGNO")
  {
 		TString archivio(s.get()); 	
 		TString campo(s.get()); 	
 		const real importo = cur.curr(archivio).get_real(campo);
 		valore = "+";
 		if (importo < 0)
 			valore = "-";
  }
  else if (code == "_IMPORTO")
  { 
		real importo(str);
		valore = importo.string(0,2);
  	valore.strip("-");
  	valore.strip("+");
  	valore.strip(".");
  }
  else if (code == "_TIPODOC")
  { 
		const char tipodoc = str[0];
		valore = (tipodoc == 'F') ? "1" : "2";
  }
  else if (code == "_DIVERSI")
  { 
  	valore = (app().finemov() ? "X" : " ");
  }
  else if (code == "_TOTALE")
  { 
  	real importo(ZERO);
  	if (app().totale())    
  	{ 
  		importo = cur.curr(LF_MOV).get_real(MOV_TOTDOC);
  		importo+=cur.curr(LF_MOV).get_real(MOV_RITFIS);
  	}	
		valore = importo.string(11,2);
  	valore.strip("-");
  	valore.strip("+");
  	valore.strip(".");
  }
  else if (code == "_SEGNOTOTALE")
  {          
  	real importo(ZERO);
  	if (app().totale())
  	{
  		importo = cur.curr(LF_MOV).get_real(MOV_TOTDOC);
  		importo+=cur.curr(LF_MOV).get_real(MOV_RITFIS);
  	}	
  	valore = importo.string(11,2);
  	valore.trim();
  	valore = valore.sub(0,1);	
  	if (valore[0] != '-' && valore[0] != '+')
  		valore = "+";
  }
	else if (code == "_GIUFIS")
	{
		const char tipopers = cur.curr(LF_CLIFO).get_char(CLI_TIPOPERS);
		valore = (tipopers == 'F') ? " " : "S";
	}
	else if (code == "_BLACKLIST")
	{
		const bool sospeso = cur.curr(LF_CLIFO).get_bool(CLI_SOSPESO);
		valore = (sospeso == true) ? "S" : " ";
	}
	else if (code == "_CONTO")
	{
 		const int ln = s.get_int(); 	
		const TRectype & rec = cur.curr(ln);
		char t = ' ';
		const TString& tiponame = s.get();

		if (s.full())
			t = rec.get_char(tiponame);

		if (ln == LF_CLIFO)
		{
			const int gr = rec.get_int(CLI_GRUPPORIC);
			const int co = rec.get_int(CLI_CONTORIC);
			const long so = rec.get_int(CLI_SOTTOCRIC);
		
			valore = bill2ricl(t, gr, co, so);
		}
		else
		{
			const int gr = rec.get_int("GRUPPO");
			const int co = rec.get_int("CONTO");
			const long so = rec.get_int("SOTTOCONTO");

			valore = bill2ricl(t, gr, co, so);
		}

	}
  else NFCHECK("Macro non definita: %s", (const char *)code);
  str = valore;
}

void TInvio::i_zucchetti_testa()
{
	// cursore fittizio
  TRelation rel(LF_CAUSALI);
  TCursor cur(&rel);
  _nrecords = 0;
  _nfiles = 0;
	if (_msk->get_bool(F_CAUSALI))
	{
		_nrecords += i_zucchetti_causali(FALSE)+2;
		_nfiles++;
	}	
	if (_msk->get_bool(F_CLIFOR))
	{
		_nrecords += i_zucchetti_clifor(FALSE)+2;
		_nfiles++;
	}	
	if (_msk->get_bool(F_CONTI))
	{
		_nrecords += i_zucchetti_conti(FALSE)+2;
		_nfiles++;
	}	
	if (_msk->get_bool(F_MOVCONT))
	{
		_nrecsmocontab = i_zucchetti_movcont(FALSE);
		if (_nrecsmocontab > 0)
		{
			_nrecords += _nrecsmocontab+2;
			_nfiles++;
		}	
	}	
	if (_msk->get_bool(F_MOVIVA))
	{ 
		_nrecsfattvend = i_zucchetti_moviva('V', FALSE);
		if (_nrecsfattvend > 0)
		{
			_nrecords += _nrecsfattvend+2;
			_nfiles++;
		}	
		_nrecsfattacqu = i_zucchetti_moviva('A', FALSE);
		if (_nrecsfattacqu > 0)
		{
			_nrecords += _nrecsfattacqu+2;
			_nfiles++;
		}	
	}	
	TRecord_text rec;
	rec.set_type("I");
	_trasfile->autoload(rec, cur); 
	_trasfile->write(rec);
}

void TInvio::i_zucchetti_testa_dettaglio(const TString16& descr, const long nrecs)
{
	// cursore fittizio
  TRelation rel(LF_CAUSALI);
  TCursor cur(&rel);
  _nrecsdettaglio = nrecs;
  _descrdettaglio = descr;
	TRecord_text rec;
	rec.set_type("F");
	_trasfile->autoload(rec, cur); 
	_trasfile->write(rec);
}

void TInvio::i_zucchetti_coda_dettaglio(const TString16& descr, const long nrecs)
{
	// cursore fittizio
  TRelation rel(LF_CAUSALI);
  TCursor cur(&rel);
  _nrecsdettaglio = nrecs;
  _descrdettaglio = descr;
	TRecord_text rec;
	rec.set_type("E");
	_trasfile->autoload(rec, cur); 
	_trasfile->write(rec);
}

void TInvio::i_zucchetti_coda()
{
  TRelation rel(LF_CAUSALI);
  TCursor cur(&rel);
	TRecord_text rec;
	rec.set_type("C");
	_trasfile->autoload(rec, cur); 
	_trasfile->write(rec);
}

long TInvio::i_zucchetti_causali(const bool invio)
{
  TRelation rel(LF_CAUSALI);
  TCursor cur(&rel);
  const long cur_items = cur.items();
  if (cur_items != 0 && invio) 
  {
		TProgind pi(cur_items, rel.file().description(), true, true);
		i_zucchetti_testa_dettaglio("CAUSMOVM", cur_items);
	  cur.freeze();
    TRectype& cur_rec = cur.curr();
    for (cur = 0; cur.pos() < cur_items; ++(cur))
    {
			if (!pi.addstatus(1))
				break;
			TRecord_text rec;
			rec.set_type("21");
			_trasfile->autoload(rec, cur); 
			_trasfile->write(rec);
    }	
		i_zucchetti_coda_dettaglio("CAUSMOVM", cur_items);
  }                  
  return cur_items;
}

long TInvio::i_zucchetti_conti(const bool invio)
{
  TRelation rel(LF_PCON);
  TCursor cur(&rel);

	cur.setfilter("(CONTO>=0)&&(SOTTOCONTO>0)");
  const long cur_items = cur.items();
  if (cur_items != 0 && invio) 
  {
		TProgind pi(cur_items, rel.file().description(), true, true);
		i_zucchetti_testa_dettaglio("DESCONTI", cur_items);
	  cur.freeze();
    TRectype& cur_rec = cur.curr();
    for (cur = 0; cur.pos() < cur_items; ++(cur))
    {
			if (!pi.addstatus(1))
				break;
			TRecord_text rec;
			rec.set_type("20");
			_trasfile->autoload(rec, cur); 
			_trasfile->write(rec);
    }	
		i_zucchetti_coda_dettaglio("DESCONTI", cur_items);
  }                  
  return cur_items;
}

long TInvio::i_zucchetti_movcont(const bool invio)
{
  TRectype da(LF_MOV);
  TRectype a(LF_MOV);
  da.put(MOV_DATAREG, _dataini);
  a.put(MOV_DATAREG, _datafin);
  TRelation rel(LF_MOV);
  rel.add(LF_RMOV, "NUMREG==NUMREG", 1);
  TCursor cur(&rel, "23->PROTIVA == \"\"", 2, &da, &a);

  const long cur_items = cur.items();
  long totrec = 0;
  if (cur_items != 0) 
  {
		TProgind pi(cur_items, rel.file().description(), true, true);
  	if (invio)
			i_zucchetti_testa_dettaglio("MOCONTAB", _nrecsmocontab);
	  cur.freeze();
    TRectype& cur_rec = cur.curr();
    for (cur = 0; cur.pos() < cur_items; ++(cur))
    { 
			if (!pi.addstatus(1))
				break;
			const long numreg = cur.curr().get_long(MOV_NUMREG);
 			bool continua = TRUE;
 			while (continua)
 			{                                                   
 				const long numregrig = cur.curr(LF_RMOV).get_long(RMV_NUMREG);
 				if (numreg == numregrig)
 				{      
 					if (invio)
 					{
			    	TRectype& cur_rec_righe = cur.curr(LF_RMOV);
						TRecord_text recrighe;
						recrighe.set_type("50");
						cur.save_status();
						_finemov = !(cur.next_match(LF_RMOV, "NUMREG"));
						cur.restore_status();
						_trasfile->autoload(recrighe, cur); 
						_trasfile->write(recrighe);
					}
					totrec++;	
 				}
		  	continua = cur.next_match(LF_RMOV, "NUMREG");
 			}	
    }	
    if (invio)
			i_zucchetti_coda_dettaglio("MOCONTAB", _nrecsmocontab);
  }                  
  return totrec;
}

long TInvio::i_zucchetti_moviva(const char acqven, const bool invio)
{
  TRectype da(LF_MOV);
  TRectype a(LF_MOV);
  da.put(MOV_DATAREG, _dataini);
  a.put(MOV_DATAREG, _datafin);
  TRelation rel(LF_MOV);
  rel.add(LF_RMOVIVA, "NUMREG==NUMREG", 1);
  rel.add("REG", "CODTAB[1,4]==ANNOIVA|CODTAB[5,7]==REG", 1);
  TString filtro = "(23->PROTIVA != \"\")&&";
  if (acqven == 'V')
  	filtro << "(REG->I0 == 1)";
  else 
  	filtro << "(REG->I0 == 2)";
  TCursor cur(&rel, "", 2, &da, &a);
  cur.setfilter(filtro, true);
  const long cur_items = cur.items();
  long totrec = 0;
  if (cur_items != 0) 
  {   
		TProgind pi(cur_items, rel.file().description(), true, true);
  	if (invio)
			i_zucchetti_testa_dettaglio(acqven == 'V' ? "FATTVEND" : "FATTACQU", acqven == 'V' ? _nrecsfattvend : _nrecsfattacqu);
	  cur.freeze();
    TRectype& cur_rec = cur.curr();
    for (cur = 0; cur.pos() < cur_items; ++(cur))
    { 
			if (!pi.addstatus(1))
				break;
			if (invio)
			{
				TRecord_text rec;
				rec.set_type("30");
				_trasfile->autoload(rec, cur); 
				_trasfile->write(rec);
			}	
			totrec++;
			const long numreg = cur.curr().get_long(MOV_NUMREG);
 			bool continua = TRUE;
 			while (continua)
 			{                                                   
 				const long numregrig = cur.curr(LF_RMOVIVA).get_long(RMI_NUMREG);
 				if (numreg == numregrig)
 				{      
 					if (invio)
 					{
			    	TRectype& cur_rec_righe = cur.curr(LF_RMOVIVA);
						TRecord_text recrighe;
						recrighe.set_type("31");
						cur.save_status();
						_totale = !(cur.next_match(LF_RMOVIVA, "NUMREG"));
						cur.restore_status();
						_trasfile->autoload(recrighe, cur); 
						_trasfile->write(recrighe);
					}
					totrec++;	
 				}
		  	continua = cur.next_match(LF_RMOVIVA, "NUMREG");
 			}	
    }	
    if (invio)
			i_zucchetti_coda_dettaglio(acqven == 'V' ? "FATTVEND" : "FATTACQU", acqven == 'V' ? _nrecsfattvend : _nrecsfattacqu);
  }                  
  return totrec;
}

long TInvio::i_zucchetti_clifor(const bool invio)
{
  TRelation rel(LF_CLIFO);
  TCursor cur(&rel);
  const long cur_items = cur.items();
  if (cur_items != 0 && invio) 
  {
		TProgind pi(cur_items, rel.file().description(), true, true);
		i_zucchetti_testa_dettaglio("CLIEFORN", cur_items*2);
	  cur.freeze();
    TRectype& cur_rec = cur.curr();
    for (cur = 0; cur.pos() < cur_items; ++(cur))
    {
			if (!pi.addstatus(1))
				break;
			TRecord_text rec;

			rec.set_type("10");
			_trasfile->autoload(rec, cur); 
			_trasfile->write(rec);

			rec.set_type("11");
			_trasfile->autoload(rec, cur); 
			_trasfile->write(rec);
    }	
		i_zucchetti_coda_dettaglio("CLIEFORN", cur_items*2);
  }                  
  return cur_items+cur_items;
}

//metodone globale che chiama, come un menu, i vari sottometodi in base alle scelte sulla maschera
void TInvio::invio_zucchetti()
{
	//prende i parametri dal file di configurazione dell'applicazione
	TFilename configname = "tc1100conf.ini";
	TConfig configfile(configname);
	//prepara il file su cui scrivere, ovvero il _trasfile
	TFilename filename = _msk->get(F_DESTINAZIONE);
	filename.add(configfile.get("NOMEFILE", "OPZIONI"));
	if (filename.exist())
		remove(filename);
	
	_trasfile = new TInvio_file(filename);
	_trasfile->open(filename,'w');
  _log = new TLog_report("Trasferimento Zucchetti");

	i_zucchetti_testa();

	if (_msk->get_bool(F_CAUSALI))
		i_zucchetti_causali();
	if (_msk->get_bool(F_CLIFOR))
		i_zucchetti_clifor();
	if (_msk->get_bool(F_CONTI))
		i_zucchetti_conti();
	if (_msk->get_bool(F_MOVCONT))
		i_zucchetti_movcont();
	if (_msk->get_bool(F_MOVIVA))
	{
		i_zucchetti_moviva('V');
		i_zucchetti_moviva('A');
	}	
	i_zucchetti_coda();
    
	TReport_book book;

  book.add(*_log);
  book.preview();

	_trasfile->close();
	delete _trasfile;
	_trasfile = NULL;
	delete _log;
	_log = NULL;
}

bool TInvio::create()
{
	_tabelle = new TRiclassifica_cache;
  _msk = new TInvio_mask();
  _trasfile = NULL;
	_conti = new TRecord_cache(LF_RICLPDC, 1);
  return TSkeleton_application::create();
}

bool TInvio::destroy()
{ 
	if (_trasfile)  
  	delete _trasfile;
  delete _msk;
	delete _conti;
	delete _tabelle;
  return TSkeleton_application::destroy();
}

void TInvio::main_loop()
{
	TFilename configname = "tc1100conf.ini";
	configname.custom_path();
	TConfig configfile(configname);
	_msk->set(F_NUMEROINVIO, configfile.get_int("NUMEROINVIO","OPZIONI")+1);
	_msk->set(F_DATAINI, configfile.get("DATA","OPZIONI"));
	_msk->set(F_DESTINAZIONE, configfile.get("PERCORSO","OPZIONI"));

  while (_msk->run() != K_QUIT)
  {                                  
  	_totale = false;
  	_finemov = false;
  	configfile.set("NUMEROINVIO", _msk->get(F_NUMEROINVIO),"OPZIONI");
  	configfile.set("DATA", _msk->get_date(F_DATAFIN),"OPZIONI");
  	configfile.set("PERCORSO", _msk->get(F_DESTINAZIONE),"OPZIONI");
  	configfile.set_paragraph("CAUSALI");
  	_dataini = _msk->get_date(F_DATAINI);
  	_datafin = _msk->get_date(F_DATAFIN);
		const char tipoinvio = _msk->get(F_TIPOINVIO)[0];
		if (tipoinvio == 'Z')
			invio_zucchetti();
	}	
}

int tc1100(int argc, char **argv) 
{
  TInvio a;
  a.run(argc, argv, "Invio dati contabilità Zucchetti");
  return 0;
}