#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <textset.h>

#include <mov.h>
#include <rmoviva.h>

#include "../ca/calib01.h"
#include "../ca/calib02.h"
#include "../cg/cgsaldac.h"

#include "ps0713800a.h"


/* Utility */

bool regSpec(TString codcaus)
{
	return cache().get(LF_CAUSALI, codcaus, "REGSPIVA") != "X";
}


///////////////////////////////////
////    TEsportaIva_msk        ////
///////////////////////////////////

//Classe TEsportaIva_msk
class TEsportaIva_msk : public TAutomask
{
	void createName();
	bool test_partita(const long numreg, TDate& last_data_pag, const TDate& data) const;
	void fill();
public:
	virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
	bool testFields() const;
	TISAM_recordset createRecset() const;
	TDate getDataTest() const;
	TEsportaIva_msk();
};

//ON_FIELD_EVENT: metodo che gestisce i comportamenti dei vari campi della maschera
bool TEsportaIva_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
		case F_PATH:
    if (e == fe_init)
      o.set(ini_get_string(CONFIG_DITTA, "Esporta_Dati_IVA", "Path"));
		break;
/*
  case F_DADATA:
    if (e == fe_init)
      o.set(ini_get_string(CONFIG_DITTA, "Esporta_Dati_IVA", "LastSend", "01-01-2017"));
		break;
*/
	//case F_ADATA:
	case F_CODCF:
		if (e == fe_modify || e == fe_close)
			createName();
		break;
	case B_FORNITORE:
		if(e != fe_init)
		{
			if(get_bool(B_FORNITORE))
			{
				enable(F_CODCF);
				enable(F_RAGSOC);
			}
			else
			{
				disable(F_CODCF);
				disable(F_RAGSOC);
				set(F_CODCF, "");
				set(F_RAGSOC, "");
				createName();
			}
		}
		break;
	case B_GCS:
		if(get_bool(B_GCS))
		{
			enable(F_GRUPPO);
			enable(F_CONTO);
			enable(F_SOTTOCONTO);
		}
		else
		{
			disable(F_GRUPPO);
			disable(F_CONTO);
			disable(F_SOTTOCONTO);
			set(F_GRUPPO, "");
			set(F_CONTO, "");
			set(F_SOTTOCONTO, "");
			
		}
	case B_PRTAPE:
		if(e == fe_init)
		{
			set(B_PRTAPE, "X");
			set(B_PRTCHIU, "X");
			set(B_SOLNONINV, "X");
		}
		break;
	case DLG_RECALC:
		if (e != fe_init)
			fill();
		break;
	default: break;
	}
  return true;
}

void TEsportaIva_msk::createName()
{
	//setto il campo F_NAME a un valore fisso, e cioè: "CODF_data.txt"
  TDate today(TODAY);
	TString name; 
	if(get(F_CODCF).full())
		name << get(F_CODCF);

	if(get(F_CODCF).full() && today.ok()) // Solo se ci sono entrambi, sennò farebbe schifo
		name << "_";

	if(today.ok())
		name << today.date2ansi();
	if(name.full())	// Capita che venga chiamato per eliminare
		name << ".txt";
	set(F_NAME, name);
}

bool TEsportaIva_msk::testFields() const
{
	// Controllo presenza campi
	if(!get_bool(B_PRTAPE) && !get_bool(B_PRTCHIU))
	{
		warning_box("Selezionare almeno un tipo di partita!");
		return false;
	}
	if(get_bool(B_FORNITORE) && get(F_CODCF).empty())
	{
		warning_box("Selezionare il fornitore o togliere il filtro!");
		return false;
	}
	return true;
}

