#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <progind.h>
#include <cfven.h>
#include <doc.h>
#include <mask.h>

#include <lffiles.h>
#include <isam.h>
#include <urldefid.h>
#include <progind.h>
#include <utility.h>
#include <sqlset.h>

#include "../ve/velib05.h"
#include "../fe/felib.h"
#include "../f1/f1lib.h"
#include "../fp/fplib.h"

#include "f901tab.h"
#include "f90600.h"
#include "f90600a.h"
#include "f90600b.h"
#include "f90600c.h"
#include "f90600d.h"


#define TABMOD_TABVER       "S0"  // Campo per la memorizzazione della versione attuale delle tabelle
#define TAB_BASE_VERSION    100   // Versione base delle tabelle
#define SQL_VERSION         104   // Utilizzo questo per controllare la versione attuale delle tabelle e nel caso aggiornarle

//TConfig_f9_mask

bool TConfigIntf9_mask::on_key(const KEY key)
{
	if (key == K_SHIFT + K_F12)
	{
		if (run_fp_psw_mask())
		{
			enable(CF_LVLNEW);
		}
	}
	return true;
}

bool TConfigIntf9_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case CF_LVLNEW:
		if (e == fe_close)
		{
			TMask& config_mask = o.mask();
			TString new_lvl = config_mask.get(CF_LVLNEW);
			TString old_lvl = config_mask.get(CF_LVLOLD);

			if (new_lvl.empty())
				return o.error_box("Livello Patch non conforme. Impossibile aggiornare");

			if (new_lvl > old_lvl)
				return o.error_box("Per impostare un livello patch superiore dell'attuale\nč sufficente riavviare il programma.");
		}

		break;
	default: break;
	}
	return true;
}

//TArchInt_mask

bool TArchInt_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case DLG_ELABORA:
		if (e == fe_button)
			open_win_estr();
			fill();
		break;
	case DLG_CONFIG:
		if (e == fe_button)
			open_win_conf();
		break;
	case DLG_DELREC:
		if (e == fe_button)
			delete_pack();
		break;
	case B_SHOWESTR:
		open_apri_estr_win();
	break;
	case DLG_FINDREC:
		if (e == fe_button)
			controllo_errori();
		break;

	default: break;
	}
	
	return true;
}

void TArchInt_mask::open_apri_estr_win()
{
	static TString  last_fill_id = 0;
	TString         id;
	TToken_string*  row_estrazione = nullptr;
	FOR_EACH_SHEET_ROW(sfield(S_ELAB), nr, row)
	{
		if (row->get(0)[0] == 'X')
		{
			if (TString(row->get(cid2index(F_STATESTR))).starts_with("02"))
			{
				message_box("Impossibile controllare un pacchetto in stato di errore '02'.\n"
					"Usare il 'Controllo Estrazioni' per vedere i movimenti in errore.");
				return;
			}
			row_estrazione = row;
			id = row->get(cid2index(F_IDESTR));
			break;
		}
	}
	if (row_estrazione == nullptr)
	{
		message_box("Selezionare un pacchetto.");
		return;
	}

	if (last_fill_id != id)
	{
		_inclusi_msk.set_from_estrazione(*row_estrazione);

		_inclusi_msk.fill_estr();
		_inclusi_msk.fill_res();
		last_fill_id = id;
	}
	_inclusi_msk.run();
}

void TArchInt_mask::fill() const
{
	TString query;
	query << "SELECT * FROM " F9_DRD " WHERE " DRD_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " DRD_ID_EST " like 'R%' ORDER BY " << DRD_TIME << " DESC;";
	fp_db().sq_set_exec(query, false);

	TSheet_field& sf = sfield(S_ELAB);

	sf.reset();
	int i = 0;
	for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
	{
		TString tipo;
		const int row = sf.set_row_cell(F_ARCH_B, fp_db().sq_get(DRD_STATO) == "09");

		sf.set_row_cell(F_IDESTR, fp_db().sq_get(DRD_ID_EST), row);
		sf.set_row_cell(F_DATAESTR, fp_db().sq_get_date(DRD_TIME), row);
		sf.set_row_cell(F_PROV_B, fp_db().sq_get(DRD_FLAG_PD) == "P", row);
		sf.set_row_cell(F_TIPODOC, fp_db().sq_get(DRD_TIPODOC), row);
		sf.set_row_cell(F_DATADAL, fp_db().sq_get_date(DRD_DATADA), row);
		sf.set_row_cell(F_DATAAL, fp_db().sq_get_date(DRD_DATAA), row);
		sf.set_row_cell(F_USER, fp_db().sq_get(DRD_UTENTE), row);

		TString s = fp_db().sq_get(DRD_STATO);
		s << " - " << TArchiviazioneIntegrazioni::traduci_stato(fp_db().sq_get(DRD_STATO));
		sf.set_row_cell(F_STATESTR, s, row);
		sf.set_row_cell(F_DESCR_E, fp_db().sq_get(DRD_DESC), row);
	}
	sf.force_update();

}

void TArchInt_mask::delete_estr_fld(const TString& idestr)
{
	TFilename dir(F9CONF.get_addr_doc_loc());

	if (dexist(dir))
	{
		dir << SLASH << F9CONF.get_ambiente() << SLASH << idestr << SLASH << "*";
		remove_files(dir, true);
	}
}

void TArchInt_mask::delete_pack(const bool all) 
{
	// Se nello sheet non c'e' selezionata alcuna riga viene richiamata col flag all = true
	bool flag = false;
	TSheet_field& sf = sfield(S_ELAB);
	FOR_EACH_SHEET_ROW(sf, nr, row)
	{
		if (row->get(0)[0] == 'X' || all)
		{
			flag = true;
			const TString id_estr(row->get(cid2index(F_IDESTR)));
			TString query;
			const TString& codsoc(F9CONF.get_ambiente());
			query << "BEGIN\n"
				"  DECLARE @flag_prov CHAR(1), @stato CHAR(2);\n\n"
				"  SELECT @flag_prov = " DRD_FLAG_PD ", @stato = " DRD_STATO "\n"
				"  FROM " F9_DRD "\n"
				"  WHERE " DRD_ID_EST " = '" << id_estr << "';\n\n"
				"  IF (@flag_prov = 'P' OR @stato = '" D_GEST_ERR "' OR @stato = '" IN_DIAGN "' OR @stato = '" D_WA_ERR "' OR @stato = '" D_ERR_SOS "') BEGIN\n"
				"    DELETE FROM " F9_ERR " WHERE " ERR_CODSOC " = '" << codsoc << "' AND " ERR_IDESTR " = '" << id_estr << "';\n"
				"  END\n"
				"  ELSE BEGIN\n"
				"    SELECT @flag_prov AS FLAG, @stato AS STATO;\n"
				"  END\n"
				"END";
			fp_db().sq_set_exec(query);
			// Elimino testata in DRD, solo se provvis.
			query.cut(0) << "BEGIN\n"
				" DECLARE @flag_prov CHAR(1), @stato CHAR(2);\n\n"
				" SELECT @flag_prov = " DRD_FLAG_PD ", @stato = " DRD_STATO "\n"
				" FROM " F9_DRD "\n"
				" WHERE " DRD_ID_EST " = '" << id_estr << "';\n\n"
				" IF (@flag_prov = 'P' OR @stato = '" D_GEST_ERR "' OR @stato = '" IN_DIAGN "' OR @stato = '" D_WA_ERR "' OR @stato = '" D_ERR_SOS "') BEGIN\n"
				"   DELETE FROM " F9_DRD      " WHERE " DRD_CODSOC " = '" << codsoc << "' AND " DRD_ID_EST " = '" << id_estr << "';\n"
				"   DELETE FROM " F9_IVA      " WHERE " IVA_CODSOC " = '" << codsoc << "' AND " IVA_IDLAN  " = '" << id_estr << "';\n"
				"   DELETE FROM " F9_MOVESTR  " WHERE " MES_CODSOC " = '" << codsoc << "' AND " MES_IDESTR " = '" << id_estr << "';\n"
				" END\n"
				" SELECT @flag_prov AS FLAG, @stato AS STATO;\n"
				"END";
			fp_db().sq_set_exec(query);
			TString stato = fp_db().sq_get("STATO");
			if (fp_db().sq_get("FLAG") != "P" && stato != D_GEST_ERR && stato != IN_DIAGN && stato != D_WA_ERR && stato != D_ERR_SOS && !all)
			{
				warning_box("E' possibile eliminare solo un'estrazione provvisoria\no in uno degli stati di errore se definitiva (02 - 05 - 08).");
				return;
			}
			fp_db().sq_commit();

			// DA VEDERE
			delete_estr_fld(id_estr);

			if (!all)
				break;
		}
	}
	if (!flag)
	{
		if (noyes_box("Eliminare tutti i pacchetti provvisori o in stato di errore gestionale?"))
			delete_pack(true);
	}
	fill();
}

