#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <odbcrset.h>
#include <relation.h>
#include <utility.h>
#include <doc.h>
#include <recarray.h>		// cache()
#include <dongle.h>			// dongle()

#include "mr0600a.h"

class TCampass_msk : public TAutomask
{
protected:
	virtual long handler(WINDOW task, EVENT* ep);
	virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
	TCampass_msk();
};

long TCampass_msk::handler(WINDOW task, EVENT* ep)
{
	if (ep->type == E_TIMER)
	{
		if (is_running())
			stop_run(K_ENTER);
	}
	return TAutomask::handler(task, ep);
}

bool TCampass_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	return true;
}

TCampass_msk::TCampass_msk() : TAutomask("mr0600a")
{
	set(F_DSN, ini_get_string(CONFIG_DITTA, "Campo_Compass", "DSN"));
	set(F_USR, ini_get_string(CONFIG_DITTA, "Campo_Compass", "User"));
	set(F_PWD, ini_get_string(CONFIG_DITTA, "Campo_Compass", "Password"));
	set(B_IMPORT, ini_get_bool(CONFIG_DITTA, "Campo_Compass", "Importa"));
	set(B_EXPORT, ini_get_bool(CONFIG_DITTA, "Campo_Compass", "Esporta"));
}

class TCampass_app : public TSkeleton_application
{
protected:
	TToken_string tables;
	TString DSN, usr, psw;
	TCampass_msk* m;
	const TString getTime() const;
	const TString getFam(TString codArt) const {TString app; app << codArt[3] << codArt[4] << codArt[5]; return app; } // Restituisce la famiglia di un prodotto CODART[3,5]
	const TString getGroup(TString codTab) const {TString app; app << codTab[1] << codTab[2] << codTab[3]; return app; } // Restituisce la famiglia di un prodotto CODART[3,5]
	const TString toEscape(TString val) const; // Prende una stringa e sistema i caratteri di escape
	const TString zeroFill(TString val, int n = 6) const; // Riempe di 0 se non ci sono 6 caratteri
	const TString toNumber(const TString& val) const;
	bool setParameters(TString dsn, TString utente, TString password);
	bool checkParameters(const TString& DSN, const TString& usr, const TString& psw) { TODBC_recordset connTest(""); return connTest.connect(DSN, usr, psw) ? setParameters(DSN, usr, psw) : false; }
	//*****************************************************************
	// Funzioni per segnalare a Compass il trasferimento delle tabelle
	TString startExport(TString prefixTables) const;
	void endExport(TString id) const;
	//*****************************************************************
	bool emptyTables(const TString& DSN, const TString& usr, const TString& psw) const;
	TString esporta(const TString& DSN, const TString& usr, const TString& psw) const;
	// Funzioni di esportazione
	bool a01a(const TString id) const;
	bool o01a(const TString id) const;
	bool o01c(const TString id) const;
	bool o01e(const TString id) const;
	bool o02a(const TString CodNum, const TString id) const;
	bool o02c(const TString CodNum, const TString id) const;
	bool o03a(const TString id) const;
	bool p01a(const TString id) const;
	bool p01b(const TString id) const;
	bool p02a(const TString id) const;
	
	bool p01c(const TString id) const; // Esportazione cicli articoli
	bool c09a() const;								 // Importazione cicli articoli
	/**< Funzione di test */
	bool test() const;
	//bool o01b(const TString& DSN) const; Messa in pausa

	void log_to_file(TString func, TString msg) const;

public:
	virtual void main_loop();
	void setTable(TToken_string s) { tables = s; }
	~TCampass_app();
};

TCampass_app::~TCampass_app()
{
	if(m != NULL)
		delete m;
}

const TString TCampass_app::getTime() const
{
	TString app;
	time_t timer = time(0); // Tempo per il file di log
	tm *ltm = localtime(&timer);
	TString hour;		hour	<< 1 + ltm->tm_hour;
	TString min;		min		<< 1 + ltm->tm_min;
	TString sec;		sec		<< 1 + ltm->tm_sec;
	TString day;		day		<< ltm->tm_mday;
	TString month;	month << 1 + ltm->tm_mon;
	TString year;		year	<< 1900 + ltm->tm_year;
	app << zeroFill(day, 2) << "/" << zeroFill(month, 2) << "/" << year << " - " << zeroFill(hour, 2) << ":" << zeroFill(min, 2) << ":" << zeroFill(sec, 2);
	return app;
}

const TString TCampass_app::toEscape(TString val) const
{
	TString app;
	for(int k = 0; k < val.len(); k++)
	{
		switch (val[k])
		{
			case '\'':
				app << "''";
				break;
			default:
				app << val[k];
				break;
		}
	}
	return app;
}

const TString TCampass_app::zeroFill(TString val, int n) const
{
	TString app;
	if (n - val.len() > 0)
		app.fill('0', n - val.len());
	app << val;
	return app;
}

const TString TCampass_app::toNumber(const TString& val) const
{
	// A volte capitano dei valori non numerici
	real app = val;
	if(app >= ZERO)
		return app.stringa(5,2);
	return val;
}

bool TCampass_app::setParameters(TString dsn, TString utente, TString password)
{
	// Salvo i parametri
	ini_set_string(CONFIG_DITTA, "Campo_Compass", "DSN", dsn);
	ini_set_string(CONFIG_DITTA, "Campo_Compass", "User", utente);
	ini_set_string(CONFIG_DITTA, "Campo_Compass", "Password", password);
	ini_set_bool(CONFIG_DITTA,	 "Campo_Compass",	"Importa", m->get_bool(B_IMPORT));
	ini_set_bool(CONFIG_DITTA,	 "Campo_Compass",	"Esporta", m->get_bool(B_EXPORT));
	DSN = dsn;
	usr = utente;
	psw = password;
	return true;
}


TString TCampass_app::startExport(TString prefixTables) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return "";

	//Preparo la query
	TString sqlQuery; sqlQuery << "INSERT INTO RunImp (CFLUSSO, DWINI) VALUES ('" << prefixTables << "',CURRENT_TIMESTAMP);";
	TString selectString; selectString << "SELECT TOP 1 IDRUNIMP FROM RunImp ORDER BY IDRUNIMP DESC";
	sqlset.exec(sqlQuery);
	sqlset.commit();
	sqlset.exec(selectString);
	sqlset.move_next();
	TVariant idrunimp = sqlset.get("IDRUNIMP");
	return idrunimp.as_string();
}