TISAM_recordset TEsportaIva_msk::createRecset() const
{
	// Eseguo un controllo sulle date
	TDate daDReg = get_date(F_DADATAREG), aDReg = get_date(F_ADATAREG);
	if(!aDReg.ok())
	{
		aDReg = TDate(TODAY);
	}
	if(!daDReg.ok())
	{
		daDReg = TDate(01,01,1990);
	}
	TDate daDFatt = get_date(F_DADATAFATT), aDFatt = get_date(F_ADATAFATT);
	if(!aDFatt.ok() && daDFatt.ok())	// Sistemo le date solo se mi ha messo il filtro complementare
	{
		aDFatt = TDate(TODAY);
	}
	if(!daDFatt.ok() && aDFatt.ok())
	{
		daDFatt = TDate(01,01,1990);
	}

	// Preparo query su righe iva joinati ai mov
	TString query("USE RMOVIVA SELECT ");
	if(daDReg.ok() && aDReg.ok())	// Se almeno una delle due è stata impostata con i controlli di sopra dovrebbero essere tutte e due OK
	{
		query <<  "BETWEEN(23.DATAREG,#DADATAREG,#ADATAREG)&&";
	}
	if(daDFatt.ok() && aDFatt.ok())
	{
		query <<  "BETWEEN(23.DATADOC,#DADATAFATT,#ADATAFATT)&&";
	}

	if(get_bool(B_SOLNONINV))
	{
		query << "(23.INVIVA!=\"X\")&&";
	}
	
	query << "(23.TIPO=\"F\")";
	
	if(get_bool(B_FORNITORE))
	{
		query << "&&(23.CODCF=#CODCF)";
	}

	if(get_bool(B_GCS))
	{
		if(get_int(F_GRUPPO) > 0)
		{
			query << "&&(25.GRUPPO=#GRUPPO)";
			if(get_int(F_CONTO) > 0)
			{
				query << "&&(25.CONTO=#CONTO)";
				if(get_int(F_SOTTOCONTO) > 0)
				{
					query << "&&(25.SOTTOCONTO=#SOTTOCONTO)";
				}
			}
		}
	}

	query << "\n";

	query << "JOIN MOV INTO NUMREG==NUMREG\n"
	      << "JOIN %IVA ALIAS 101 INTO CODTAB==CODIVA\n"
	      << "JOIN CLIFO TO MOV INTO TIPOCF==TIPO CODCF==CODCF";
	
	// Instanzio il recordset
	TISAM_recordset recset(query);	
	if(daDReg.ok() && aDReg.ok())
	{
		recset.set_var("#DADATAREG", daDReg);
		recset.set_var("#ADATAREG",  aDReg);
	}
	if(daDFatt.ok() && aDFatt.ok())
	{
		recset.set_var("#DADATAFATT", daDFatt);
		recset.set_var("#ADATAFATT",  aDFatt);
	}

	if(get_bool(B_FORNITORE))
	{
		recset.set_var("#CODCF",  get(F_CODCF));
	}

	if(get_bool(B_GCS))
	{
		if(get_int(F_GRUPPO) > 0)
		{
			recset.set_var("#GRUPPO",  get(F_GRUPPO));
			if(get_int(F_CONTO) > 0)
			{
				recset.set_var("#CONTO",  get(F_CONTO));
				if(get_int(F_SOTTOCONTO) > 0)
				{
					recset.set_var("#SOTTOCONTO",  get(F_SOTTOCONTO));
				}
			}
		}
	}

	return recset;
}

TDate TEsportaIva_msk::getDataTest() const
{
	if(get_date(F_ADATAREG).ok())
	{
		return get_date(F_ADATAREG);
	}
	else if(get_date(F_ADATAFATT).ok())
	{
		return get_date(F_ADATAFATT);
	}
	return TDate(TODAY);
}

//TEST_PARTITA: metodo che cerca l'ultima data pagamento delle partite relative ad un numreg (la maggiore)
//il metodo restiruisce true se esiste almeno una partita per il numreg indicato
bool TEsportaIva_msk::test_partita(const long numreg, TDate& last_data_pag, const TDate& data) const
{
  TPartite_array torneo;
  //aggiungo all'array tutte le partite con quel numreg
	torneo.add_numreg(numreg);
	TPartita* partita = torneo.first();
  //se esiste almeno una partita ed è chiusa
	if (partita != NULL && partita->chiusa())
	{
		//scorro tutte le partite
    for (int r = partita->last(); r > 0; r = partita->pred(r))
		{
      //instanzio una riga_partite
			const TRiga_partite& row = partita->riga(r);
			const tipo_movimento tipo = row.tipo();
      //controllo il tipo_movimento; se è del tipo tm_pagamento o tm_pagamento_insoluto
      //recupero la data del pagamento, e se questa è maggiore di quella già trovata, aggiorno
      //quest'ultima
			if (tipo == tm_pagamento || tipo == tm_pagamento_insoluto)
			{
				const TDate datadoc = row.get_date(PART_DATAPAG);
				if (datadoc > last_data_pag)
					last_data_pag = datadoc;
			}
		}
    return last_data_pag <= data ? true : false;
	}
	return false;
}

