campo-sirio/src/f9/f90100.cpp

#include <automask.h>
#include "applicat.h"
#include "f90100a.h"
#include "lffiles.h"
#include "isam.h"
#include "mov.h"
#include "f1lib.h"
#include "../fp/fplib.h"
#include "urldefid.h"
#include "f90100.h"
#include "progind.h"

SSimple_query& db()
{
	static SSimple_query* db = nullptr;
	if (db == nullptr)
	{
		db = new SSimple_query();
		set_connection(*db);
	}
	return *db;
}

////////////////////////////////////////////////////////
// TEstrai_mask
////////////////////////////////////////////////////////

TEstrai_mask::TEstrai_mask() : TMask("Estrazione", 1, 60, 10), _dirty(true)
{
	add_button_tool(DLG_ELABORA, "Estrai", TOOL_ELABORA);
	//add_button_tool(DLG_FINDREC, "Diagnostica", TOOL_PERMISSIONS);
	//add_button_tool(DLG_NULL, "", 0);
	//add_button_tool(DLG_EDIT, "Reset", TOOL_EDIT);
	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, 3, "");
	add_list(ES_TIPODOC, 0, "Tipi documento", 33, 4, 1, "", "A|V|C", "Acquisti|Vendite|Corrispettivi");

	TMask::set_handler(DLG_ELABORA, estrai_handler);
	//TMask::set_handler(DLG_FINDREC, diagnostica_handler);
	//TMask::set_handler(DLG_EDIT, enable_handler);
	TMask::set_handler(ES_DATAINI, dataini_handler);
	TMask::set_handler(ES_DATAEND, dataend_handler);

	//TMask::enable(DLG_ELABORA, false);
	//TMask::enable(DLG_EDIT, false);

	TDate dt(TODAY); dt.set_day(1); dt.set_month(1);
#ifdef DBG
	dt.set_year(2017);
#endif
	set(ES_DATAINI, dt);
	set(ES_DATAEND, TDate(TODAY));
}

bool TEstrai_mask::estrai_handler(TMask_field& f, unsigned short key)
{
	auto& msk = (TEstrai_mask&)f.mask(); // this
	descr_msk().run();
	msk._descr.cut(0) << descr_msk().get(DES_TEXT);
	app().estrai();
	return true;
}

void TEstrai_mask::enable_fields(bool en)
{
	enable(ES_DATAINI, en);
	enable(ES_DATAEND, en);
	enable(ES_FLAGPROV, en);
	enable(ES_TIPODOC, en);

	//enable(DLG_ELABORA, !en);
	//enable(DLG_FINDREC, en);
	//enable(DLG_EDIT, !en);
}

bool TEstrai_mask::enable_handler(TMask_field& f, unsigned short key)
{
	((TEstrai_mask&)f.mask()).enable_fields();
	return true;
}

bool TEstrai_mask::dataini_handler(TMask_field& f, unsigned short key)
{
	TMask& msk = f.mask();
	if (key == K_TAB)
	{
		if(msk.get(ES_DATAINI).full() && msk.get(ES_DATAEND).full() && msk.get_date(ES_DATAINI) > msk.get_date(ES_DATAEND))
			return f.error_box("La data di inizio non puo' essere maggiore di quella di fine");
	}
	//msk.enable(DLG_ELABORA, false);
	return true;
}

bool TEstrai_mask::dataend_handler(TMask_field& f, unsigned short key)
{
	TMask& msk = f.mask();
	if (key == K_TAB)
	{
		if (msk.get(ES_DATAINI).full() && msk.get(ES_DATAEND).full() && msk.get_date(ES_DATAINI) > msk.get_date(ES_DATAEND))
			return f.error_box("La data di fine non puo' essere minore di quella di inizio");
	}
	//msk.enable(DLG_ELABORA, false);
	return true;
}

TMask& TEstrai_mask::descr_msk()
{
	static TMask* m = nullptr;
	if(m == nullptr)
	{
		m = new TMask("Estrazione", 1, 60, 5);
		m->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
		m->add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, "");
		m->add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40);
	}
	return *m;
}

////////////////////////////////////////////////////////
// TMonitor_mask
////////////////////////////////////////////////////////