void TArchInt_mask::controllo_errori()
{
	TString       id_estr, stato;
	TSheet_field& sf = sfield(S_ELAB);
	bool          flag = false;
	FOR_EACH_SHEET_ROW(sf, nr, row)
	{
		if (row->get(0)[0] == 'X')
		{
			id_estr << row->get(cid2index(F_IDESTR));
			stato << row->get(cid2index(F_STATESTR));
			flag = true;
			break;
		}
	}
	if (flag)
	{
		if (stato.cut(2) == D_GEST_ERR)
		{
			TControlloIntegrazioni_mask controllo(F9CONF.get_ambiente(), id_estr);
			controllo.run();
		}
		else
			warning_box("Impossibile controllare un'estrazione che non e'\nin stato di %s ('" D_GEST_ERR "').", TArchiviazioneIntegrazioni::traduci_stato(D_GEST_ERR));
	}
	else
		warning_box("Selezionare un'estrazione.");
}

void TArchInt_mask::open_win_estr()
{
	if (!F9CONF.get_ambiente().full())
		warning_box("Inserire codice ambiente societa' in configurazione");
	else f9Int_app().run_estr_msk();
}

void TArchInt_mask::open_win_conf()
{
	TConfigIntf9_mask m("Configurazione Archiviazione Sostitutiva", 1, 70, 30, 55, 5);

	TLocalisamfile tabmod(LF_TABMOD);
	tabmod.put("MOD", "F9");
	tabmod.put("COD", "SQL");
	tabmod.put("CODTAB", "VERSION");
	const bool exists = tabmod.read() == NOERR;
	int version = exists ? real(tabmod.get(TABMOD_TABVER)).integer() : TAB_BASE_VERSION - 2;

	m.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
	m.add_button_tool(DLG_NULL, "", 0);
	m.add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);

	m.add_groupbox(CF_CODGROUP, 0, "Codice Ambiente Societa' (WEBAPP):", 1, 0, 69, 3, "");
	m.add_string(CF_CODSOC, 0, "Codice ambiente ", 4, 1, 10, "", 10);
	m.add_groupbox(CF_ADDRGROUP, 0, "Indicare percorso documenti cartacei:", 1, 3, 69, 4, "");
	m.add_string(CF_ADDRDOC, 0, "Server ", 2, 4, 256, "", 40);
	m.add_string(CF_ADDRDOCLOC, 0, "Locale ", 2, 5, 256, "", 40);
	m.add_groupbox(CF_ESTRGROUP, 0, "Opzioni estrazione", 1, 7, 69, 4, "");
	m.add_boolean(CF_CARTEXP, 0, "Estrai anche documenti cartacei", 2, 8);
	m.add_groupbox(CF_LVLGROUP, 0, "Livello Patch Tabelle F9", 1, 11, 69, 4, "");
	m.add_string(CF_LVLOLD, 0, "Livello Attuale", 35, 12, 10, "D", 10);
	m.add_string(CF_LVLNEW, 0, "Nuovo Livello  ", 2, 12, 10, "D", 10);
	m.set_handlers();

	m.set(CF_CODSOC, F9CONF.get_ambiente());
	m.set(CF_ADDRDOC, F9CONF.get_addr_doc());
	m.set(CF_ADDRDOCLOC, F9CONF.get_addr_doc_loc());
	m.set(CF_CARTEXP, F9CONF.get_has_cartexp());
	m.set(CF_LVLOLD, version);


	m.disable(CF_LVLOLD);
	if (m.run() == K_ENTER)
		save_conf(m);

}

bool TArchInt_mask::save_conf(TMask& config_mask)
{
	TString old_codsoc = F9CONF.get_ambiente();

	TString new_lvl = config_mask.get(CF_LVLNEW);
	TString old_lvl = config_mask.get(CF_LVLOLD);

	if (config_mask.get(CF_CODSOC).empty())
		warning_box("Codice Ambiente vuoto. Impossibile salvare i dati.");
	F9CONF.set_ambiente(config_mask.get(CF_CODSOC));
	F9CONF.set_addr_doc(config_mask.get(CF_ADDRDOC));
	F9CONF.set_addr_doc_loc(config_mask.get(CF_ADDRDOCLOC));
	F9CONF.set_has_cartexp(config_mask.get_bool(CF_CARTEXP));

	config_mask.close();
	//f9Int_app().edit_wa(old_codsoc);
	if (new_lvl.full() && (new_lvl != old_lvl))
	{
		TLocalisamfile tabmod(LF_TABMOD);
		tabmod.put("MOD", "F9");
		tabmod.put("COD", "SQL");
		tabmod.put("CODTAB", "VERSION");
		tabmod.put("S0", real(new_lvl));

		if (tabmod.write_rewrite() == NOERR)
		{
			config_mask.set(CF_LVLOLD, new_lvl);
			config_mask.set(CF_LVLNEW, "");
			message_box("Versione impostata!");
		}
		else
			return error_box("Impossibile aggiornare il livello degli archivi");
	}
	return true;
}

TArchInt_mask::TArchInt_mask() : TAutomask("f90600a")
{
	int i = 0;
	// Controllo che esistano delle categorie documentali.
	fill();
}


/////////////////////////////////////////////////////////
// Tf9IntEstrai_mask
////////////////////////////////////////////////////////