void TCampass_app::endExport(TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	sqlset.connect(DSN, usr, psw);
	//Preparo la query
	TString sqlQuery; sqlQuery << "UPDATE RunImp SET DWEND = CURRENT_TIMESTAMP WHERE IDRUNIMP = '" << id << "'";
	sqlset.exec(sqlQuery);
  sqlset.commit();
}

bool TCampass_app::emptyTables(const TString& DSN, const TString& usr, const TString& psw) const
{
	TODBC_recordset sqlset("");
	sqlset.disable_variables();
	TString table;

	if (!sqlset.connect(DSN, usr, psw))
		return false;
	
	for (int i = 0; i < tables.size(); i++)
	{
		TString theQuery; // The query: una tabella (donna) per cui uccidere

		tables.get(i, table);
		theQuery << "DELETE FROM "<< table << ";";
		sqlset.exec(theQuery);
	}
	// Committo i cambiamenti
	sqlset.exec("COMMIT;");
	return true;
}

TString TCampass_app::esporta(const TString& DSN, const TString& usr, const TString& psw) const
{
	TString errors;

	// File di Log
	ofstream logFile;
	logFile.open("Campass_log.txt", ios::out);
	if(!logFile.is_open()) 
		return "Errore generazione file di Log";

	logFile << getTime() << " - Test connessione\n";
	
	TODBC_recordset sqlset("");
	sqlset.disable_variables();
	if (!sqlset.connect(DSN, usr, psw))
		return "Connessione fallita!";
	
	logFile << getTime() << " - Connessione effettuata!\n";

	if(m->get_bool(B_EXPORT))
	{
		// INIZIO O03
		logFile << getTime() << " - Inizio esportazione O03:\n";

		TString o03; o03 << startExport("O03");

		if(!o03a(o03)) errors << "ERRORE TABELLA: O03A\n";	// O03A
		else
			logFile << getTime() << " - Esportata tabella O03A\n";
	
		endExport(o03);	
		logFile << getTime() << " - Fine esportazione O03!\n";
	
	
		// INIZIO P02
		logFile << getTime() << " - Inizio esportazione P02:\n";

		TString p02; p02 << startExport("P02");

		if(!p02a(p02)) errors << "ERRORE TABELLA: P02A\n";	// P02A
		else
			logFile << getTime() << " - Esportata tabella P02A\n";

		endExport(p02);	
	
		logFile << getTime() << " - Fine esportazione P02!\n";

		// INIZIO P01
	
		logFile << getTime() << " - Inizio esportazione P01:\n";

		TString p01; p01 << startExport("P01");

		if(!p01a(p01)) errors << "ERRORE TABELLA: P01A\n"; // P01A
		else
			logFile << getTime() << " - Esportata tabella P01A\n";


		if(!p01b(p01)) errors << "ERRORE TABELLA: P01B\n";	// P01B
		else
			logFile << getTime() << " - Esportata tabella P01B\n";
		
		if(!p01c(p01)) errors << "ERRORE TABELLA: P01C\n"; // O01A
		else
			logFile << getTime() << " - Esportata tabella P01C\n";

		endExport(p01);
	
		logFile << getTime() << " - Fine esportazione P01!\n";

		// INIZIO O02
	
		logFile << getTime() << " - Inizio esportazione O02:\n";

		TString o02; o02 << startExport("O02");
	
		if(!o02a("ORC", o02)) errors << "ERRORE TABELLA: O02A - ORC\n"; // O02A ORC
		else
			logFile << getTime() << " - Esportata tabella O02A - ORC\n";

		if(!o02a("PRC", o02)) errors << "ERRORE TABELLA: O02A - PRC\n"; // O02A PRC
		else
			logFile << getTime() << " - Esportata tabella O02A - PRC\n";
	
		if(!o02c("ORC", o02)) errors << "ERRORE TABELLA: O02C - ORC\n"; // O02C ORC
		else
			logFile << getTime() << " - Esportata tabella O02C - ORC\n";

		if(!o02c("PRC", o02)) errors << "ERRORE TABELLA: O02C - PRC\n"; // O02C PRC
		else
			logFile << getTime() << " - Esportata tabella O02C - PRC\n";

		endExport(o02);

		logFile << getTime() << " - Fine esportazione O02!\n";
	
		// INIZIO O01
	
		logFile << getTime() << " - Inizio esportazione O01:\n";

		TString o01; o01 << startExport("O01");

		if(!o01a(o01)) errors << "ERRORE TABELLA: O01A\n"; // O01A
		else
			logFile << getTime() << " - Esportata tabella O01A\n";

		if(!o01c(o01)) errors << "ERRORE TABELLA: O01C\n"; // O01C
		else
			logFile << getTime() << " - Esportata tabella O01C\n";

		if(!o01e(o01)) errors << "ERRORE TABELLA: O01E\n"; // O01E
		else
			logFile << getTime() << " - Esportata tabella O01E\n";

		endExport(o01);
	
		logFile << getTime() << " - Fine esportazione O01!\n";
	
		// INIZIO A01
	
		logFile << getTime() << " - Inizio esportazione A01:\n";

		TString a01; a01 << startExport("A01");

		if(!a01a(a01)) errors << "ERRORE TABELLA: A01A\n"; // O01A
		else
			logFile << getTime() << " - Esportata tabella A01A\n";
		
		endExport(a01);
	
		logFile << getTime() << " - Fine esportazione A01!\n";

	  }

	if(m->get_bool(B_IMPORT))
	{

		logFile << getTime() << " - Inizio importazione C09A:\n";
		if(!c09a()) errors << "ERRORE TABELLA: C09A\n"; // O01A
		else
			logFile << getTime() << " - Importata tabella C09A\n";
		logFile << getTime() << " - Fine importazione C09A!\n";
	}
	

	logFile.close();
	
	return errors;
}