bool TMonitor_mask::save_conf_handler(TMask_field& f, unsigned short key)
{
	TMask& m = f.mask();
	TF9_app& a = app();
	a.set_ambiente(m.get(CF_CODSOC));
	a.set_addr_doc(m.get(CF_ADDRDOC));
	
	if(a.get_ambiente().full())
		ini_set_string(CONFIG_DITTA, "F9", AMBIENTE_F9, a.get_ambiente());
	if(a.get_addr_doc().full())
		ini_set_string(CONFIG_DITTA, "F9", ADDRCART_F9, a.get_addr_doc());
	m.close();
	a.edit_wa();
	return true;
}

void TMonitor_mask::controllo_errori()
{
	
}

bool TMonitor_mask::on_key(const KEY key)
{
	return true;
}

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

void TMonitor_mask::open_win_conf() const
{
	static TMask* m = nullptr;

	if (m == nullptr)
	{
		m = new TMask("Configurazione Archiviazione Sostitutiva", 1, 60, 10);

		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, 59, 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, 59, 3, "");
		m->add_string(CF_ADDRDOC, 0, "Percorso", 2, 4, 256, "", 40);

		m->set_handler(DLG_OK, save_conf_handler);

		m->set(CF_CODSOC, ini_get_string(CONFIG_DITTA, PAR_MOD, AMBIENTE_F9));
		m->set(CF_ADDRDOC, ini_get_string(CONFIG_DITTA, PAR_MOD, ADDRCART_F9));
	}
	m->run();
}

bool TMonitor_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
	case DLG_ALL:
		if(e == fe_button && curr_page() == 1)
			//sel_all();
		break;
	case DLG_ELABORA:
		if (e == fe_button)
			open_win_estr();
		break;
	case DLG_CONFIG:
		if (e == fe_button)
			open_win_conf();
		break;
	case DLG_FINDREC:
		if (e == fe_button)
			controllo_errori();
	default: break;
	}
	return true;
}

////////////////////////////////////////////////////////
// TF9_app
////////////////////////////////////////////////////////

void TF9_app::edit_wa() const
{
	TString query;
	query << "DELETE FROM F9WA00K WHERE true;" <<
		"INSERT INTO F9WA00K (F9PCSOC, F9PPCDC0) VALUES (" << _ambiente << ", " << _addr_doc << ");";
}

void TF9_app::load()
{
	const TDate dataini = get_dataini();
	const TDate dataend = get_dataend();
	const char	tipodoc = get_tipodoc();
	const bool	flagpro = is_provviso();
	TLocalisamfile mov(LF_MOV);

	mov.setkey(2);
	mov.put(MOV_DATAREG, dataini);

	int items = 0;
	for (bool ok = mov.read(); ok && mov.get_date(MOV_DATAREG) <= dataend; ok = mov.next() == NOERR)
		items++;

	TProgress_monitor progr(items, "Acquisizione movimenti");
	int i = 0;
	mov.zero();
	mov.setkey(2);
	mov.put(MOV_DATAREG, dataini);
	// Prendo tutti i movimenti a partire da una data e li carico tutti fino alla data finale
	for (bool ok = mov.read(); ok && mov.get_date(MOV_DATAREG) <= dataend; ok = mov.next() == NOERR)
	{
		if (!progr.add_status())
			break;
		const TipoIVA tipo = tipodoc == 'V' ? iva_vendite : iva_acquisti;
		// Se definitivo controllo il flag di stampato REGST
		if (mov.get_bool(MOV_REGST) != flagpro && mov.get(MOV_NUMDOC).full() && TCausale(mov.get(MOV_CODCAUS)).reg().iva() == tipo)
		{
			TToken_string t("", '|');
			t.add("");
			t.add(mov.get(MOV_NUMREG));
			t.add(mov.get(MOV_DATAREG));
			t.add(mov.get(MOV_DATADOC));
			t.add(mov.get(MOV_CODCAUS));
			t.add(mov.get(MOV_MESELIQ));
			t.add(mov.get(MOV_NUMDOC));
			t.add(mov.get(MOV_PROTIVA));
			t.add(mov.get(MOV_DESCR));
			_movs.insert(_movs.end(), t);
			i++;
		}
	}
	_tot_movs = i;
}

const char* TF9_app::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"; // Deprecated
		else if (cod == "02")
			stato << "err. diagnostica";
		else if (cod == "03")
			stato << "diagnostica ok";
		else if (cod == "04")
			stato << "controllo WA";
		else if (cod == "05")
			stato << "err. diagn. WA";
		else if (cod == "06")
			stato << "diagn. WA OK";
		else if (cod == "07")
			stato << "in elab. sost.";
		else if (cod == "08")
			stato << "err. diag. sost.";
		else if (cod == "09")
			stato << "Archiviato";
	}
	return (const char*)stato;
}