int Tf9IntEstrai_mask::estrai()
{
	const TDate dataini = get_dataini();
	const TDate dataend = get_dataend();
	const char  tipodoc = get_tipodoc();
	const bool  flagpro = is_provviso();
	TFilename path;
	TLog_report log("Log estrazione");

	//f9_app().get_spotlite_path(path);



	// Vero e proprio oggetto estrazione
	_estrazione = new TEstrazione(
		F9CONF.get_ambiente(),      // Codice ambiente
		flagpro,                    // Flag prov.
		tipodoc,                    // Tipo doc.
		get_descr(),                // Descrizione estrazione
		F9CONF.get_addr_doc(),      // Cartella documenti
		false,                      // Estrazione di un escluso
		path,                       // Spotlight path
		&log,												// Log
		&dataini,                   // Data estr. mov dal
		&dataend,                   // Data estr. mov al
		F9CONF.get_has_cartexp()    // Flag per estrarre anche i doc. cartacei
	);

	const TString& doc_sdi = get(ES_DOCSDI);

	// Leggo i movimenti e li carico nell'estrazione. /////////////
	TString query;

	query = "USE MOV KEY 2";
	query << "\nFROM DATAREG=" << dataini.date2ansi() << "\nTO DATAREG=" << dataend.date2ansi();

	TISAM_recordset mov(query);
	TProgress_monitor*  progr = new TProgress_monitor(mov.items(), "Acquisizione movimenti", false);
	TLocalisamfile      clifo(LF_CLIFO);
	const TipoIVA       tipo = tipodoc == 'A' ? iva_acquisti : iva_vendite;
	int count = 0;
	// Prendo tutti i movimenti a partire da una data e li carico tutti fino alla data finale

	TToken_string caus_list = select_causali(doc_sdi, tipodoc);

	for (bool ok = mov.move_first(); progr->add_status() && ok; ok = mov.move_next())
	{
		const TString& cod_cau = mov.get_string(MOV_CODCAUS);
		if (causale_in_lista(cod_cau, caus_list)) 
		{
			TToken_string     elab_f9(mov.get_string(MOV_ELABF9), ';'); // Stringa del campo elaborazione f9 nel file mov
			bool							escluso = (elab_f9.items() == 3 && elab_f9.get_bool(2));
			const TCausale &  caus = cached_causale(mov.get_string(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year());
			const bool        stampato = mov.get_bool(MOV_REGST);
			const TRegistro&  reg = caus.reg();
			const TipoIVA&    iva = reg.iva();
			TString numdoc = mov.get_string(MOV_NUMDOCEXT);
			long nreg = mov.get_long(MOV_NUMREG);

			if (numdoc.blank())
				numdoc = mov.get_string(MOV_NUMDOC);
			// Se definitivo controllo il flag di stampato REGST
			if ((flagpro || stampato) && numdoc.full())
			{
				// Creo il movimento da inserire e lo inserisco
				_estrazione->add_mov(new TMovimento_estr(mov, tipo, escluso));
				++count;
			}
		}
	}
	delete progr;
	
	_stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0,0,0,0 };
	// Effettiva estrazione. Faccio partire diagnostica e scrittura db.
	const result_estr result = _estrazione->estrai_integrazioni();

	//LAVORO SULLE STAT
	int tot;

	tot = (int)_stats.int_match + (int)_stats.int_nomatch + (int)_stats.int_err;

	TString msg;
	msg << "Tot. Docs : " << tot << "\n";


	msg << "Mov. Integrazione estratti  :  " << (int)_stats.int_match << "\n";
	msg << "Mov. Integrazione XML non trovato:  " << (int)_stats.int_nomatch << "\n";
	msg << "Mov. Integrazione in errore   :  " << (int)_stats.int_err;
	message_box(msg);

	return result;
}

bool Tf9IntEstrai_mask::causale_in_lista(const TString& cod_cau, TToken_string cau_list)
{
	bool in_list = false;
	int a = cau_list.items(); //da rimuovere
	for (int i = 0; i < cau_list.items(); i++) 
	{
		TString prov = cau_list.get(i); //dr
		if (cod_cau == cau_list.get(i)) 
		{
			in_list = true;
			break;
		}
	}
	return in_list;
}

TToken_string Tf9IntEstrai_mask::select_causali(const TString& tipo_sdi, const char reg)
{
	TCursor cur(new TRelation(LF_CAUSALI));
	TToken_string caus_list;

	const int items = cur.items();

	for (cur.first_item(); cur.pos() < items; cur.succ_item())
	{
		const TRectype& rec = cur.curr();

		if (reg == 'V')
		{
			const TString& tipodocsdi = rec.get(CAU_TIPODOCSDI);
			if ((tipo_sdi == "T" && tipodocsdi.full()) || tipodocsdi == tipo_sdi)
				caus_list.add(rec.get(CAU_CODCAUS));
		}
		else if (reg == 'A')
		{
			if (rec.get(CAU_CODCAUREG).full())
			{
				const TCausale & caus_coll = cached_causale(rec.get(CAU_CODCAUREG), get_date(ES_DATAEND).year());
				const TString& tipodocsdi = caus_coll.tipodocsdi();
				if ((tipo_sdi == "T" && tipodocsdi.full()) || tipodocsdi == tipo_sdi)
					caus_list.add(rec.get(CAU_CODCAUS));
			}
		}

	}
	return caus_list;
}

bool Tf9IntEstrai_mask::estrai_handler(TMask_field& f, KEY key)
{
	Tf9IntEstrai_mask& msk = (Tf9IntEstrai_mask&)f.mask();
	TArchiviazioneIntegrazioni&      app = f9Int_app();

	// Estraggo
	const int stato = msk.estrai();   // Main function

	// Gestione risultato estrazione
	if (stato == 1)
	{
		message_box("Estrazione avvenuta con successo!");
		//app.segna_estratti();
	}
	if (stato == 0 || stato == -3)
	{
		warning_box("L'estrazione non e' stata completata. Controllare il log degli errori.");
		//if (stato == 0)           // Errore scrittura F9IVA, non segno in errore in testata...
			//msk.segna_in_errore();  // ... se l'errore e' dovuto alla scrittura sul db.
	}
	msk.field(ES_DESCR).set("");
	msk.stop_run(K_FORCE_CLOSE);
	return true;
}

Tf9IntEstrai_mask::Tf9IntEstrai_mask() : TMask("Estrazione", 1, 60, 18), _estrazione(nullptr)
{
	add_button_tool(DLG_ELABORA, "Estrai", TOOL_ELABORA);
	add_button_tool(DLG_NULL, "", 0);
	add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);

	add_groupbox(ES_DATEGROUP, 0, "Inserire periodo per estrazione:", 1, 0, 59, 3, "");
	add_date(ES_DATAINI, 0, "dal", 4, 1, "");
	add_date(ES_DATAEND, 0, " al", 33, 1, "");
	add_groupbox(ES_FLAGGROUP, 0, "Selezionare tipo di estrazione:", 1, 3, 28, 3, "");
	add_list(ES_FLAGPROV, 0, "Flag provvisorio", 2, 4, 1, "", "P|D", "Provvisorio|Definitivo");
	add_groupbox(ES_TIPOGROUP, 0, "Selezionare documenti da estrarre:", 32, 3, 28, 4, "");
	add_list(ES_TIPODOC, 0, "Tipi documento", 33, 4, 1, "", "A|V", "Acquisti|Vendite");
	add_list(ES_DOCSDI, 0, "Tipi doc SDI", 33, 5, 5, "", "T|TD16|TD17|TD18|TD19|TD28",
		"TUTTI|TD16 Integ. rev. chrg|TD17 Integ. servizi estero|TD18 Integ. beni intracom.|TD19 Integ. beni ex art. 17|TD28 Fatt. cartacea S.Marino");
	add_groupbox(ES_DESCGROUP, 0, "Inserire descrizione estrazione:", 1, 7, 59, 3, "");
	add_string(ES_DESCR, 0, "Descrizione", 2, 8, 250, "", 40);


	set_handler(DLG_ELABORA, estrai_handler);
	//set_handler(ES_DATAINI, dataini_handler);
	//set_handler(ES_DATAEND, dataend_handler);

	TDate dt(TODAY); dt.set_day(1); dt.set_month(1);

	set(ES_DATAINI, dt);
	set(ES_DATAEND, today);
}