void TEsportaIva_msk::fill()
{
	// Controllo se i campi corretti
	if(!testFields())
		return;

	bool with_cms = get_int(F_JOB) == 1;
	// Controllo che data mettere per partita chiusa
	TDate dataTest = getDataTest();

	TISAM_recordset rmoviva = createRecset();

	TSheet_field& sheet = sfield(S_RESULT);
	TString_array& strarr = sheet.rows_array();

	sheet.hide();
	sheet.destroy();
  
	TProgress_monitor pi(rmoviva.items(), TR("Creazione sheet..."));	

	bool all = get_bool(B_PRTAPE) && get_bool(B_PRTCHIU);
	for (bool ok = rmoviva.move_first(); ok && !pi.is_cancelled(); ok = rmoviva.move_next())
	{
    if (!pi.add_status())
      break;

		if(get_bool(B_SOLRITFIS) && rmoviva.get("23.RITFIS").as_real() <= ZERO && !regSpec(rmoviva.get("23.CODCAUS").as_string())) continue;

		TCursor* i = rmoviva.cursor();
		int k = i->pos();

		TDate last_data_pag;
    const long  numreg = rmoviva.get(RMI_NUMREG).as_int();
		
		// Da fare sempre o last_data_pag non viene valorizzato
		bool partita_chiusa = test_partita(numreg, last_data_pag, dataTest);

		TDate daDPag = get_date(F_DADATAPAG), aDPag = get_date(F_ADATAPAG);
		if(!aDPag.ok() && daDPag.ok())	// Sistemo le date solo se mi ha messo il filtro complementare
		{
			aDPag = TDate(TODAY);
		}
		if(!daDPag.ok() && aDPag.ok())
		{
			daDPag = TDate(01,01,1990);
		}

		if(aDPag.ok() && daDPag.ok() && (last_data_pag < daDPag || aDPag < last_data_pag || !last_data_pag.ok())) continue;

		if (all || (get_bool(B_PRTAPE) && !partita_chiusa) || (get_bool(B_PRTCHIU) && partita_chiusa))
		{
			if (with_cms)
			{
				TAnal_mov movana;

				movana.read_cgnum(numreg);
				const int rows = movana.rows();

				if (rows > 0)
				{
					for(int i = 1; i <= rows; i++)
					{
						TToken_string row;
						const TRectype& rmovana = movana.body()[i];
						const TString80 codcms = rmovana.get("CODCMS");        

						row.add(rmoviva.get("23.DATAREG").as_string(), 0);
						row.add(codcms);
						row.add(rmoviva.get("23.CODCF").as_string());
						row.add(rmoviva.get("20.RAGSOC").as_string());
						char sez = rmovana.get_char("SEZIONE");
						TImporto importo(sez, rmovana.get_real("IMPORTO"));		
						importo.normalize('D');
						row.add(importo.valore());
						row.add(rmoviva.get("23.RITFIS").as_real());
						row.add(rmoviva.get("23.TOTDOC").as_real());
						row.add(rmoviva.get("23.DATADOC").as_string());
						row.add(rmoviva.get("23.NUMDOC").as_string());
						row.add(last_data_pag);
						row.add(rmoviva.get("25.GRUPPO").as_string());
						row.add(rmoviva.get("25.CONTO").as_string());
						row.add(rmoviva.get("25.SOTTOCONTO").as_string());
						strarr.add(row);
					}
					while (rmoviva.move_next())
					{
						const long wnumreg = rmoviva.get(RMI_NUMREG).as_int();
						if (wnumreg != numreg)
						{
							rmoviva.move_prev();
							break;
						}
					}

				}
				else
				{
					const TString & codcms = rmoviva.get("CODCMS").as_string();

					if (codcms.full())
					{
						TToken_string row;
						row.add(rmoviva.get("23.DATAREG").as_string(), 0);
						row.add(codcms);
						row.add(rmoviva.get("23.CODCF").as_string());
						row.add(rmoviva.get("20.RAGSOC").as_string());			
						row.add(rmoviva.get(RMI_IMPONIBILE).as_real());
						row.add(rmoviva.get("23.RITFIS").as_real());
						row.add(rmoviva.get("23.TOTDOC").as_real());
						row.add(rmoviva.get("23.DATADOC").as_string());
						row.add(rmoviva.get("23.NUMDOC").as_string());
						row.add(last_data_pag);
						row.add(rmoviva.get("25.GRUPPO").as_string());
						row.add(rmoviva.get("25.CONTO").as_string());
						row.add(rmoviva.get("25.SOTTOCONTO").as_string());
						strarr.add(row);
					}
				}
			}
			else
				if (rmoviva.get("CODCMS").as_string().blank())
				{
					TToken_string row;
					row.add(rmoviva.get("23.DATAREG").as_string(), 0);
					row.add("");
					row.add(rmoviva.get("23.CODCF").as_string());
					row.add(rmoviva.get("20.RAGSOC").as_string());			
					row.add(rmoviva.get(RMI_IMPONIBILE).as_real());	
					row.add(rmoviva.get("23.RITFIS").as_real());
					row.add(rmoviva.get("23.TOTDOC").as_real());
					row.add(rmoviva.get("23.DATADOC").as_string());
					row.add(rmoviva.get("23.NUMDOC").as_string());
					row.add(last_data_pag);
					row.add(rmoviva.get("25.GRUPPO").as_string());
					row.add(rmoviva.get("25.CONTO").as_string());
					row.add(rmoviva.get("25.SOTTOCONTO").as_string());
					strarr.add(row);
				}
		}
	}
	sheet.force_update();
	sheet.show();
}