void TF9_app::fill()
{
	_ambiente = ini_get_string(CONFIG_DITTA, PAR_MOD, AMBIENTE_F9);
	_addr_doc = ini_get_string(CONFIG_DITTA, PAR_MOD, ADDRCART_F9);

	TString query;
	query << "SELECT * FROM F9DRD00K ORDER BY " << DRD_TIME << ";";
	db().sq_set_exec(query, false);

	TSheet_field& sf = _msk->sfield(S_ELAB);
	sf.hide();
	int i = 0;
	for(bool ok = db().sq_next(); ok; ok = db().sq_next())
	{
		TString tipo;
		TToken_string& row = sf.row(i++);
		row.add(db().sq_get(DRD_STATO) == "09" ? "X" : "");
		row.add(db().sq_get(DRD_ID_EST));
		row.add(db().sq_get_date(DRD_TIME));
		row.add(db().sq_get(DRD_FLAG_PD) == "P" ? "X" : "");

		tipo << db().sq_get(DRD_TIPODOC);
		if(tipo == "A") tipo << "cquisti";
		if(tipo == "V") tipo << "endite";
		if(tipo == "C") tipo << "orrispettivi";
		row.add(tipo);

		row.add(db().sq_get_date(DRD_DATADA));
		row.add(db().sq_get_date(DRD_DATAA));
		row.add(db().sq_get(DRD_UTENTE));
		row.add(traduci_stato(db().sq_get(DRD_STATO)));
		row.add(db().sq_get(DRD_DESC));
		if(TDate(row.get(cid2index(F_DATAESTR))) == TDate(TODAY))
		{
			if (TString(row.get(cid2index(F_PROV_B))) == "X")
				_last_estr_p = real(TString(row.get(cid2index(F_IDESTR))).ltrim(9)).integer();
			else
				_last_estr_d = real(TString(row.get(cid2index(F_IDESTR))).ltrim(9)).integer();
		}
	}
	sf.force_update();
	sf.show();
}

state_fppro TF9_app::check_fppro(int numreg) const
{
	TLocalisamfile mov(LF_MOV);
	mov.put(MOV_NUMREG, numreg);
	if (mov.read() == NOERR && check_causale(mov.get(MOV_CODCAUS)))
	{
		// Controllo se ho i riferimenti all'FPPRO e verifico che sia tutto ok
		const TString& keys_fppro = mov.get(MOV_KEYFPPRO);
		if (keys_fppro.full())
		{
			TToken_string keys(keys_fppro, ';');
			if (fppro_db().check_reg(keys, numreg))
				return correct;
			return reg_with_err;
		}
		else		// Se non ho i riferimenti faccio guessing
		{
			if (fppro_db().guess_the_doc(mov))
				return guessed;
			return no_guessed;
		}
	}
	return not_fa;
}

// Controlla lo stato delle fatture e per le fatt. acquisto non collegate a fppro cerca di agganciarle
const char * TF9_app::check_stato(TipoIVA tipo)
{
	bool ok = true;

	if (tipo == iva_acquisti)
	{
		TProgress_monitor bar(_movs.size(), "Controllo stato movimenti di acquisto");
		// Controlli per le fatture di acquisto
		for (auto it = _movs.begin(); it != _movs.end(); ++it)
		{
			if (!bar.add_status())
				break;

			TToken_string& row = *it;
			const int numreg = row.get_int(cid2index(F_NUMREG));
			switch (app().check_fppro(numreg))
			{
			case guessed:
				ok &= fppro_db().associa_mov(numreg);
				//row.add(fppro_db().get_keys_fppro());
			case correct:
				ok &= true;
				break;

			case not_fa:
			case reg_with_err:
			case no_guessed:
				ok &= false;
				row.add("X", 0);	// Mi segno il movimento che ha un problema
			default: break;
			}
		}
	}
	else if (tipo == iva_vendite) {
		for (auto it = _movs.begin(); it != _movs.end(); ++it)
		{
			// Controlli per le fatture di vendita
		}
	}

	return ok ? D_GEST_OK : D_GEST_ERR;
}

TString TF9_app::next_estr_today(const char tipo) const
{
	char estr[] = {0,0,0,0,0,0,0,0,0,0};
	if(tipo == 'P')
		sprintf_s(estr, 10, "%09d", _last_estr_p + 1);
	else
		sprintf_s(estr, 10, "%09d", _last_estr_d + 1);
	return estr;
}