////////////////////////////////////////////////////////
// TControlloIntegrazioni_mask
////////////////////////////////////////////////////////

void TControlloIntegrazioni_mask::associa()   // todo: levare gli ultimi residui del vecchio funzionamento del controllo errori
{
	TToken_string* mov_sel = selected_mov();
	TToken_string* fat_sel = selected_fat();
	if (mov_sel == nullptr || fat_sel == nullptr)
	{
		warning_box("Selezionare prima un movimento e una fattura elettronica.");
		return;
	}

	int numreg = mov_sel->get_int(cid2index(F_CNUMREG));
	TRectype &  mov = (TRectype &)cache().get(LF_MOV, numreg);
	
	
	TToken_string keys(fat_sel->get(cid2index(F_FPROKEYS)), ';');
	bool ok = true;
	char c = _tipo_doc_err;

	//DAT CAPIRE  COME TIRARE FUORI TIPO IVA ESTR
	if (_tipo_doc_err == 'A') 
	{
		ok &= associa_int_acq(mov_sel->get_int(cid2index(F_CNUMREG)), keys);
	}
	else 
	{
		ok &= associa_int_ven(mov_sel->get_int(cid2index(F_CNUMREG)), keys);
	}

	if (ok)
	{
		// Tolgo il flag di in errore sul vettore in modo da rifare la fill e non venir piu' contato come da controllare
		int   count = -1;

		FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
			if (count < _selected_mov && row->get_bool(0)) // Devo saltare tutti quelli che non hanno il flag e contare solo quelli che ce l'hanno
				count++;
		dberr_del_err(_cod_soc, _id_estr, mov_sel->get_int(cid2index(F_CNUMREG)));
	}
}

bool TControlloIntegrazioni_mask::associa_int_ven(const long numreg, TToken_string key_paf)
{
	TRectype &  mov = (TRectype &)cache().get(LF_MOV, numreg);
	bool ok = mov.full();
	ok &= key_paf.full();

	if (ok) 	// Scrivo sul movimento il riferimento al fppro
	{
		//mov.put(MOV_IDDOCSDI, fppro_db().get_numdoc());
		//mov.put(MOV_DATADOCSDI, fppro_db().get_datadoc());
		mov.put(MOV_KEYPAF, key_paf);
		ok = mov.rewrite() == NOERR;
	}
	else   // Se la scrittura sul db fallisce levo sul movimento il riferimento all'fppro
	{
		//mov.zero(MOV_IDDOCSDI);
		//mov.zero(MOV_DATADOCSDI);
		mov.zero(MOV_KEYPAF);
		mov.rewrite();
	}
	return ok;
}

bool TControlloIntegrazioni_mask::associa_int_acq(const long numreg, TToken_string key_fppro)
{
	TRectype &  mov = (TRectype &)cache().get(LF_MOV, numreg);
	bool ok = mov.full();
	ok &= key_fppro.full();

	if (ok) 	// Scrivo sul movimento il riferimento al fppro
	{
		//mov.put(MOV_IDDOCSDI, fppro_db().get_numdoc());
		//mov.put(MOV_DATADOCSDI, fppro_db().get_datadoc());
		mov.put(MOV_KEYFPPRO, key_fppro);
		ok = mov.rewrite() == NOERR;
	}
	else   // Se la scrittura sul db fallisce levo sul movimento il riferimento all'fppro
	{
		//mov.zero(MOV_IDDOCSDI);
		//mov.zero(MOV_DATADOCSDI);
		mov.zero(MOV_KEYFPPRO);
		mov.rewrite();
	}
	return ok;
}

void TControlloIntegrazioni_mask::conferma_esclusi() const
{
	const TMask& mask = *this;
	TSheet_field& sf = mask.sfield(S_CONTROLLO);

	FOR_EACH_SHEET_ROW_LOOP(sf, row)
	{
		const long nreg = sf.get_long_row_cell(row, F_CNUMREG);
		TRectype & movs = (TRectype&)cache().get(LF_MOV, nreg);

		if (sf.get_bool_row_cell(row, F_CESCLUDI))
		{
			TToken_string stato("", ';');

			stato.add("", 0);
			stato.add(today.date2ansi());
			stato.add("X");
			movs.put(MOV_ELABF9, stato);
			movs.rewrite();
			sf.set_row_cell(F_CESCLUSO, "Si", row);

			TString query;

			query << "UPDATE " F9_ERR " SET ESCLUSO = 'Si' WHERE " ERR_CODSOC " = '" << _cod_soc << "' AND IDESTR = '" <<
				_id_estr << "' AND NUMREG = '" << nreg << "';";
			fp_db().sq_set_exec(query);
			fp_db().sq_commit();
		}
		else
		{
			if (movs.get(MOV_ELABF9).full())
			{
				movs.put(MOV_ELABF9, "");
				sf.set_row_cell(F_CESCLUSO, "", row);

				movs.rewrite();
				TString query;
				query << "UPDATE " F9_ERR " SET ESCLUSO = NULL WHERE " ERR_CODSOC " = '" << _cod_soc << "' AND IDESTR = '" <<
					_id_estr << "' AND NUMREG = '" << nreg << "';";
				fp_db().sq_set_exec(query);
				fp_db().sq_commit();
			}
		}
	}
	sf.force_update();
	sf.show();
}

TToken_string* TControlloIntegrazioni_mask::selected_mov()
{
	TSheet_field& movs = sfield(S_CONTROLLO);
	FOR_EACH_SHEET_ROW(movs, nr, row)
	{
		if (row->get(0)[0] == 'X')
		{
			_selected_mov = nr;
			return row;
		}
	}
	return nullptr;
}

TToken_string* TControlloIntegrazioni_mask::selected_fat() const
{
	TSheet_field& fppro = sfield(S_FPPRO);
	FOR_EACH_SHEET_ROW(fppro, nr, row)
	{
		if (row->get(0)[0] == 'X')
			return row;
	}
	return nullptr;
}

TArray& TControlloIntegrazioni_mask::import_error_list()
{
	_tipo_doc_err = dberr_get_err(_cod_soc, _id_estr, _controllo_mov);
	return _controllo_mov;
}

void TControlloIntegrazioni_mask::fill_sheets()
{
	TSheet_field& sf = sfield(S_CONTROLLO);

	sf.reset();
	if (!_is_escluso)
		import_error_list();
	else
		_controllo_mov = f9Int_app().esclusi();
	FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
	{
		TToken_string& sfrow = sf.row(-1);
		if (row->get_bool(0))
		{
			sfrow = *row;
			sf.set_row_cell(101, false, r);
		}
	}
	sf.force_update();
	// Fill fppro sheet

	if (_tipo_doc_err == 'A') 
		fill_fppro_sheet();
	else
		fill_pafw300_sheet();


}