bool TCampass_app::test() const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	
	TRelation doc(LF_DOC),rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC);
	TString msg("Esportazione tabella "); msg << "O01A";
	// Creo il filtro per la chiave del cursore
	TRectype filtroRDoc(rdoc.curr()); filtroRDoc.put("CODNUM", "ORP1");
	TCursor curRDoc(&rdoc, "", 1, &filtroRDoc, &filtroRDoc);
	const int items = curRDoc.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	int i = 0, j = 0, k = 0;
	for (curRDoc = 0; curRDoc.pos() < items && !p.is_cancelled(); ++curRDoc)
	{
		int num = curRDoc.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;
		// Prendo la riga del FILTRO
		TRectype rowRDoc = curRDoc.curr();
		if(rowRDoc.get("DACODNUM") != "ORC" && rowRDoc.get("DACODNUM") != "PRC") continue; // Filtro subito, evito di caricare un sacco di documenti per nulla
		if(rowRDoc.get_bool("RIGAEVASA")) continue;
		j++;

		TRectype filtroDoc(TRelation(LF_DOC).curr());
		filtroDoc.put(DOC_PROVV, rowRDoc.get("PROVV"));
		filtroDoc.put(DOC_ANNO, rowRDoc.get("ANNO"));
		filtroDoc.put(DOC_CODNUM, rowRDoc.get("CODNUM"));
		filtroDoc.put(DOC_NDOC, rowRDoc.get("NDOC"));
		TCursor curDoc(&doc, "", 1, &filtroDoc, &filtroDoc);
		if(curDoc.items() > 0)
		{
			k++;
		

		TRectype filtroFiltro(filtro.curr());
		filtroFiltro.put("CODNUM", rowRDoc.get("DACODNUM"));
		filtroFiltro.put("ANNO", rowRDoc.get("DAANNO"));
		filtroFiltro.put("PROVV", rowRDoc.get("DAPROVV"));
		filtroFiltro.put("NDOC", rowRDoc.get("DANDOC"));
		TCursor curFiltro(&rdoc, "", 1, &filtroFiltro, &filtroFiltro);
		curFiltro = 0;
		if (curFiltro.items() == 0 || rowRDoc.get_int("DAIDRIGA") != curFiltro.curr().get_int("IDRIGA")|| curFiltro.curr().get_bool("RIGAEVASA")) continue;
		i++;
		}
	}
	message_box(TR("Numero elementi prima: %d, con doc: %d dopo: %d"), j, k, i);
	return true;
}

void TCampass_app::log_to_file(TString func, TString msg) const
{
	ofstream log_file;
	log_file.open("Campass_error_log.txt", ios::app);
	if (!log_file.is_open())
		return;

	log_file << getTime() << " - " << func << " - " << msg << "\n";

	log_file.close();
}


// Non sono molto sicuro del suo funzionamento
bool TCampass_app::a01a(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation rilprod(LF_RILPROD), rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC);
	TString msg("Esportazione tabella "); msg << "A01A";
	TCursor curRilprod(&rilprod, "CODNUM = \"ORC\" && QTA > 0");

	const int items = curRilprod.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curRilprod = 0; curRilprod.pos() < items && !p.is_cancelled(); ++curRilprod)
	{
		int num = curRilprod.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;
		// Prendo la riga di RILPROD
		TRectype rowRilprod = curRilprod.curr();

		// Applico i filtri di nuovo
		if(rowRilprod.get_int("QTA") <= 0 || rowRilprod.get("CODNUM") != "ORC") continue;

		// Vado a prendere il documento di riferimento
		TRectype filtroFiltro(filtro.curr());
		filtroFiltro.put("CODNUM", rowRilprod.get("CODNUM"));
		filtroFiltro.put("ANNO", rowRilprod.get("ANNO"));
		filtroFiltro.put("PROVV", rowRilprod.get("PROVV"));
		filtroFiltro.put("NDOC", rowRilprod.get("NDOC"));
		TCursor curFiltro(&rdoc, "", 1, &filtroFiltro, &filtroFiltro);
		if(curFiltro.items() > 0)
		{
			curFiltro = 0;
			// Prendo la riga di Filtro
			TRectype rowFiltro = curFiltro.curr();
			if(rowFiltro.get_bool("RIGAEVASA")) continue;
			// Preparo la riga del documento
			TRectype filtroRDoc(rdoc.curr());
			filtroRDoc.put("DAPROVV", rowFiltro.get("PROVV")); 
			filtroRDoc.put("DAANNO", rowFiltro.get("ANNO"));
			filtroRDoc.put("DACODNUM", rowFiltro.get("CODNUM"));
			filtroRDoc.put("DANDOC", rowFiltro.get("NDOC"));
			//filtroRDoc.put("DAIDRIGA", rowFiltro.get("IDRIGA")); Non esiste questa chiave
			TString codartmag; codartmag << "CODARTMAG == \"" << rowRilprod.get("CODART") << "\"";
			TCursor curRdoc(&rdoc, codartmag, 4, &filtroRDoc, &filtroRDoc);
			if(curRdoc.items() > 0)
			{
				curRdoc = 0;
				// Prendo la riga di RDOC
				TRectype rowRDoc = curRdoc.curr();
				bool trovato = false;
				for(curFiltro = 0; curFiltro.pos() < curFiltro.items() && !trovato;)
				{
					trovato = rowRDoc.get_int("DAIDRIGA") == curFiltro.curr().get_int("IDRIGA");
					if(!trovato) ++curFiltro;
				}
				// Riapplico i filtri
				if(rowRilprod.get("CODART") != rowRDoc.get("CODARTMAG") || !trovato) continue;

				// Dichiaro la stringa
				TString sqlQuery;
				sqlQuery << "INSERT INTO A01A ( IKRUNIMP, FAZI, CStr, CPRD, NMOV, CMAC, QPFPRO, FSALDO, NFAS ) \
									 VALUES('" << id << "','U','DBS','" << zeroFill(rowRDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','1','" << rowRilprod.get("LINEA") << "','" << rowRilprod.get("QTA") << "','";
				sqlQuery << (rowRilprod.get("CHIUSO") == "X" ? "1" : "0"); sqlQuery << "','10');";
				if(sqlset.exec(sqlQuery) != 1)
				{
					message_box(sqlQuery);
					return false;
				}
			}
		}
	}
	return sqlset.commit() != -1;
}