//metodo costruttore
TEsportaIva_msk::TEsportaIva_msk() : TAutomask("ps0713800a"){}

///////////////////////////////////
////    TEsportaIva_REC				////
///////////////////////////////////

//Classe TEsportaIva_rec (righe movimenti iva)
class TEsportaIva_rec : public TCSV_recordset
{
public:
	TEsportaIva_rec();
};

//metodo costruttore
TEsportaIva_rec::TEsportaIva_rec() 
                    : TCSV_recordset("CSV(\"\t\")")
{
}

///////////////////////////////////
////    TEsportaIva_APP				 ////
///////////////////////////////////

//Classe TEsportaIva_app
class TEsportaIva_app : public TSkeleton_application
{
	friend class TEsportaIva_msk;
protected:
	virtual bool check_autorization() const {return false;}
  virtual const char * extra_modules() const {return "cg";}
	virtual void main_loop();

	bool test_partita(const long numreg, TDate& last_data_pag, const TDate& data) const;

public:
	void esporta_righe_iva(const TEsportaIva_msk& msk) const;
	void set_inviva(TISAM_recordset& rmoviva, const TDate& data) const;
};

//TEST_PARTITA: metodo che cerca l'ultima data pagamento delle partite relative ad un numreg (la maggiore)
//il metodo restiruisce true se esiste almeno una partita per il numreg indicato
bool TEsportaIva_app::test_partita(const long numreg, TDate& last_data_pag, const TDate& data) const
{
  TPartite_array torneo;
  //aggiungo all'array tutte le partite con quel numreg
	torneo.add_numreg(numreg);
	TPartita* partita = torneo.first();
  //se esiste almeno una partita ed è chiusa
	if (partita != NULL && partita->chiusa())
	{
		//scorro tutte le partite
    for (int r = partita->last(); r > 0; r = partita->pred(r))
		{
      //instanzio una riga_partite
			const TRiga_partite& row = partita->riga(r);
			const tipo_movimento tipo = row.tipo();
      //controllo il tipo_movimento; se è del tipo tm_pagamento o tm_pagamento_insoluto
      //recupero la data del pagamento, e se questa è maggiore di quella già trovata, aggiorno
      //quest'ultima
			if (tipo == tm_pagamento || tipo == tm_pagamento_insoluto)
			{
				const TDate datadoc = row.get_date(PART_DATAPAG);
				if (datadoc > last_data_pag)
					last_data_pag = datadoc;
			}
		}
    return last_data_pag <= data ? true : false;
	}
	return false;
}