void TControlloIntegrazioni_mask::fill_pafw300_sheet(bool filter)
{
	TSheet_field& sf = sfield(S_FPPRO);

	sf.reset();
	const char* order;
	switch (_ordin)
	{
	default:
	case 'D': order = "P7_DATA";        break;
	case 'N': order = "P7_NUMERO";      break;
	case 'F': order = "FORNITORE";      break;
	case 'R': order = "P2_ANADENOMIN";  break;
	case 'P': order = "P2_FISCIVACOD";  break;
	}
	TString query;
	query << "SELECT PQ_KEYPRGINVIO AS KEYPRGINVIO, PQ_KEYHEADERFATT AS KEYHEADERFATT, PQ_KEYBODYFATT AS KEYBODYFATT,\n" <<
		"PW_TIPODOC AS TIPODOC, P7_DATA AS DATA, P7_NUMERO AS NUMDOC, PQ_IMPTOTDOC AS IMPTOTDOC,\n" <<
		"PW_RAGSOC AS CLIENTE, " <<
		"P2_ANADENOMIN AS RAGSOC, P2_FISCIVAPAESE AS STATOPIVA, P2_FISCIVACOD AS PIVA FROM PAF2700F\n" <<
		"JOIN PAF0700F ON PQ_KEYPRGINVIO = P7_KEYPRGINVIO AND PQ_KEYHEADERFATT = P7_KEYHEADERFATT AND PQ_KEYBODYFATT = P7_KEYBODYFATT\n" <<
		"JOIN PAF0200F ON PQ_KEYPRGINVIO = P2_KEYPRGINVIO AND PQ_KEYHEADERFATT = P2_KEYHEADERFATT AND PQ_KEYBODYFATT = P2_KEYBODYFATT\n" <<
		"JOIN PAFW300F ON PQ_KEYPRGINVIO = PW_KEYPRGINVIO AND PQ_KEYHEADERFATT = PW_KEYHEADERFATT AND PQ_KEYBODYFATT = PW_KEYBODYFATT\n" <<
		"WHERE PW_DATA > '20211201'" << "\n";

	if (filter)
	{
		if (!_flt_da_data.empty())
			query << "AND PW_DATA >= '" << _flt_da_data.date2ansi() << "'";
		else
			query << "AND PW_DATA >= '20010101'";

		if (!_flt_a_data.empty())
			query << "AND PW_DATA <= '" << _flt_a_data.date2ansi() << "'\n";
		else
			query << "AND PW_DATA <= '" << today.date2ansi() << "'\n";

		if (!_flt_tipodoc.empty())
			query << "AND PW_TIPODOC = '" << _flt_tipodoc << "'\n";
		if (!_flt_numdoc.empty())
			query << "AND P7_NUMERO like '%" << _flt_numdoc << "%'\n";
		if (!_flt_tot_doc_da.is_zero())
			query << "AND PQ_IMPTOTDOC >= '" << _flt_tot_doc_da << "'\n";
		if (!_flt_tot_doc_a.is_zero())
			query << "AND PQ_IMPTOTDOC <= '" << _flt_tot_doc_a << "'\n";
		if (!_flt_ragsoc.empty())
			query << "AND P2_ANADENOMIN like '%" << _flt_ragsoc << "%'\n";
		if (!_flt_codforn.empty())
			query << "AND PW_RAGSOC = '" << _flt_codforn << "'\n";
		if (!_flt_piva.empty())
			query << "AND P2_FISCIVACOD = '" << _flt_piva << "'\n";
	}

	query << "ORDER BY " << order << " " << (_verso == 'A' ? "ASC" : "DESC") << "\n";
	fp_db().sq_set_exec(query, false);

	for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
	{
		const int row = sf.set_row_cell(F_FTIPODOC, fp_db().sq_get("TIPODOC"));

		sf.set_row_cell(F_FDATA, fp_db().sq_get_date("DATA"), row);
		sf.set_row_cell(F_FNUMDOC, fp_db().sq_get("NUMDOC"), row);
		sf.set_row_cell(F_FIMPTOTDOC, fp_db().sq_get("IMPTOTDOC"), row);
		sf.set_row_cell(F_FFORNITORE, fp_db().sq_get("CLIENTE"), row);
		sf.set_row_cell(F_FRAGSOC, fp_db().sq_get("RAGSOC"), row);
		sf.set_row_cell(F_FSTATOPIVA, fp_db().sq_get("STATOPIVA"), row);
		sf.set_row_cell(F_FPIVA, fp_db().sq_get("PIVA"), row);
		TString s = fp_db().sq_get("KEYPRGINVIO");
		s << ";" << fp_db().sq_get("KEYHEADERFATT") << ";" << fp_db().sq_get("KEYBODYFATT");
		sf.set_row_cell(F_FPROKEYS, s, row);

	}
	sf.force_update();
}

void TControlloIntegrazioni_mask::fill_fppro_sheet(bool filter)
{
	TSheet_field& sf = sfield(S_FPPRO);

	sf.reset();
	const char* order;
	switch (_ordin)
	{
	default:
	case 'D': order = "P7_DATA";        break;
	case 'N': order = "P7_NUMERO";      break;
	case 'F': order = "FORNITORE";      break;
	case 'R': order = "P2_ANADENOMIN";  break;
	case 'P': order = "P2_FISCIVACOD";  break;
	}
	TString query;
	query << "SELECT PQ_KEYPRGINVIO AS KEYPRGINVIO, PQ_KEYHEADERFATT AS KEYHEADERFATT, PQ_KEYBODYFATT AS KEYBODYFATT,\n" <<
		"PZ_TIPODOC AS TIPODOC, P7_DATA AS DATA, P7_NUMERO AS NUMDOC, PQ_IMPTOTDOC AS IMPTOTDOC,\n" <<
		"PZ_CLIFOR AS FORNITORE, " <<
		"P2_ANADENOMIN AS RAGSOC, P2_FISCIVAPAESE AS STATOPIVA, P2_FISCIVACOD AS PIVA FROM PAA2700F\n" <<
		"JOIN PAA0700F ON PQ_KEYPRGINVIO = P7_KEYPRGINVIO AND PQ_KEYHEADERFATT = P7_KEYHEADERFATT AND PQ_KEYBODYFATT = P7_KEYBODYFATT\n" <<
		"JOIN PAA0200F ON PQ_KEYPRGINVIO = P2_KEYPRGINVIO AND PQ_KEYHEADERFATT = P2_KEYHEADERFATT AND PQ_KEYBODYFATT = P2_KEYBODYFATT\n" <<
		"JOIN FPPRO00F ON PQ_KEYPRGINVIO = PZ_KEYPRGINVIO AND PQ_KEYHEADERFATT = PZ_KEYHEADERFATT AND PQ_KEYBODYFATT = PZ_KEYBODYFATT\n" <<
		"WHERE PZ_DATA > '20211201'" << "\n";

	if (filter)
	{
		if (!_flt_da_data.empty())
			query << "AND P7_DATA >= '" << _flt_da_data.date2ansi() << "'";
		else
			query << "AND P7_DATA >= '20010101'";

		if (!_flt_a_data.empty())
			query << "AND P7_DATA <= '" << _flt_a_data.date2ansi() << "'\n";
		else
			query << "AND P7_DATA <= '" << today.date2ansi() << "'\n";

		if (!_flt_tipodoc.empty())
			query << "AND PZ_TIPODOC = '" << _flt_tipodoc << "'\n";
		if (!_flt_numdoc.empty())
			query << "AND P7_NUMERO like '%" << _flt_numdoc << "%'\n";
		if (!_flt_tot_doc_da.is_zero())
			query << "AND PQ_IMPTOTDOC >= '" << _flt_tot_doc_da << "'\n";
		if (!_flt_tot_doc_a.is_zero())
			query << "AND PQ_IMPTOTDOC <= '" << _flt_tot_doc_a << "'\n";
		if (!_flt_ragsoc.empty())
			query << "AND P2_ANADENOMIN like '%" << _flt_ragsoc << "%'\n";
		if (!_flt_codforn.empty())
			query << "AND PZ_CLIFOR = '" << _flt_codforn << "'\n";
		if (!_flt_piva.empty())
			query << "AND P2_FISCIVACOD = '" << _flt_piva << "'\n";
	}

	query << "ORDER BY " << order << " " << (_verso == 'A' ? "ASC" : "DESC") << "\n";
	fp_db().sq_set_exec(query, false);

	for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
	{
		const int row = sf.set_row_cell(F_FTIPODOC, fp_db().sq_get("TIPODOC"));

		sf.set_row_cell(F_FDATA, fp_db().sq_get_date("DATA"), row);
		sf.set_row_cell(F_FNUMDOC, fp_db().sq_get("NUMDOC"), row);
		sf.set_row_cell(F_FIMPTOTDOC, fp_db().sq_get("IMPTOTDOC"), row);
		sf.set_row_cell(F_FFORNITORE, fp_db().sq_get("CLIENTE"), row);
		sf.set_row_cell(F_FRAGSOC, fp_db().sq_get("RAGSOC"), row);
		sf.set_row_cell(F_FSTATOPIVA, fp_db().sq_get("STATOPIVA"), row);
		sf.set_row_cell(F_FPIVA, fp_db().sq_get("PIVA"), row);
		TString s = fp_db().sq_get("KEYPRGINVIO");
		s << ";" << fp_db().sq_get("KEYHEADERFATT") << ";" << fp_db().sq_get("KEYBODYFATT");
		sf.set_row_cell(F_FPROKEYS, s, row);

	}
	sf.force_update();
}