bool TCampass_app::o01a(const TString id) const
{
	long totalItems = 0;
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation doc(LF_DOC),rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC);
	TString msg("Esportazione tabella "); msg << "O01A";
	// Creo il filtro per la chiave del cursore
	TRectype filtroRDoc(rdoc.curr()); filtroRDoc.put("CODNUM", "ORP1");
	TCursor curRDoc(&rdoc, "", 1, &filtroRDoc, &filtroRDoc);
	const int items = curRDoc.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curRDoc = 0; curRDoc.pos() < items && !p.is_cancelled(); ++curRDoc)
	{
		int num = curRDoc.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;
		// Prendo la riga del FILTRO
		TRectype rowRDoc = curRDoc.curr();
		if(rowRDoc.get("DACODNUM") != "ORC" && rowRDoc.get("DACODNUM") != "PRC") continue; // Filtro subito, evito di caricare un sacco di documenti per nulla
		if(rowRDoc.get_bool("RIGAEVASA")) continue;

		// Vado a prendere il documento di riferimento
		TRectype filtroDoc(TRelation(LF_DOC).curr());
		filtroDoc.put(DOC_PROVV, rowRDoc.get("PROVV"));
		filtroDoc.put(DOC_ANNO, rowRDoc.get("ANNO"));
		filtroDoc.put(DOC_CODNUM, rowRDoc.get("CODNUM"));
		filtroDoc.put(DOC_NDOC, rowRDoc.get("NDOC"));
		TCursor curDoc(&doc, "", 1, &filtroDoc, &filtroDoc);
		if(curDoc.items() > 0)
		{
			// Forzo a 0, sennò ci sono problemi di sporcizia
			curDoc = 0;
			TRectype rowDoc = (curDoc.curr());

			// Vado a prendere la riga di riferimento
			TRectype filtroFiltro(filtro.curr());
			
			filtroFiltro.put("CODNUM", rowRDoc.get("DACODNUM"));
			filtroFiltro.put("ANNO", rowRDoc.get("DAANNO"));
			filtroFiltro.put("PROVV", rowRDoc.get("DAPROVV"));
			filtroFiltro.put("NDOC", rowRDoc.get("DANDOC"));
			TCursor curFiltro(&rdoc, "", 1, &filtroFiltro, &filtroFiltro);
			bool trovato = false;
			for(curFiltro = 0; curFiltro.pos() < curFiltro.items() && !trovato;)
			{
				trovato = rowRDoc.get_int("DAIDRIGA") == curFiltro.curr().get_int("IDRIGA");
				if(!trovato) ++curFiltro;
			}
			if(curFiltro.items() <= 0 || !trovato || curFiltro.curr().get_bool("RIGAEVASA")) continue;
			totalItems++;
			// Dichiaro la stringa
			TString sqlQuery;

			// Inserisco IIKRUNIMP, FAZI, CStr, CPRD, CART
			sqlQuery << "INSERT INTO O01A ( IKRUNIMP, FAZI, CStr, CPRD, CART, TIPORD, FLGSTA, CMAG, DPRICHI, DPRICHF, QPORD, XNOTE, CCLI ) \
									VALUES('" << id << "','U','DBS','" << zeroFill(rowDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','" << rowRDoc.get("CODARTMAG") << "','";

			// Inserisco TIPORD
			sqlQuery << (rowRDoc.get("DACODNUM") == "ORC" ? "R" : "P");
					
			// Inserisco FLGSTA, CMAG, DPRICHI, DPRICHF, QPORD, XNOTE, CCLI
			sqlQuery << "','" << (rowRDoc.get("RIGAEVASA") == "X" ? "C" : "A");
			sqlQuery << "','";
					
			// Se non ho un codice magazzino metto lo standard, Roberto ha detto di metterlo a mano tanto non cambierà mai!
			TString mag(rowRDoc.get("CODMAG"));
			if(mag.full())
				sqlQuery << mag;
			else
				sqlQuery << "001";

			sqlQuery << "','" << rowDoc.get_date("DATADOC").date2ansi() << "','" << rowRDoc.get_date("DATACONS").date2ansi() << "','" << zeroFill(rowRDoc.get("QTA")) << "',";
					
			// Controllo che il campo DESCEST sia pieno
			TString desc; desc << rowRDoc.get("DESCEST");
			if(desc.len() == 0)
				sqlQuery << "NULL,";
			else
				sqlQuery << "'" << desc << "',";
			sqlQuery << "'" << zeroFill(rowDoc.get("CODCF")) << "');";

			if(sqlset.exec(sqlQuery) != 1)
			{
				message_box(sqlQuery);
				return false;
			}
		}
	}
	return sqlset.commit() != -1;
}

bool TCampass_app::o01c(const TString id) const
{
	long totalItems = 0;
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC), rdist(LF_RDIST);
	TString msg("Esportazione tabella "); msg << "O01C";
	TRectype frdoc(rdoc.curr()); 
	frdoc.put("CODNUM", "ORP1");
	TCursor crdoc(&rdoc, "", 1, &frdoc, &frdoc);
	const int items = crdoc.items();
	TProgress_monitor p(items, msg);
	for(crdoc = 0; crdoc.pos() < items; ++crdoc)
	{
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;

		TRectype rowRDoc = crdoc.curr();
		if(rowRDoc.get_bool("RIGAEVASA")) continue;
		if(rowRDoc.get("DACODNUM") == "ORC" || rowRDoc.get("DACODNUM") == "PRC")
		{
			// Adesso creo il cursore del filtro
			TRectype filtroFiltro(filtro.curr());
			filtroFiltro.put("CODNUM",	rowRDoc.get("DACODNUM"));
			filtroFiltro.put("ANNO",		rowRDoc.get("DAANNO"));
			filtroFiltro.put("PROVV",		rowRDoc.get("DAPROVV"));
			filtroFiltro.put("NDOC",		rowRDoc.get("DANDOC"));

			TCursor curFiltro(&rdoc, "", 1, &filtroFiltro, &filtroFiltro);
			bool trovato = false;
			for (curFiltro = 0; curFiltro.pos() < curFiltro.items() && !trovato; ++curFiltro)
			{
				TRectype rowFiltro = curFiltro.curr();
				if(rowFiltro.get_bool("RIGAEVASA")) continue;
				trovato |= rowFiltro.get_int("IDRIGA") == rowRDoc.get_int("DAIDRIGA");
			}
			if(trovato)
			{
				totalItems++;
				// Adesso creo il cursore di RDIST
				TRectype frdist(rdist.curr());
				frdist.put("CODDIST", rowRDoc.get("CODART"));
				TCursor cRdist(&rdist, "", 1, &frdist, &frdist);
				for (cRdist = 0; cRdist.pos() < cRdist.items(); ++cRdist)
				{
					TRectype rowDist = cRdist.curr();
					if(rowDist.get_char("TIPO") != 'A') continue;
					TString sqlQuery;
					sqlQuery << "INSERT INTO O01C ( IKRUNIMP, CStr, CPRD, CARTFIL, CUDM, QIMP, QBASE, XTCALC, NSEQ )";
					sqlQuery << "VALUES('"	<< id << "','DBS','" << zeroFill(rowRDoc.get("NDOC")) << ".";
					sqlQuery << rowRDoc.get("IDRIGA") << "','" << rowDist.get("CODCOMP") << "','";
					sqlQuery << rowDist.get("UM") << "','" << rowDist.get("EXPR") << "','1','0','" << rowDist.get("NRIG") << "');";
					if(sqlset.exec(sqlQuery) != 1)
					{
						message_box(sqlQuery);
						return false;
					}
				}
			}
		}
	}
	return sqlset.commit() != -1;
}