bool TF9_app::check_periodo_def(const drd& head)
{
	TString query;
	// Controllo se ci sono estrazioni (definitive) che si sovrappongono di periodo (con lo stesso tipo) e che non siano in stato di errore
	// Nel caso di stato di errore e' invece possibile la ri-estrazione
	query << "SELECT *\nFROM F9DRD00K\n" <<
		"WHERE '" << head.dal.date2ansi() << "' =< " << DRD_DATAA << " AND '" << head.al.date2ansi() << "' >= " << DRD_DATADA << " AND " <<
		DRD_FLAG_PD << " = 'D' AND\n F9RIDAS <> '02' AND F9RIDAS <> '05' AND F9RIDAS <> '08' AND " << DRD_TIPODOC << " = '" << head.tipo_doc << "';";
	db().sq_set_exec(query);
	return db().sq_items() == 0;
}

bool TF9_app::esporta()
{
	const bool ok = new_extr();
	fill();
	return ok;
}

TString& TF9_app::drd_attr()
{
	static TString attr;
	attr.cut(0) << DRD_CODSOC << ", " << DRD_ID_EST << ", " << DRD_FLAG_PD << ", " << DRD_DESC <<
		", " << DRD_TIPODOC << ", " << DRD_DATADA << ", " << DRD_DATAA << ", " << DRD_UTENTE << ", " << DRD_TIME << ", " <<
		DRD_STATO << ", " << DRD_PERC;
	return attr;
}

TString& TF9_app::drd_tovalues() const
{
	static TString str;
	return str.cut(0) << "'" << _head.cod_soc << "', '" << _head.id_estr << "', '" << (_head.flag_prov ? "P" : "D") << "', '" << _head.descr <<
		"', '" << _head.tipo_doc << "', '" << _head.dal.date2ansi() << "', '" << _head.al.date2ansi() << "', '" << _head.user << "', CURRENT_TIMESTAMP, '" <<
		_head.stato_estr << "', '" << _head.addr_cart << "'";
}

auto TF9_app::new_extr() -> bool
{
	TString query;
	query << "INSERT INTO " << F9_DRD << " ( " << drd_attr() << " ) \nVALUES ( " << drd_tovalues() << " );";
	bool ok = db().sq_set_exec(query);
	ok = ok && db().sq_commit();
	return ok;
}

int TF9_app::estrai()
{
	// Acquisisco i movimenti
	load();

	if (_movs.empty())
	{
		warning_box("Non esistono movimenti estraibili per il periodo selezionato.");
		return -1;
	}

	const char tipo = _estr_msk->get(ES_FLAGPROV)[0];
	_head.flag_prov	= is_provviso();
	_head.dal				= get_dataini();
	_head.al					= get_dataend();
	_head.tipo_doc		= get_tipodoc();
	if(!_head.flag_prov)	// Se estrazione definitiva controllo il periodo che non si sovrapponga alle altre estrazioni def.
	{
		if (!check_periodo_def(_head))
		{
			error_box("Attenzione e' stato inserito un periodo che si sovrappone\nad un'estrazione definitiva gia' esistente.");
			return -1;
		}
	}
	_head.cod_soc		= _ambiente;
	_head.id_estr.cut(0) << TDate(TODAY).date2ansi() << _estr_msk->get(ES_FLAGPROV) << next_estr_today(tipo);
	_head.descr			= get_descr();
	_head.user				= user();
	_head.flag_prov	= is_provviso();
	_head.addr_cart	= _addr_doc;

	_head.stato_estr = check_stato(get_tipoiva());

	const bool ok = esporta();

	if (_head.stato_estr)
		warning_box("Attenzione l'estrazione ha prodotto degli errori. \nControllare e correggere eventuali problemi \npremendo il pulsante 'Controllo Estr.'");
	_msk->enable(DLG_FINDREC, ok);
	return ok ? 1 : false;
}

void TF9_app::main_loop()
{
	_msk			= new TMonitor_mask();
	_estr_msk = new TEstrai_mask();
	fill();
	while (_msk->run() == K_ENTER){	}

	delete _msk;
	delete _estr_msk;
}

TF9_app& app()
{
	static TF9_app* app = nullptr;
	if(app == nullptr)
		app = (TF9_app*)&main_app();
	return *app;
}

int f90100(int argc, char* argv[])
{
	TF9_app app;
	app.run(argc, argv, TR("Configurazione FP"));
	return 0;
}