void TControlloIntegrazioni_mask::open_win_filter()
{
	TMask& m = get_win_filter();
	m.set(F_FLTDATADA, _flt_da_data);
	m.set(F_FLTDATAA, _flt_a_data);

	m.run();

	_flt_da_data = m.get_date(F_FLTDATADA);
	_flt_a_data = m.get_date(F_FLTDATAA);

	_flt_tipodoc = m.get(F_FLTTIPODOC);
	_flt_numdoc = m.get(F_FLTNUMDOC);
	_flt_tot_doc_da = m.get_real(F_FLTTOTDOCDA);
	_flt_tot_doc_a = m.get_real(F_FLTTOTDOCA);

	//_flt_codforn = m.get(F_FLTCODFORN);
	_flt_ragsoc = m.get(F_FLTRAGSOC);
	_flt_piva = m.get(F_FLTPIVA);

	//Ordinamento
	_ordin = m.get(F_ORDER)[0];
	_verso = m.get(F_VERSO)[0];
	ini_set_string(CONFIG_DITTA, INI_PAR_MOD, "ORDINAM", &_ordin);
	ini_set_string(CONFIG_DITTA, INI_PAR_MOD, "VERSO", &_verso);
}

TMask& TControlloIntegrazioni_mask::get_win_filter()
{
	TMask* m = nullptr;

	if (m == nullptr)
	{
		m = new TMask("Filtro griglia FPPRO", 1, 65, 36, 60, 2);

		// TOOLBAR
		m->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
		m->add_button_tool(DLG_NULL, "", 0);
		//m->add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);

		// Filtro Documenti
		m->add_groupbox(F_FLTDOCGRP, 0, "@BFiltra sui parametri del documento", 1, 1, 59, 5);
		m->add_list(F_FLTTIPODOC, 0, "TIPO DOC.  ", 2, 2, 8, "",
			"|TD01|TD02|TD03|TD04|TD05|TD06|TD07|TD08|TD10|TD11|TD16|TD17|TD18|TD19|TD20|TD21|TD22|TD23|TD24|TD25|TD26|TD27|TD28",
			"|TD01|TD02|TD03|TD04|TD05|TD06|TD07|TD08|TD10|TD11|TD16|TD17|TD18|TD19|TD20|TD21|TD22|TD23|TD24|TD25|TD26|TD27|TD28");
		m->add_string(F_FLTNUMDOC, 0, "NUM.DOC.", 30, 2, 8);
		m->add_string(F_FLTTOTDOCDA, 0, "TOT.DOC. DA", 2, 3, 8);
		m->add_string(F_FLTTOTDOCA, 0, "A  ", 10, 4, 8);

		// Filtro date
		m->add_groupbox(F_FLTDATAGRP, 0, "@BFiltra per data documento", 1, 6, 59, 3);
		m->add_date(F_FLTDATADA, 0, "DATA DOC. DAL", 2, 7);
		m->add_date(F_FLTDATAA, 0, " AL", 30, 7);

		// Filtro per fornitore
		m->add_groupbox(F_FLTFORNGRP, 0, "@BFiltra per parametri fornitore", 1, 9, 59, 4);
		//m->add_string(F_FLTCODFORN, 0, "CODICE  ", 2, 10, 8);
		m->add_string(F_FLTPIVA, 0, "P.IVA", 30, 10, 15);
		m->add_string(F_FLTRAGSOC, 0, "RAG.SOC.", 2, 11, 48);

		// Ordinatori
		m->add_radio(F_ORDER, 0, "@BOrdina per:", 1, 13, 59, "D|N|F|R|P", "DATA|NUMDOC|FORNITORE|RAGSOC|PIVA", "Z");
		m->add_radio(F_VERSO, 0, "@BVerso:", 1, 16, 59, "A|D", "Crescente|Decrescente", "Z");

		//m->set_handler(DLG_OK, save_conf_handler);
		_ordin = ini_get_string(CONFIG_DITTA, INI_PAR_MOD, "ORDINAM", "D")[0];
		_verso = ini_get_string(CONFIG_DITTA, INI_PAR_MOD, "VERSO", "A")[0];

		m->set(F_FLTDATADA, _flt_da_data);
		m->set(F_FLTDATAA, _flt_a_data);
		m->set(F_FLTDATAA, _flt_tipodoc);
		m->set(F_FLTNUMDOC, _flt_numdoc);
		m->set(F_FLTTOTDOCDA, _flt_tot_doc_da);
		m->set(F_FLTTOTDOCA, _flt_tot_doc_a);
		//m->set(F_FLTCODFORN, _flt_codforn);
		m->set(F_FLTPIVA, _flt_piva);
		m->set(F_FLTRAGSOC, _flt_ragsoc);
		m->set(F_ORDER, &_ordin);
		m->set(F_VERSO, &_verso);

	}
	return *m;
}