//ESPORTA_RIGHE_IVA: metodo che prepara il csv-recordset per essere esportato
void TEsportaIva_app::esporta_righe_iva(const TEsportaIva_msk& m) const
{
	// Controllo se i campi corretti
	if(!m.testFields())
		return;

	// Instanzio il TFilename e controllo la sua esistenza
  TFilename path = m.get(F_PATH);
	path.add(m.get(F_NAME));
	if (path.exist())
  {
		TString str;
    str << "ATTENZIONE! "  << "Il file " << m.get(F_NAME) << "è già esistente.\n"
        << "Se si procede sara' azzerato il file esistente!\nContinuare?";
    if (!yesno_box(str))
			return;
  }

	bool with_cms = m.get_int(F_JOB) == 1;
	// Controllo che data mettere per partita chiusa
	TDate dataTest = m.getDataTest();
	TISAM_recordset rmoviva = m.createRecset();

	//instanzio il csv recordset
	TEsportaIva_rec csv;
	bool all = m.get_bool(B_PRTAPE) && m.get_bool(B_PRTCHIU);
	TProgress_monitor pi(rmoviva.items(), TR("Estrazione dati..."));	
	for (bool ok = rmoviva.move_first(); ok && !pi.is_cancelled(); ok = rmoviva.move_next())
	{
		if (!pi.add_status())
		 break;

		if(m.get_bool(B_SOLRITFIS) && rmoviva.get("23.RITFIS").as_real() <= ZERO && !regSpec(rmoviva.get("23.CODCAUS").as_string())) continue;

		TDate last_data_pag;
		const long  numreg = rmoviva.get(RMI_NUMREG).as_int();

		// Da fare sempre o last_data_pag non viene valorizzato
		bool partita_chiusa = test_partita(numreg, last_data_pag, dataTest);

		TDate daDPag = m.get_date(F_DADATAPAG), aDPag = m.get_date(F_ADATAPAG);
		if(!aDPag.ok() && daDPag.ok())	// Sistemo le date solo se mi ha messo il filtro complementare
		{
			aDPag = TDate(TODAY);
		}
		if(!daDPag.ok() && aDPag.ok())
		{
			daDPag = TDate(01,01,1990);
		}

		if(aDPag.ok() && daDPag.ok() && (last_data_pag < daDPag || aDPag < last_data_pag || !last_data_pag.ok())) continue;

		if (all || (m.get_bool(B_PRTAPE) && !partita_chiusa) || (m.get_bool(B_PRTCHIU) && partita_chiusa))
		{
			if (with_cms)
			{
				TAnal_mov movana;

				movana.read_cgnum(numreg);
				const int rows = movana.rows();

				if (rows > 0)
				{
					for(int i = 1; i <= rows; i++)
					{
						csv.new_rec("");
						const TRectype& rmovana = movana.body()[i];
						const TString80 codcms = rmovana.get("CODCMS");        

						csv.set(0, rmoviva.get("23.DATAREG").as_string());
						csv.set(1, codcms);
						csv.set(2, rmoviva.get("23.CODCF"));
						csv.set(3, rmoviva.get("20.RAGSOC"));
						char sez = rmovana.get_char("SEZIONE");
						TImporto importo(sez, rmovana.get_real("IMPORTO"));		
						importo.normalize('D');
						csv.set(4, importo.valore());

						csv.set(5, rmoviva.get("23.RITFIS").as_real());
						csv.set(6, rmoviva.get("23.TOTDOC").as_real());
						csv.set(7, rmoviva.get("23.DATADOC"));
						csv.set(8, rmoviva.get("23.NUMDOC"));
						csv.set(9, last_data_pag);
						csv.set(10, rmoviva.get("25.GRUPPO"));
						csv.set(11, rmoviva.get("25.CONTO"));
						csv.set(12, rmoviva.get("25.SOTTOCONTO"));
					}
					while (rmoviva.move_next())
					{
						const long wnumreg = rmoviva.get(RMI_NUMREG).as_int();
						if (wnumreg != numreg)
						{
							rmoviva.move_prev();
							break;
						}
					}

				}
				else
				{
					const TString & codcms = rmoviva.get("CODCMS").as_string();

					if (codcms.full())
					{
						csv.new_rec("");
						csv.set(0, rmoviva.get("23.DATAREG").as_string());
						csv.set(1, codcms);
						csv.set(2, rmoviva.get("23.CODCF"));
						csv.set(3, rmoviva.get("20.RAGSOC"));			
						csv.set(4, rmoviva.get(RMI_IMPONIBILE).as_real());		
						csv.set(5, rmoviva.get("23.RITFIS").as_real());
						csv.set(6, rmoviva.get("23.TOTDOC").as_real());
						csv.set(7, rmoviva.get("23.DATADOC"));
						csv.set(8, rmoviva.get("23.NUMDOC"));
						csv.set(9, last_data_pag);
						csv.set(10, rmoviva.get("25.GRUPPO"));
						csv.set(11, rmoviva.get("25.CONTO"));
						csv.set(12, rmoviva.get("25.SOTTOCONTO"));
					}
				}
			}
			else
				if (rmoviva.get("CODCMS").as_string().blank())
				{
					csv.new_rec("");
					csv.set(0, rmoviva.get("23.DATAREG").as_string());
					csv.set(1, "");
					csv.set(2, rmoviva.get("23.CODCF"));
					csv.set(3, rmoviva.get("20.RAGSOC"));			
					csv.set(4, rmoviva.get(RMI_IMPONIBILE).as_real());	
					csv.set(5, rmoviva.get("23.RITFIS").as_real());
					csv.set(6, rmoviva.get("23.TOTDOC").as_real());
					csv.set(7, rmoviva.get("23.DATADOC"));
					csv.set(8, rmoviva.get("23.NUMDOC"));
					csv.set(9, last_data_pag);
					csv.set(10, rmoviva.get("25.GRUPPO"));
					csv.set(11, rmoviva.get("25.CONTO"));
					csv.set(12, rmoviva.get("25.SOTTOCONTO"));
				}
		}
	} 	
	csv.save_as(path, fmt_text);

#ifdef DBG
	xvt_sys_goto_url(path, "open");
#endif

	TString msg;
	msg << TR("Si conferma l'esportazione definitiva dei movimenti IVA fino al ") << dataTest;
	if (m.get_bool(B_PRTCHIU) && yesno_box(msg))
		set_inviva(rmoviva, dataTest);	//mette il flag di "INVIVA" alla testata movimento

	// Salvo su file le impostazioni
	//ini_set_string(CONFIG_DITTA, "Esporta_Dati_IVA", "LastSend", m.get_date(F_DADATA));
	ini_set_string(CONFIG_DITTA, "Esporta_Dati_IVA", "Path", m.get(F_PATH));
}