bool TCampass_app::o01e(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation doc(LF_DOC), rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC);
	TString msg("Esportazione tabella "); msg << "O01E";
	TRectype filtroRDoc(rdoc.curr()); filtroRDoc.put("CODNUM", "ORP1");
	TCursor curRDoc(&rdoc, "", 1, &filtroRDoc, &filtroRDoc);
	const int items = curRDoc.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curRDoc = 0; curRDoc.pos() < items && !p.is_cancelled(); ++curRDoc)
	{
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;

		TRectype rowRDoc = curRDoc.curr();

		// Vado a prendere la riga di riferimento
		TRectype filtroFiltro(filtro.curr());
		if(rowRDoc.get("DACODNUM") == "ORC")
		{
			filtroFiltro.put("CODNUM", rowRDoc.get("DACODNUM"));
			filtroFiltro.put("ANNO", rowRDoc.get("DAANNO"));
			filtroFiltro.put("PROVV", rowRDoc.get("DAPROVV"));
			filtroFiltro.put("NDOC", rowRDoc.get("DANDOC"));
			//filtroFiltro.put("IDRIGA", rowRDoc.get("DAIDRIGA"));
			TCursor curFiltro(&filtro, "", 1, &filtroFiltro, &filtroFiltro);
			for (curFiltro = 0; curFiltro.pos() < curFiltro.items() && !p.is_cancelled(); ++curFiltro)
			{
				TRectype rowFiltro(curFiltro.curr());
				if(rowFiltro.get_int("IDRIGA") != rowRDoc.get_int("DAIDRIGA") || rowFiltro.get_bool("RIGAEVASA")) continue;
				// Dichiaro la stringa
				TString sqlQuery;
				TString codagg; codagg << rowFiltro.get("CODAGG1");
				// Inserisco IIKRUNIMP, FAZI, CStr, CPRD, CART
				sqlQuery << "INSERT INTO O01E ( IKRUNIMP, CSTR, CPRD, CPARAM, CPARVAL ) \
										VALUES('" << id << "','DBS','" << zeroFill(rowRDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','TONING','" << codagg.sub(0,5) << "');";
				sqlQuery << "INSERT INTO O01E ( IKRUNIMP, CSTR, CPRD, CPARAM, CPARVAL ) \
										VALUES('" << id << "','DBS','" << zeroFill(rowRDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','CALING','" << codagg.sub(6) << "');";
				codagg = rowFiltro.get("CODAGG2");
				sqlQuery << "INSERT INTO O01E ( IKRUNIMP, CSTR, CPRD, CPARAM, CPARVAL ) \
										VALUES('" << id << "','DBS','" << zeroFill(rowRDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','TONUSC','" << codagg.sub(0,5) << "');";
				sqlQuery << "INSERT INTO O01E ( IKRUNIMP, CSTR, CPRD, CPARAM, CPARVAL ) \
										VALUES('" << id << "','DBS','" << zeroFill(rowRDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','CALUSC','" << codagg.sub(6) << "');";
				if(sqlset.exec(sqlQuery) != 1)
				{
					message_box(sqlQuery);
					return false;
				}
			}
		}
	}
	return sqlset.commit() != -1;
}
bool TCampass_app::o02a(const TString CodNum, const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation doc(LF_DOC), rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC);
	TString msg("Esportazione tabella "); msg << "O02A - " << CodNum;
	
	TRectype filtroRDoc(rdoc.curr()); filtroRDoc.put("CODNUM", CodNum);
	TCursor curRDoc(&rdoc, "", 1, &filtroRDoc, &filtroRDoc);
	const int items = curRDoc.items();

	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curRDoc = 0; curRDoc.pos() < items && !p.is_cancelled(); ++curRDoc)
	{
		int num = curRDoc.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;

		// Prendo la riga di RDOC
		TRectype rowRDoc = curRDoc.curr();

		// Filtro aggiuntivo
		if(rowRDoc.get_bool("RIGAEVASA")) continue;

		// Dichiaro la stringa
		TString sqlQuery;
		
		// Vado a prendere il documento di riferimento
		TRectype filtroDoc(doc.curr());
		filtroDoc.put(DOC_PROVV, rowRDoc.get("PROVV"));
		filtroDoc.put(DOC_ANNO, rowRDoc.get("ANNO"));
		filtroDoc.put(DOC_CODNUM, rowRDoc.get("CODNUM"));
		filtroDoc.put(DOC_NDOC, rowRDoc.get("NDOC"));
		TCursor curDoc(&doc, "", 1, &filtroDoc, &filtroDoc);
		// Forzo a 0, sennò ci sono problemi di sporcizia
		curDoc = 0; curDoc.items();
		TRectype rowDoc = (curDoc.curr());

		// Inserisco IKRUNIMP, FAZI, CStr, CMAG, CCLIH, CCLIR, CCLI
		sqlQuery << "INSERT INTO O02A ( IKRUNIMP, FAZI, CStr, CMAG, CCLIH, CCLIR, CCLI, FLGSTA, XRIFCLI, XNOTE, CART, QCORD, QCSPE, DCCONF, DBS_CCLIHOLD, DBS_CCLIROLD ) \
								VALUES('" << id << "','U','DBS','" << rowRDoc.get("CODMAG") << "','" << rowRDoc.get("ANNO") << "." << CodNum << "." << zeroFill(rowRDoc.get("NDOC")) << "','" << rowRDoc.get("IDRIGA") << "','" << zeroFill(rowDoc.get("CODCF")) << "','";
		// Inserisco FLGSTA
		sqlQuery << (rowRDoc.get("RIGAEVASA") == "X" ? "C" : "A");
		// Inserisco XRIFCLI, XNOTE, CART, QCORD, QCSPE, DCCONF
		sqlQuery << "','" << rowDoc.get("NUMDOCRIF") << "-" << rowDoc.get_date("DATADOCRIF").date2ansi() << "','" << toEscape(rowRDoc.get("DESCEST")) << "','" << toEscape(rowRDoc.get("CODARTMAG")) 
			<< "','" << rowRDoc.get("QTA") << "','" << rowRDoc.get("QTAEVASA") << "','" << rowRDoc.get_date("DATACONS").date2ansi() << "','";
		if(rowRDoc.get("DANDOC") != "")
			sqlQuery <<  rowRDoc.get("DAANNO") << "." << rowRDoc.get("DACODNUM") << "." << zeroFill(rowRDoc.get("DANDOC")) << "','" << rowRDoc.get("DAIDRIGA") << "');";
		else
			sqlQuery << "','');";

		if(sqlset.exec(sqlQuery) != 1)
		{
			message_box(sqlQuery);
			return false;
		}
	}
	return sqlset.commit() != -1;
}
bool TCampass_app::o02c(const TString CodNum, const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation doc(LF_DOC), rdoc(LF_RIGHEDOC), filtro(LF_RIGHEDOC);
	TString msg("Esportazione tabella "); msg << "O02C - " << CodNum;
	// Creo il filtro per la chiave del cursore //OLD: da quel che ho capito le chiavi sono più veloci di un filtro (come è possibile?), (ora lo so lol)
	TRectype filtroRDoc(rdoc.curr()); filtroRDoc.put("CODNUM", "ORP1");
	TCursor curRDoc(&rdoc, "", 1, &filtroRDoc, &filtroRDoc);
	const int items = curRDoc.items();

	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curRDoc = 0; curRDoc.pos() < items && !p.is_cancelled(); ++curRDoc)
	{
		int num = curRDoc.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;
		// Prendo la riga del FILTRO
		TRectype rowRDoc = curRDoc.curr();

		if(rowRDoc.get("DACODNUM") == CodNum)
		{
			// Vado a prendere la riga di riferimento
			TRectype filtroFiltro(filtro.curr());
			filtroFiltro.put("CODNUM", rowRDoc.get("DACODNUM"));
			filtroFiltro.put("ANNO",   rowRDoc.get("DAANNO"));
			filtroFiltro.put("PROVV",  rowRDoc.get("DAPROVV"));
			filtroFiltro.put("NDOC",   rowRDoc.get("DANDOC"));
			//filtroFiltro.put("IDRIGA", rowRDoc.get("DAIDRIGA"));
			
			TCursor curFiltro(&rdoc, "", 1, &filtroFiltro, &filtroFiltro);
			
			// Se non ho elementi salto tutto
			bool trovato = false;
			for(curFiltro = 0; curFiltro.pos() < curFiltro.items() && !trovato;)
			{
				trovato = rowRDoc.get_int("DAIDRIGA") == curFiltro.curr().get_int("IDRIGA");
				if(!trovato) ++curFiltro;
			}
			if(curFiltro.items() <= 0 || !trovato || curFiltro.curr().get_bool("RIGAEVASA") || rowRDoc.get_bool("RIGAEVASA")) continue;
			// Dichiaro la stringa
			TString sqlQuery;
 			// Inserisco Tutto
			sqlQuery << "INSERT INTO O02C ( IKRUNIMP, CStr, CPRD, CCLIH, CCLIR, BVAL, DBS_CART) \
									VALUES('" << id << "','DBS','" << zeroFill(rowRDoc.get("NDOC")) << "." << rowRDoc.get("IDRIGA") << "','" << rowRDoc.get("DAANNO") << "." << rowRDoc.get("DACODNUM") << "." << zeroFill(rowRDoc.get("DANDOC")) << "','" << rowRDoc.get("DAIDRIGA") << "','1','" << rowRDoc.get("CODART") << "');";

			if(sqlset.exec(sqlQuery) != 1)
			{
				message_box(sqlQuery);
				return false;
			}
		}
	}
	return sqlset.commit() != -1;
}
bool TCampass_app::o03a(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation clifo(LF_CLIFO);
	TString msg("Esportazione tabella "); msg << "O03A";
	
	TRectype filtro(clifo.curr()); filtro.put("TIPOCF", "C");
	TCursor curClifo(&clifo, "", 1, &filtro, &filtro);
	const int items = curClifo.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curClifo = 0; curClifo.pos() < items && !p.is_cancelled(); ++curClifo)
	{
		int num = curClifo.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;
		// Dichiaro la stringa
		TString sqlQuery;
		// Prendo la riga di RDOC
		TRectype rowClifo = curClifo.curr();
		// Inserisco tutto in un colpo
		sqlQuery << "INSERT INTO O03A ( IKRUNIMP, FAZI, CStr, CCLI, RCLI ) \
			VALUES('" << id << "','U','DBS','" << zeroFill(rowClifo.get("CODCF")) << "','" << toEscape(rowClifo.get("RAGSOC")) << "');";

		if(sqlset.exec(sqlQuery) != 1)
		{
			message_box(sqlQuery);
			return false;
		}
	}
	return sqlset.commit() != -1;
}
bool TCampass_app::p01a(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation anamag(LF_ANAMAG), rdist(LF_RDIST), umart(LF_UMART);
	TString msg("Esportazione tabella "); msg << "P01A";
	TCursor curAna(&anamag), curRDist(&rdist), curUmart(&umart);
	const int items = curAna.items(); curRDist.items();curUmart.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curAna = 0; curAna.pos() < items && !p.is_cancelled(); ++curAna)
	{
		int num = curAna.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;
		// Dichiaro la stringa
		TString sqlQuery;
		// Prendo la riga di ANAMAG
		TRectype rowAna = curAna.curr();
		// Inserisco IKRUNIMP,CART,RPART,CFAM
		sqlQuery << "INSERT INTO P01A (IKRUNIMP,FAZI,CStr,CART,RART,CFAM,CTART,CUDMP,CUDMM,CUDMA,CUDMV,PCONVPMN,PCONVPMD,PCONVPVN,PCONVPVD,PCONVPAN,PCONVPAD,FOBS) \
			VALUES('" << id << "','U','DBS','" << toEscape(rowAna.get("CODART")) << "','" << toEscape(rowAna.get("DESCR")) << "','" << getFam(rowAna.get("CODART")) <<"','";
		
		
		/****************************************************************************
		* Senza ricreare il cursore ogni volta lo scorro insieme a DIST e RDIST 
		* spostandomi solo quando trovo le righe interessate.
		* Con questo ragionamento risparmio circa 1 secondo 
		*****************************************************************************/
		TRectype rowRDist = curRDist.curr();
		// Carico il codice attuale
		const TString artRDist = rowRDist.get("CODDIST");
		// Controllo se il cursore punta allo stesso articolo
		// Inserisco CTART
		if(artRDist == rowAna.get("CODART"))
		{
			bool trovato = false;
			while(rowRDist.get("CODDIST") == rowAna.get("CODART"))
			{
				if(rowRDist.get("CODCOMP") == rowAna.get("CODART"))
					trovato = true;
				++curRDist;
				rowRDist = curRDist.curr();
			}
			sqlQuery << (trovato ? "SL" : "PF");
		}
		else
			sqlQuery << "MP";
		sqlQuery << "','";

		/****************************************************************************
		* Parto dal presupposto che tutti gli articoli sono presenti in UMART.
		* Senza ricreare il cursore ogni volta lo scorro insieme a ANAMAG 
		* spostandomi solo quando trovo le righe interessate.
		* Con questo ragionamento risparmio circa 1 secondo 
		*****************************************************************************/
		
		TRectype rowUmart = curUmart.curr();
		// Carico il codice attuale
		TString artUmart = rowUmart.get("CODART");
		// Controllo se il cursore punta allo stesso articolo, 
		// siccome a volte possono esserci righe delle distinte senza articolo mi sposto finchè non lo trovo
		while(artUmart != rowAna.get("CODART"))
		{
			++curUmart;
			rowUmart = curUmart.curr();
			artUmart = rowUmart.get("CODART");
		}
		TString UM; UM << rowUmart.get("UM");
		TString UM2;
		// Inserisco CUDMP,CUDMM,CUDMA,CUDMV
		sqlQuery << UM <<"','" << UM <<"','" << UM <<"','";
		// Mi sposto per prendere la seconda riga
		++curUmart;
		rowUmart = curUmart.curr();
		if(artUmart == rowUmart.get("CODART")) // Controllo di essere sulla seconda riga
		{
			UM2 << rowUmart.get("UM");
			++curUmart;
		}
		else
			UM2 << UM;
		sqlQuery << UM2 <<"','";
		
		// Inserisco PCONVPMN,PCONVPMD,PCONVPVN,PCONVPVD,PCONVPAN,PCONVPAD
		// Se siamo alla riga 2 di UMART prendo il valore, altrimenti passo 1
		TString FC; FC << (curUmart.items() > 1 ? rowUmart.get_real("FC") : "1");
		sqlQuery << "1','1','1','" << FC << "','1','1','";

		// Inserisco FOBS
		sqlQuery << rowAna.get_bool("SOSPESO") ? "1" : "0"; 
		// Chiudo la query
		sqlQuery << "');";
		if(sqlset.exec(sqlQuery) != 1)
		{
			message_box(sqlQuery);
			return false;
		}
	}
	return sqlset.commit() != -1;
}