bool TControlloIntegrazioni_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case DLG_USER:
		if (e == fe_button && jolly > 0)
		{
			TSheet_field&   sf = sfield(S_CONTROLLO);
			TToken_string&  row = sf.row(sf.selected());
			TRectype        mov(LF_MOV);
			mov.put(MOV_NUMREG, row.get(sf.cid2index(F_CNUMREG)));
			//if (open_mov(mov))
				//fill();
		}
		break;
	case B_FILTER_CONF:
		if (e == fe_button)
		{
			open_win_filter();
			if (_tipo_doc_err == 'V')
				fill_pafw300_sheet(true);
			else
				fill_fppro_sheet(true);
			field(B_FILTER_OFF).enable();
			field(B_FILTER_ON).disable();
		}
		break;
	case B_FILTER_ON:
		if (e == fe_button)
		{
			if (_tipo_doc_err == 'V')
				fill_pafw300_sheet(true);
			else
				fill_fppro_sheet(true);
			field(B_FILTER_OFF).enable();
			field(B_FILTER_ON).disable();
		}
		break;
	case B_FILTER_OFF:
		if (e == fe_button)
		{
			if (_tipo_doc_err == 'V')
				fill_pafw300_sheet(false);
			else
				fill_fppro_sheet(false);
			field(B_FILTER_ON).enable();
			field(B_FILTER_OFF).disable();
		}
		break;
	case B_ASSOC:
		if (e == fe_button)
		{
			associa();
			fill_sheets();   // Ricarico gli sheet
		}
		break;
	case B_ESCL:
		if (e == fe_button)
		{
			conferma_esclusi();
			fill_sheets();
		}
		break;
	case B_SELESCL:
		if (e == fe_button)
		{
			_sel_esclusi = !_sel_esclusi;
			field(B_ASSOC).enable(!_sel_esclusi);
			field(B_ESCL).enable(_sel_esclusi);
			field(B_ALLESCL).enable(_sel_esclusi);
			sfield(S_CONTROLLO).enable_column(cid2index(F_CESCLUDI), _sel_esclusi);
			sfield(S_CONTROLLO).force_update();
		}
		break;
	case B_ALLESCL:
		if (e == fe_button)
		{
			TSheet_field& sf = sfield(S_CONTROLLO);
			sf.hide();
			const bool active = *sf.row(0).get(cid2index(F_CESCLUDI)) == 'X';
			FOR_EACH_SHEET_ROW(sf, nr, row)
				row->add(active ? " " : "X", cid2index(F_CESCLUDI));
			sf.force_update();
			sf.show();
		}
		break;
	case S_CONTROLLO:
		if (e == fe_init)
			sfield(S_CONTROLLO).enable_column(cid2index(F_CESCLUDI), false);
		break;
	case F_CSEL:
		if (e == fe_modify)
			//selfatt(o, jolly);
		break;
	default: break;
	}
	return true;
}

TControlloIntegrazioni_mask::TControlloIntegrazioni_mask(const char* codsoc, const char* id_estr, const bool esclusi)
	: TAutomask("f90600b"), _ordin('D'), _verso('A'), _selected_mov(0), _sel_esclusi(false)
{
	_cod_soc = codsoc;
	_id_estr = id_estr;
	field(B_ESCL).disable();
	field(B_ALLESCL).disable();
	_is_escluso = esclusi;

	field(B_FILTER_ON).disable();
	field(B_FILTER_OFF).disable();

	// Fill controllo sheet
	if (!_is_escluso)
		import_error_list();
	else
		_controllo_mov = f9Int_app().esclusi();

	_datada = EOTIME;
	_dataa = 0L;
	FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
	{
		if (row->get_bool(0))
		{
			const TDate& d = row->get_date(3);

			if (d < _datada)
				_datada = d;
			if (d > _dataa)
				_dataa = d;
		}
	}
	fill_sheets();
}


////////////////////////////////////////////////////////
// TApri_pacchetto_msk
////////////////////////////////////////////////////////

void TApri_pacchetto_msk::conferma_esclusi() const
{
	TSheet_field& sf = sfield(S_INCL);

	FOR_EACH_SHEET_ROW_LOOP(sf, row)
	{
		const long nreg = sf.get_long_row_cell(row, FI_NUMREG);
		TRectype & movs = (TRectype&)cache().get(LF_MOV, nreg);
		const TString & da_escludere = sf.get_str_row_cell(row, FI_IESCLUDI);

		if (da_escludere == "S")
		{
			TToken_string stato("", ';');

			stato.add("", 0);
			stato.add(today.date2ansi());
			stato.add("X");
			movs.put(MOV_ELABF9, stato);
			movs.rewrite();
			sf.set_row_cell(FI_IESCLUSO, true, row);
		}
		else
		{
			if (movs.get(MOV_ELABF9).full())
			{
				movs.zero(MOV_ELABF9);
				sf.set_row_cell(FI_IESCLUSO, false, row);
				movs.rewrite();
			}
		}
	}
	sf.force_update();
}

bool TApri_pacchetto_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case DLG_USER:
		if (e == fe_button)
		{
			TSheet_field& sf = sfield(S_INCL);
			TToken_string& row = sf.row(sf.selected());
			TRectype mov(LF_MOV);
			mov.put(MOV_NUMREG, row.get(sf.cid2index(FI_NUMREG)));
			//open_mov(mov);
		}
		break;
	case B_ISELESCL:
		if (e == fe_button)
		{
			static bool sel_esclusi = false;
			if (_provv || TArchiviazioneIntegrazioni::is_stato_errore(_statoestr))
			{
				sel_esclusi = !sel_esclusi;
				field(B_IESCL).enable(sel_esclusi);
				field(B_IALLESCL).enable(sel_esclusi);
				sfield(S_INCL).enable_column(cid2index(FI_IESCLUDI), sel_esclusi);
				sfield(S_INCL).force_update();
				return true;
			}
			warning_box("E' possibile escludere i movimenti solo per pacchetti bloccati\nin stato di errore '" D_WA_ERR " - %s'",
				TArchiviazioneIntegrazioni::traduci_stato(D_WA_ERR));
		}
		break;
	case B_IESCL:
		if (e == fe_button)
			conferma_esclusi();
		break;
	case B_IALLESCL:
		if (e == fe_button)
		{
			TSheet_field& sf = sfield(S_INCL);
			const bool active = *sf.row(0).get(cid2index(FI_IESCLUDI)) == 'S';

			FOR_EACH_SHEET_ROW_LOOP(sf, row)
				sf.set_row_cell(FI_IESCLUDI, active ? "N" : "S", row);
			sf.force_update();
			return true;
		}
		break;
	default: break;
	}
	return true;
}

void TApri_pacchetto_msk::fill_estr() const
{
	TString query;
	query << "SELECT " IVA_SEZIVA ", " IVA_DATADOC ", " IVA_NUMDOC ", " IVA_NPROT "\n"
		"FROM " F9_IVA "\n"
		"WHERE " IVA_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " IVA_IDLAN " = '" << _idestr << "'";
	// REG + DATAREG + PROTIVA + DATAINC + DATA74TER + NUMREG

	TSQL_recordset rec("");
	fp_db().sq_set_exec(query, false);
	TSheet_field& sf = sfield(S_ESCL);

	sf.reset();

	TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione...");

	for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
	{
		if (!prog.add_status())
			break;

		TString sql;

		sql << "SELECT NUMREG, DATAREG, DATADOC, CODCAUS, TIPODOC, MESELIQ, NUMDOC, TOTDOC, CODCF, REG, PROTIVA, DESCR, ELABF9\n"
			"FROM MOV\n"
			"WHERE REG = '" << fp_db().sq_get(IVA_SEZIVA) << "' AND DATADOC='" << TDate(fp_db().sq_get_date(IVA_DATADOC)).date2ansi() << "'"
			" AND PROTIVA = '" << fp_db().sq_get(IVA_NPROT) << "'";
		rec.set(sql);
		rec.move_first();

		const int row = sf.set_row_cell(FI_NUMREG, rec.get(0).as_string());  // Numreg

		sf.set_row_cell(FI_DATAREG, rec.get(1).as_date(), row);  // Data reg
		sf.set_row_cell(FI_DATADOC, rec.get(2).as_string(), row);  // Data doc
		TString codcaus;

		codcaus << rec.get(3).as_string();
		codcaus.lpad(3, '0');
		sf.set_row_cell(FI_CODCAUS, codcaus, row);  // Cod caus
		sf.set_row_cell(FI_TIPOMOV, rec.get(4).as_string(), row);  // Tipo doc
		sf.set_row_cell(FI_MESELIQ, rec.get(5).as_string(), row);  // Mese liq
		sf.set_row_cell(FI_NUMDOC, rec.get(6).as_string(), row);  // Num doc
		sf.set_row_cell(FI_IMPTOTDOC, rec.get(7).as_string(), row);  // Tot doc
		sf.set_row_cell(FI_FORN, rec.get(8).as_string(), row);  // Clifo

		TToken_string key(_tipodoc == 'A' ? "F" : "C");

		key.add(rec.get(8).as_string());

		const TRectype& clifo = cache().get(LF_CLIFO, key);

		sf.set_row_cell(FI_RAGSOC, clifo.get(CLI_RAGSOC), row);                                   // Rag soc

		TString protiva(rec.get(9).as_string());

		protiva << "/" << rec.get(10).as_string();
		sf.set_row_cell(FI_PROTIVA, protiva, row);  // Prot iva
		sf.set_row_cell(FI_DESCR, rec.get(11).as_string(), row);                                 // Descr
		sf.set_row_cell(FI_IESCLUSO, TToken_string(rec.get(12).as_string(), ';').get_bool(2), row);  // Escluso
	}
	sf.force_update();
}