//SET_INVIA: metodo che mette il flag di "INVIVA" alla testata movimento
void TEsportaIva_app::set_inviva(TISAM_recordset& rmoviva, const TDate& data) const
{
	return; //Test
	long last_numreg = 0L;

	TProgind pi(rmoviva.items(), TR("Impostazione flag Inviata parte IVA..."), true, true);
	TLocalisamfile mov(LF_MOV);

  //scorro il recordset che contiene le righe IVA joinate con i movimenti
	for (bool ok = rmoviva.move_first(); ok; ok = rmoviva.move_next())
	{
    if (!pi.addstatus(1))
      break;
		
    const long curr_numreg = rmoviva.get(RMI_NUMREG).as_int();
		//ad ogni cambio di numreg
    if (curr_numreg != last_numreg)
		{
			TDate last_data_pag;
			bool partita_chiusa = test_partita(curr_numreg, last_data_pag, data);
      //controllo che la partita sia chiusa
			if (partita_chiusa)
			{
				//leggo dal file LF_MOV quello che ha il numero di registrazione selezionato
        mov.put(MOV_NUMREG, curr_numreg);
				int err = mov.read();

        //se riesco a leggerlo setto il flag di invio e aggiorno il movimento
				if (err == NOERR)
				{
					mov.put(MOV_INVIVA, 'X');
					err = mov.rewrite();
				}

        //se non sono riuscito ne' a leggerlo ne' a scriverlo, lo segnalo
				if (err != NOERR)
				{
					TString str;
					str << TR("Impossibile aggiornare il movimento ") << curr_numreg;
					error_box(str);
					break;
				}
			}
			last_numreg = curr_numreg;
		}
	}
}

void TEsportaIva_app::main_loop()
{
  TEsportaIva_msk m;
  while (m.run() == K_ENTER)
		esporta_righe_iva(m);
}

int ps0713800(int argc, char* argv[])
{
  TEsportaIva_app app;
  app.run(argc, argv, TR("Trasferimento dati IVA"));
  return 0;
}