bool TCampass_app::p01b(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation anamag(LF_ANAMAG), tab(LF_TAB);
	TString msg("Esportazione tabella P01B");
	// Anamag
	TISAM_recordset isamrec_ana("USE ANAMAG");
	
	const int items = isamrec_ana.items();

	// Tab
	TProgress_monitor p(items, msg);

	bool ok = true;

	// Adesso inserisco tutta la bella roba
	
	for (bool ok = isamrec_ana.move_first(); isamrec_ana.cursor()->pos() < items; isamrec_ana.move_next())
	{
		//  Aggiorno il Progress Monitor
		p.add_status();

		// Dichiaro la stringa
		static TString sqlQuery;
		sqlQuery.cut(0);

		if (!isamrec_ana.get("USER3").is_empty())
		{
			TString cparam; cparam << toNumber(isamrec_ana.get("USER3").as_string()) << "x" << toNumber(isamrec_ana.get("USER4").as_string());
			// Inserisco Tutto
			sqlQuery << "INSERT INTO P01B ( IKRUNIMP, CStr, CART, CPARAM, CPARVAL ) \
									VALUES('" << id << "','DBS','" << toEscape(isamrec_ana.get("CODART").as_string()) << "','MISREA','" << toEscape(cparam) << "');";
		}

		// Inizio a eseguire quello che ho qua
		if (sqlQuery.full() && sqlset.exec(sqlQuery) != 1)
		{
			TString msg = "Impossibile esportare l'articolo "; msg << isamrec_ana.get("CODART").as_string();
			log_to_file("p01b - MISREA", msg);
		}

		sqlQuery.cut(0);

		TString anamagCod(isamrec_ana.get("CODART").as_string()), filtroCodTab;
		filtroCodTab << "3" << anamagCod.sub(6,12);
		// Tab *******************************************************************************************************************************************************
		// Filtri
		TRectype filtroTab(tab.curr()); 
			filtroTab.put("COD","GCA"); 
			filtroTab.put("CODTAB",filtroCodTab);
		// Cursore
		TCursor curTab(&tab, "", 1, &filtroTab, &filtroTab);
		// Items
		const int itemsTab = curTab.items();
		
		for (curTab = 0; curTab.pos() < itemsTab && !p.is_cancelled(); ++curTab)
		{
			TRectype rowTab = curTab.curr();
			sqlQuery << "INSERT INTO P01B ( IKRUNIMP, CStr, CART, CPARAM, CPARVAL ) \
									VALUES('" << id << "','DBS','" << toEscape(isamrec_ana.get("CODART").as_string()) << "','FORING','" << rowTab.get("S0") << "');";
			
			// Per ogni giro lancio una exec altrimenti rischio di sfondare il limite di caratteri
			if (sqlQuery != "" && sqlset.exec(sqlQuery) != 1)
			{
				TString msg = "Impossibile esportare l'articolo "; msg << isamrec_ana.get("CODART").as_string();
				log_to_file("p01b - FORING", msg);
			}
			sqlQuery.cut(0);
		}

		ok &= sqlset.commit() != -1;
	}

	return ok;
}