void TApri_pacchetto_msk::fill_res() const
{
	TString query;
	query << "SELECT * FROM " F9_MOVESTR "\n"
		"INNER JOIN " F9_IVA " ON " IVA_IDLAN " = " MES_IDESTR " AND " IVA_NUMOR " = " MES_NUMREG "\n"
		"WHERE " MES_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " MES_IDESTR " = '" << _idestr << "'";

	fp_db().sq_set_exec(query, false);
	TSheet_field& sf = sfield(S_RES);
	TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione...");

	sf.reset();
	for (bool ok = fp_db().sq_next(); prog.add_status() && ok; ok = fp_db().sq_next())
	{

		TString td = fp_db().sq_get(IVA_CAUSSOS);
		const TRectype & mov = cache().get(LF_MOV, fp_db().sq_get(MES_NUMREG));
		const int row = sf.set_row_cell(F_RSEL, fp_db().sq_get_int(MES_ESTR) ? "X" : " "); // Estratto

		sf.set_row_cell(F_RNUMREG, mov.get(MOV_NUMREG), row);                          // Numreg
		sf.set_row_cell(F_RDATAREG, mov.get_date(MOV_DATAREG), row);                   // Data reg
		sf.set_row_cell(F_RDATADOC, mov.get_date(MOV_DATADOC), row);                   // Data doc
		sf.set_row_cell(F_RTIPODOCSDI, td, row);															      	 // Tipo Doc SDI
		sf.set_row_cell(F_RCODCAUS, mov.get(MOV_CODCAUS), row);                        // Cod caus
		sf.set_row_cell(F_RTIPOMOV, mov.get(MOV_TIPODOC), row);                        // Tipo doc
		sf.set_row_cell(F_RMESELIQ, mov.get_int(MOV_MESELIQ), row);                    // Mese liq
		sf.set_row_cell(F_RNUMDOC, mov.get(MOV_NUMDOC), row);                          // Num doc
		sf.set_row_cell(F_RIMPTOTDOC, mov.get_real(MOV_TOTDOC), row);                  // Tot doc
		sf.set_row_cell(F_RFORN, mov.get_int(MOV_CODCF), row);                         // Clifo

		TToken_string key(mov.get(MOV_TIPO));

		key.add(mov.get(MOV_CODCF));

		const TRectype & clifo = cache().get(LF_CLIFO, key);

		sf.set_row_cell(F_RRAGSOC, clifo.get(CLI_RAGSOC), row);                                     // Rag soc

		TString protiva(mov.get(MOV_REG));

		protiva << "/" << mov.get(MOV_PROTIVA);

		sf.set_row_cell(F_RPROTIVA, protiva, row);  // Prot iva
		sf.set_row_cell(F_RDESCR, mov.get(MOV_DESCR), row);                                        // Descr
		sf.set_row_cell(F_RDESCRERR, fp_db().sq_get(MES_ERR), row);                                   // Descrizione errore
	}
	sf.force_update();
}

void TApri_pacchetto_msk::set_from_estrazione(TToken_string& row_estrazione)
{
	set(F_IIDESTR, _idestr.cut(0) << row_estrazione.get(cid2index(F_IDESTR)));
	set(F_IDATA, _dataestr = row_estrazione.get(cid2index(F_DATAESTR)));
	set(F_IPROV, _provv = *row_estrazione.get(cid2index(F_PROV_B)) == 'X');
	set(F_ITIPOD, (_tipodoc = *row_estrazione.get(cid2index(F_TIPODOC))) == 'V' ? "Vendite" : "Acquisti");
	(_statoestr.cut(0) << row_estrazione.get(cid2index(F_STATESTR))).cut(2);
	set(F_ISTATOESTR, TString(_statoestr) << " - " << TArchiviazioneIntegrazioni::traduci_stato(_statoestr));
	set(F_IDAL, _datadal = row_estrazione.get(cid2index(F_DATADAL)));
	set(F_IAL, _dataal = row_estrazione.get(cid2index(F_DATAAL)));
}

TApri_pacchetto_msk::TApri_pacchetto_msk() : TAutomask("f90600d.msk"), _provv(true), _tipodoc('A')
{
	field(B_IESCL).disable();
	field(B_IALLESCL).disable();
}

////////////////////////////////////////////////////////
// TArchiviazioneIntegrazioni
////////////////////////////////////////////////////////

const char* TArchiviazioneIntegrazioni::traduci_stato(const TString& cod)
{
	static TString stato;
	static TString last_cod;
	if (last_cod != cod)
	{
		last_cod = cod;
		stato.cut(0);
		if (cod == "01")
			stato << "in diagnostica";
		else if (cod == "02")
			stato << "errore diagnostica gestionale";
		else if (cod == "03")
			stato << "diagnostica gestionale passata";
		else if (cod == "04")
			stato << "controllo WebApp";
		else if (cod == "05")
			stato << "errore diagnostica WebApp";
		else if (cod == "06")
			stato << "diagnostica WebApp passata";
		else if (cod == "07")
			stato << "in elaborazione da sostitutiva";
		else if (cod == "08")
			stato << "errore diagnostica da sostitutiva";
		else if (cod == "09")
			stato << "Archiviato";
	}
	return (const char*)stato;
}

void TArchiviazioneIntegrazioni::main_loop()
{
	_msk = new TArchInt_mask;
	_estr_msk = new Tf9IntEstrai_mask;
	//m.set(1, true);
	while (_msk->run() != K_QUIT) {}
}

bool TArchiviazioneIntegrazioni::create()
{
	open_files(LF_TAB, LF_TABCOM, LF_TABMOD, LF_ANAG,
		LF_CLIFO, LF_CFVEN, LF_CFBAN, LF_NDITTE,
		LF_DOC, LF_RIGHEDOC, LF_CODCORR, LF_ANAMAG, 0);

	const TRectype cfven(LF_CFVEN);
	if (cfven.length(CFV_PADESTIN) != 7) // Nuova lunghezza per privati
		return error_box(TR("Database non convertito per fatturazione F.P."));

	//nel caso checkare qui le tabelle dell f9
	return TSkeleton_application::create();
}

bool TArchiviazioneIntegrazioni::destroy()
{
	return TSkeleton_application::destroy();
}

int f90600(int argc, char* argv[])
{
	TArchiviazioneIntegrazioni archInt;
	archInt.run(argc, argv, TR("Archiviazione Integrazioni"));
	return 0;
}