bool TCampass_app::p02a(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TRelation tab(LF_TAB);
	TString msg("Esportazione tabella "); msg << "P02A";
	
	TRectype filtroTab(tab.curr()); filtroTab.put("COD", "GCA"); filtroTab.put("CODTAB", "2");
	TCursor curTab(&tab, "", 1, &filtroTab, &filtroTab);
	const int items = curTab.items();
	TProgress_monitor p(items, msg);
	// Adesso inserisco tutta la bella roba
	for (curTab = 0; curTab.pos() < items && !p.is_cancelled(); ++curTab)
	{
		int num = curTab.pos();
		//  Aggiorno il Progress Monitor
		if (!p.add_status())
			break;

		// Prendo la riga di TAB
		TRectype rowTab = curTab.curr();

		TString codTab; codTab << rowTab.get("CODTAB");
		// Dichiaro la stringa
		TString sqlQuery;

		// Inserisco Tutto
		sqlQuery << "INSERT INTO P02A (IKRUNIMP, FAZI, CStr, FGRP, NLIV0, RLIV0, CGRP0, RGRP0 ) \
								VALUES('" << id << "','U','DBS','0','0','0','" << getGroup(rowTab.get("CODTAB")) << "','" << rowTab.get("S0") << "');";
		if(sqlset.exec(sqlQuery) != 1)
		{
			message_box(sqlQuery);
			return false;
		}
	}
	return sqlset.commit() != -1;
}

bool TCampass_app::p01c(const TString id) const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	// Controllo la connessione
	if (!sqlset.connect(DSN, usr, psw))
		return false;

	TString msg("Esportazione tabella "); msg << "P01C";
	TRelation anamag(LF_ANAMAG);
	TCursor curAna(&anamag);
	const int items = curAna.items();
	TProgress_monitor p(items, msg);
	for(curAna = 0; curAna.pos() < items; ++curAna)
	{
		if (!p.add_status())
			break;

		// Prendo la riga di Anamag
		TRectype rowAna = curAna.curr();

		TString codTab; codTab << rowAna.get("CODART");
		// Dichiaro la stringa
		TString sqlQuery;

		// Inserisco Tutto
		sqlQuery << "INSERT INTO P01C (IKRUNIMP, CSTR, CCIC, CART, CCICVER) VALUES('" << id << "','DBS',";

		TString user18 = rowAna.get("USER18");

		if(user18.full())
			sqlQuery << "'" << toEscape(user18) <<  "'";
		else
			sqlQuery << "NULL";

		sqlQuery << ",'" << toEscape(rowAna.get("CODART")) << "',";
		
		TString keyTab; keyTab << "PS|920|CCC|" << rowAna.get("USER18");

		TString ccicver; ccicver << cache().get(LF_TABMOD, keyTab, "I0");
		if(ccicver.full())
			sqlQuery << "'" << toEscape(ccicver) << "');";
		else
			sqlQuery << "NULL);";	

		if(sqlset.exec(sqlQuery) != 1)
		{
			message_box(sqlQuery);
			return false;
		}
	}

	return sqlset.commit() != -1;
}

bool TCampass_app::c09a() const
{
	TODBC_recordset sqlset("", true);
	sqlset.disable_variables();
	if (!sqlset.connect(DSN, usr, psw))
		return false;
	TString sqlQuery = "SELECT TOP 1 * \
										  FROM C09A JOIN RUNEXP ON C09A.IKRUNEXP = RUNEXP.IDRUNEXP \
											WHERE RUNEXP.DWEND IS NOT NULL AND RUNEXP.DRINI IS NULL;";
	if(sqlset.exec(sqlQuery) <= 0)
	{
		message_box("Non ho trovato nulla da importare!");
		return false;
	}

	// Flaggo tutti i record con l'ora di inizio, sarebbe meglio farli dopo ma chissene
	const TString driniQuery = "UPDATE [dbo].[RUNEXP] SET [DRINI] = CURRENT_TIMESTAMP WHERE [DRINI] IS NULL AND [CFLUSSO] = 'C09';";
	TODBC_recordset sqlDrini("", true);
	
	if(!sqlDrini.connect(DSN, usr, psw) || sqlDrini.exec(driniQuery) < 0)
	{
		message_box(driniQuery);
		return false;
	}
	
	// Facendo l'UPDATE "perdo" la SELECT, quindi la rifaccio leggermente modificata
	sqlQuery = "SELECT * \
							FROM C09A JOIN RUNEXP ON C09A.IKRUNEXP = RUNEXP.IDRUNEXP \
							WHERE RUNEXP.DWEND IS NOT NULL AND RUNEXP.DREND IS NULL;";

	sqlset.exec(sqlQuery);

	// Importo tutto quello che ho trovato
	TLocalisamfile tabMod(LF_TABMOD);
	TString msg("Importazione tabella "); msg << "C09A";
	TProgress_monitor p(sqlset.items(), msg);
	for(bool ok = !sqlset.move_first(); !sqlset.eof(); sqlset.move_next())
	{
		if (!p.add_status())
			break;

		const TString ccic = sqlset.get("CCIC").as_string();
		const TString rcic = sqlset.get("RCIC").as_string();
		const int nrev = sqlset.get("NREV").as_int();
		TRectype rec(LF_TABMOD);
		rec.put("MOD",		"PS");
		rec.put("CUST",		"920");
		rec.put("COD",		"CCC");
		rec.put("CODTAB",	ccic);
		rec.put("S0",			rcic);
		rec.put("I0",			nrev);
		
		if(rec.rewrite_write(tabMod) != NOERR)
		{
			message_box(TR("Errore caricamento record CCIC: %s RCIC: %s NREV: %d"), ccic, rcic, nrev);
			return false;
		}
		// Aggiorno DEND
		// Flaggo tutti i record con l'ora di fine, sarebbe meglio farli dopo ma chissene
	}
	const TString drendQuery = "UPDATE [dbo].[RUNEXP] SET [DREND] = CURRENT_TIMESTAMP WHERE [CFLUSSO] ='C09';";
	if(sqlDrini.exec(drendQuery) != 1)
	{
		message_box(drendQuery);
		return false;
	}
	return sqlDrini.commit() != -1;
}

void TCampass_app::main_loop()
{
	m = new TCampass_msk();
	while (m->run() == K_ENTER)
	{
		const TString& DSN = m->get(F_DSN);
		const TString& usr = m->get(F_USR);
		const TString& psw = m->get(F_PWD);
		if(checkParameters(DSN, usr, psw))
		{
			// Chiamo la funzione globale esporta
			TString errors; errors << esporta(DSN, usr, psw);
			if(errors == "") 
			{
				message_box("Esportazione effettuata correttamente!");
				// Salvo i parametri
			}
			else message_box(errors);
		}
		else 
			message_box("Fallita connessione");
	}
}


int mr0600(int argc, char* argv[])
{
	TCampass_app app;
	// Imposto le tabelle da utilizzare
	app.setTable("A01A|O01A|O01B|O01C|O02A|O02C|O03A|P01A|P01B|P02A");
	app.run(argc, argv, TR("Collegamento Campo/Compass"));
	return 0;
}