517 lines
13 KiB
C++
517 lines
13 KiB
C++
#include "f1lib.h"
|
|
#include "config.h"
|
|
#include "cglib.h"
|
|
#include "execp.h"
|
|
#include "cfven.h"
|
|
#include "reputils.h"
|
|
#include "causali.h"
|
|
#include "clifo.h"
|
|
#include "../fp/fplib.h"
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// TFppro
|
|
//////////////////////////////////////////////////////////
|
|
|
|
TFppro& fppro_db()
|
|
{
|
|
static TFppro* fppro = nullptr;
|
|
if (fppro == nullptr)
|
|
fppro = new TFppro();
|
|
return *fppro;
|
|
}
|
|
|
|
bool TFppro::sql_inj(const TString& str)
|
|
{
|
|
TString appo; appo << str;
|
|
appo.upper();
|
|
return appo.contains("--") || appo.contains("SELECT") || appo.contains("DELETE") || appo.contains("DROP");
|
|
}
|
|
|
|
bool TFppro::sql_inj(const keys_s& keys)
|
|
{
|
|
TToken_string str("", ';');
|
|
str.add(keys.prginvio);
|
|
str.add(keys.headerfatt);
|
|
str.add(keys.bodyfatt);
|
|
return sql_inj(str);
|
|
}
|
|
|
|
bool TFppro::check_reg(TToken_string& keys, int numreg)
|
|
{
|
|
return get_numreg(keys) == numreg;
|
|
}
|
|
|
|
bool TFppro::guess_the_doc(const TLocalisamfile& mov)
|
|
{
|
|
// Prendo il fornitore del mov per controllare la p.iva
|
|
TLocalisamfile clifo(LF_CLIFO);
|
|
clifo.put(CLI_TIPOCF, "F");
|
|
const TString& codforn = mov.get(MOV_CODCF);
|
|
clifo.put(CLI_CODCF, codforn);
|
|
clifo.read();
|
|
TString cli_statopiva, cli_piva;
|
|
cli_statopiva << clifo.get(CLI_STATOPAIV);
|
|
cli_piva << clifo.get(CLI_PAIV);
|
|
const real tot = mov.get_real(MOV_TOTDOC) + mov.get_real(MOV_RITFIS) + mov.get_real(MOV_RITSOC);
|
|
TString numdoc = mov.get(MOV_NUMDOCEXT);
|
|
if (numdoc.empty())
|
|
numdoc = mov.get(MOV_NUMDOC);
|
|
// Controllo datadoc - numdoc - totdoc - p.iva
|
|
TString query;
|
|
query << "SELECT PQ_KEYPRGINVIO AS KEYPRGINVIO, PQ_KEYHEADERFATT AS KEYHEADERFATT, PQ_KEYBODYFATT AS KEYBODYFATT, P7_DATA AS DATA,\n" <<
|
|
"\tP7_NUMERO AS NUMDOC, PQ_IMPTOTDOC AS IMPTOTDOC, 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" <<
|
|
"WHERE P7_DATA = '" << mov.get_date(MOV_DATADOC).date2ansi() << "' AND \n" <<
|
|
"(P7_NUMERO = '" << numdoc << "' OR P7_NUMERO LIKE '%" << numdoc << "%') AND \n" <<
|
|
(cli_statopiva.full() ? TString("P2_FISCIVAPAESE = '") << cli_statopiva << "' AND " : "") <<
|
|
"P2_FISCIVACOD = '" << cli_piva << "' AND \n" << "PQ_IMPTOTDOC = " << tot;
|
|
|
|
if (_db->sq_set_exec(query) && _db->sq_items() == 1)
|
|
{
|
|
_keys = { _db->sq_get("KEYPRGINVIO"), _db->sq_get("KEYHEADERFATT"), _db->sq_get("KEYBODYFATT") };
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const char* TFppro::get_keys_fppro() const
|
|
{
|
|
static TString keys;
|
|
keys.cut(0) << _keys.prginvio << ";" << _keys.headerfatt << ";" << _keys.bodyfatt;
|
|
return (const char*)keys;
|
|
}
|
|
|
|
int TFppro::get_numreg()
|
|
{
|
|
if (!_is_set)
|
|
{
|
|
if (set_query())
|
|
return _db->sq_get_int("PZ_NUMREGCONT");
|
|
return -1;
|
|
}
|
|
return _db->sq_get_int("PZ_NUMREGCONT");
|
|
}
|
|
|
|
int TFppro::get_numreg(TToken_string& keys)
|
|
{
|
|
set_keys(keys);
|
|
return get_numreg();
|
|
}
|
|
|
|
TString TFppro::get_codforn() const
|
|
{
|
|
TString query;
|
|
query << "SELECT PZ_CLIFOR FROM FPPRO00F\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return _db->sq_get("PZ_CLIFOR");
|
|
}
|
|
|
|
TDate TFppro::get_datareg()
|
|
{
|
|
if (!_is_set)
|
|
{
|
|
if (set_query())
|
|
return _db->sq_get_date("PZ_DATAREGCONT");
|
|
return TDate();
|
|
}
|
|
return _db->sq_get_date("PZ_DATAREGCONT");
|
|
}
|
|
|
|
TDate TFppro::get_datareg(TToken_string& keys)
|
|
{
|
|
set_keys(keys);
|
|
if (_is_set)
|
|
return get_datareg();
|
|
return TDate();
|
|
}
|
|
|
|
real TFppro::get_ritenute() const
|
|
{
|
|
real imp = ZERO;
|
|
TString query;
|
|
query << "SELECT P7_IMPORTORIT AS IMPORTO FROM PAA0700F\n" <<
|
|
"WHERE P7_KEYPRGINVIO = '" << _keys.prginvio << "' AND P7_KEYHEADERFATT = '" << _keys.headerfatt << "' AND P7_KEYBODYFATT = '" << _keys.bodyfatt << "'";
|
|
_db->sq_set_exec(query, false);
|
|
for(bool ok = _db->sq_next(); ok; ok = _db->sq_next())
|
|
imp += _db->sq_get_real("IMPORTO");
|
|
return imp;
|
|
}
|
|
|
|
TFppro& TFppro::set_keys(TToken_string& keys)
|
|
{
|
|
if (keys.items() == 3)
|
|
{
|
|
const keys_s k = { keys.get(0), keys.get(1), keys.get(2) };
|
|
return set_keys(k);
|
|
}
|
|
_is_set = false;
|
|
_keys_setted = false;
|
|
return *this;
|
|
}
|
|
|
|
TFppro& TFppro::set_keys(const keys_s& keys)
|
|
{
|
|
if (sql_inj(keys))
|
|
{
|
|
TString msg; msg << "Database error: Possibile SQL INJECTION:\n" << keys;
|
|
//throw std::exception(msg);
|
|
error_box(msg);
|
|
_last_error.cut(0) << msg;
|
|
}
|
|
else if (!keys.prginvio.empty() && !keys.headerfatt.empty() && !keys.bodyfatt.empty())
|
|
{
|
|
_keys = keys;
|
|
_keys_setted = true;
|
|
}
|
|
else
|
|
{
|
|
_last_error.cut(0) << "Chiavi settate non valide:\n" << keys;
|
|
_keys_setted = false;
|
|
}
|
|
_is_set = false;
|
|
return *this;
|
|
}
|
|
|
|
bool TFppro::associa_mov(const int numreg) const
|
|
{
|
|
bool ok;
|
|
TLocalisamfile mov(LF_MOV);
|
|
mov.put(MOV_NUMREG, numreg);
|
|
if ((ok = mov.read() == NOERR))
|
|
{
|
|
mov.put(MOV_KEYFPPRO, get_keys_fppro());
|
|
if ((ok = mov.rewrite() == NOERR)) // Scrivo sul movimento il riferimento al fppro
|
|
{
|
|
TString query;
|
|
query << "UPDATE FPPRO00F \nSET " <<
|
|
"PZ_TIPOCF = 'F', PZ_CLIFOR = '" << mov.get(MOV_CODCF) << "', PZ_NUMREGCONT = '" <<
|
|
mov.get(MOV_NUMREG) << "', PZ_DATAREGCONT = '" << mov.get_date(MOV_DATAREG).date2ansi() << "'\n" <<
|
|
fppro_db().where_str() << ";";
|
|
if (!((ok = _db->sq_set_exec(query) && _db->sq_commit()))) // Se la scrittura sul db fallisce levo sul movimento il riferimento all'fppro
|
|
{
|
|
mov.put(MOV_KEYFPPRO, "");
|
|
mov.rewrite();
|
|
}
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
const char* TFppro::get_tipoprot() const
|
|
{
|
|
TString query;
|
|
static TString tipo;
|
|
query << "SELECT PZ_TIPOPROT AS TIPOPROT FROM FPPRO00F\r\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return tipo.cut(0) = _db->sq_get("TIPOPROT");
|
|
}
|
|
|
|
const char* TFppro::get_numprot() const
|
|
{
|
|
TString query;
|
|
static TString num;
|
|
query << "SELECT PZ_NUMPROT AS NUMPROT FROM FPPRO00F\r\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return num.cut(0) = _db->sq_get("NUMPROT");
|
|
}
|
|
|
|
const char* TFppro::get_annoprot() const
|
|
{
|
|
TString query;
|
|
static TString anno;
|
|
query << "SELECT PZ_ANNOPROT AS ANNOPROT FROM FPPRO00F\r\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return anno.cut(0) = _db->sq_get("ANNOPROT");
|
|
}
|
|
|
|
const char* TFppro::get_dataoraric() const
|
|
{
|
|
TString query;
|
|
static TString data;
|
|
query << "SELECT PZ_DATAORARIC AS DATAORARIC FROM FPPRO00F\r\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return data.cut(0) << _db->sq_get_date("DATAORARIC").date2ansi();
|
|
}
|
|
|
|
const char* TFppro::get_tipodoc() const
|
|
{
|
|
TString query;
|
|
static TString tipodoc;
|
|
query << "SELECT PZ_TIPODOC AS TIPODOC FROM FPPRO00F\r\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return tipodoc.cut(0) << _db->sq_get("TIPODOC");
|
|
}
|
|
|
|
const char* TFppro::get_numdoc() const
|
|
{
|
|
TString query;
|
|
static TString numdoc;
|
|
query << "SELECT PZ_NUMERO AS NUMDOC FROM FPPRO00F\r\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return numdoc.cut(0) << _db->sq_get("NUMDOC");
|
|
}
|
|
|
|
TDate TFppro::get_data_first_doc() const
|
|
{
|
|
TString query;
|
|
query << "SELECT min(a.DATA) AS DATA \nFROM( \n\tSELECT P7_DATA as DATA \n" <<
|
|
"\tFROM PAA0700F \n\tUNION \n\tSELECT P7_DATA as DATA \n\tFROM PAF0700F \n) a";
|
|
_db->sq_set_exec(query);
|
|
return _db->sq_get_date("DATA");
|
|
}
|
|
|
|
TDate TFppro::get_dataorarioric() const
|
|
{
|
|
TString query;
|
|
query << "SELECT P1_DATAORARIC \nFROM PAA0100F \n" <<
|
|
"WHERE P1_KEYPRGINVIO = '" << _keys.prginvio << "' AND P1_KEYHEADERFATT = '" << _keys.headerfatt << "' AND P1_KEYBODYFATT = '" << _keys.bodyfatt << "'";
|
|
_db->sq_set_exec(query);
|
|
return _db->sq_get_date("P1_DATAORARIC");
|
|
}
|
|
|
|
int TFppro::get_numregcont() const
|
|
{
|
|
TString query;
|
|
query << "SELECT PZ_NUMREGCONT FROM FPPRO00F\n" << where_str();
|
|
_db->sq_set_exec(query);
|
|
return _db->sq_get_int("PZ_NUMREGCONT");
|
|
}
|
|
|
|
TString TFppro::get_last_error(bool clear)
|
|
{
|
|
TString l(_last_error);
|
|
if(clear)
|
|
_last_error.cut(0);
|
|
return l;
|
|
}
|
|
|
|
bool TFppro::set_query()
|
|
{
|
|
if (_keys_setted)
|
|
{
|
|
_fppro_query.cut(0) << "SELECT * FROM FPPRO00F " << where_str();
|
|
return _is_set = _db->sq_set_exec(_fppro_query);
|
|
}
|
|
return _is_set = false;
|
|
}
|
|
|
|
const char* TFppro::where_str() const
|
|
{
|
|
static TString str;
|
|
str.cut(0) << " WHERE PZ_KEYPRGINVIO = '" << _keys.prginvio << "' AND PZ_KEYHEADERFATT = '" << _keys.headerfatt << "' AND PZ_KEYBODYFATT = '" << _keys.bodyfatt << "'";
|
|
return str;
|
|
}
|
|
|
|
TFppro::TFppro() : _keys({ "\0", "\0", "\0" }), _keys_setted(false), _is_set(false)
|
|
{
|
|
_db = new SSimple_query();
|
|
const bool ok = set_connection(*_db);
|
|
// Non utilizzo l'autocommit, viene gestito manualmente
|
|
if (ok) _db->sq_set_autocommit(false);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////
|
|
// TProtocollo
|
|
//////////////////////////////////////////////////////////
|
|
|
|
prot_s TProtocollo::get_prot()
|
|
{
|
|
const prot_s prot = { _tipoprot, _progres, _year };
|
|
return prot;
|
|
}
|
|
|
|
TString& TProtocollo::prot_in(const int year, const char* tipoprot, const char* progres)
|
|
{
|
|
static TString protocollo;
|
|
TString tipo(tipoprot);
|
|
if (tipo.empty())
|
|
tipo << "no_prot";
|
|
protocollo.cut(0) << year << "-" << tipo << "/" << progres;
|
|
return protocollo;
|
|
}
|
|
|
|
void TProtocollo::set(const TProtocollo& prot)
|
|
{
|
|
_year = prot._year;
|
|
_tipoprot = prot._tipoprot;
|
|
_progres = prot._progres;
|
|
}
|
|
|
|
void TProtocollo::sset(const char* prot)
|
|
{
|
|
TToken_string tok(prot, '-');
|
|
_year = tok.get_int();
|
|
TToken_string p(tok.get(), '/');
|
|
_tipoprot = p.get();
|
|
_progres = p.get();
|
|
}
|
|
|
|
TString& TProtocollo::get_prot() const
|
|
{
|
|
return prot_in(_year, _tipoprot, _progres);
|
|
}
|
|
|
|
void set_ini_codcaus(const TString& codcaus)
|
|
{
|
|
ini_set_string(FILE_CONFIG, FILE_SECTION, F1_CAUS, codcaus);
|
|
}
|
|
|
|
const char* get_ini_codcaus()
|
|
{
|
|
return ini_get_string(FILE_CONFIG, FILE_SECTION, F1_CAUS);
|
|
}
|
|
|
|
const char* get_codcaus(const char * tipodoc, const char* codcf)
|
|
{
|
|
TLocalisamfile cfven(LF_CFVEN);
|
|
cfven.put(CFV_TIPOCF, "F");
|
|
cfven.put(CFV_CODCF, codcf);
|
|
const char* codcaus = "";
|
|
const char* codcausnc = "";
|
|
const bool nc = TString(tipodoc) == "TD04";
|
|
|
|
if (cfven.read() == NOERR)
|
|
{
|
|
codcaus = cfven.get(CFV_CODCAUS);
|
|
codcausnc = cfven.get(CFV_CODCAUSNC);
|
|
}
|
|
|
|
if (nc)
|
|
{
|
|
if (!TString(codcausnc).empty())
|
|
return codcausnc;
|
|
}
|
|
else
|
|
{
|
|
if (!TString(codcaus).empty())
|
|
return codcaus;
|
|
}
|
|
return get_ini_codcaus();
|
|
}
|
|
|
|
bool get_endatareg()
|
|
{
|
|
return ini_get_bool(FILE_CONFIG, FILE_SECTION, "endatareg");
|
|
}
|
|
|
|
TString get_datainireg()
|
|
{
|
|
return ini_get_string(FILE_CONFIG, FILE_SECTION, "datainireg");
|
|
}
|
|
|
|
TString get_dataendreg()
|
|
{
|
|
return ini_get_string(FILE_CONFIG, FILE_SECTION, "dataendreg");
|
|
}
|
|
|
|
bool get_periodprec()
|
|
{
|
|
return ini_get_bool(CONFIG_DITTA, FILE_SECTION, "flag_periodprec");
|
|
}
|
|
|
|
void set_endatareg(bool enable)
|
|
{
|
|
ini_set_bool(FILE_CONFIG, FILE_SECTION, "endatareg", enable);
|
|
}
|
|
|
|
void set_datainireg(const TString& date)
|
|
{
|
|
ini_set_string(FILE_CONFIG, FILE_SECTION, "datainireg", date);
|
|
}
|
|
|
|
void set_dataendreg(const TString& date)
|
|
{
|
|
ini_set_string(FILE_CONFIG, FILE_SECTION, "dataendreg", date);
|
|
}
|
|
|
|
void set_periodprec(bool flag)
|
|
{
|
|
ini_set_bool(CONFIG_DITTA, FILE_SECTION, "flag_periodprec", flag);
|
|
}
|
|
|
|
bool check_causale(const TString& cod_caus, bool acq)
|
|
{
|
|
return cod_caus.full() && (
|
|
check_causale(cod_caus, "FA", acq) ||
|
|
check_causale(cod_caus, "BD", acq) ||
|
|
check_causale(cod_caus, "AF", acq) ||
|
|
check_causale(cod_caus, "FF", acq) ||
|
|
check_causale(cod_caus, "NC", acq) ||
|
|
check_causale(cod_caus, "ND", acq));
|
|
}
|
|
|
|
bool check_causale(const TString& cod_caus, const TString& tipo_doc, bool acq)
|
|
{
|
|
const TCausale& caus = cached_causale(cod_caus);
|
|
|
|
if(tipo_doc == "FA" || tipo_doc == "BD" || tipo_doc == "AF" || tipo_doc == "FF")
|
|
return caus.tipo_doc() == tipo_doc;
|
|
|
|
if (tipo_doc == "NC" || tipo_doc == "ND")
|
|
{
|
|
bool nota;
|
|
bool nota_iva = false;
|
|
if ((nota = caus.tipo_doc() == tipo_doc))
|
|
{
|
|
if (acq)
|
|
nota_iva = caus.reg().tipo() == iva_acquisti;
|
|
else
|
|
nota_iva = caus.reg().tipo() == iva_vendite;
|
|
}
|
|
return nota && nota_iva;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool check_caus_has_rit(const TString& cod_caus, bool rit)
|
|
{
|
|
TLocalisamfile causali(LF_CAUSALI);
|
|
causali.put(CAU_CODCAUS, cod_caus);
|
|
causali.read();
|
|
return *causali.get(CAU_M770) != '\0';
|
|
}
|
|
|
|
void run_cont_ini(bool liq)
|
|
{
|
|
static TString run_string;
|
|
#ifdef DBG
|
|
run_string.cut(0) << "cg2 -0 -i" << F1_INIREGCONT << "*" << ".ini" << " -f1" << (liq? " -liq" : " ") << " /u" << user();
|
|
#else
|
|
run_string.cut(0) << "cg2 -0 -i" << TFilename().tempdir() << "\\" << F1_INIREGCONT << "*" << ".ini" << " -f1" << (liq ? " -liq" : " ") << " /u" << user();
|
|
#endif
|
|
TExternal_app(run_string).run();
|
|
}
|
|
|
|
void TF1_log::log(int severity, const char* msg)
|
|
{
|
|
if (_log == nullptr)
|
|
{
|
|
_log = new TLog_report("Stato contabilizzazione:");
|
|
// Tento l'eliminazione del file
|
|
std::remove("f1_cg.log");
|
|
}
|
|
|
|
static TString txt;
|
|
txt.cut(0) << msg;
|
|
_log->log(severity, txt);
|
|
// Scrivo anche su file
|
|
std::filebuf fb;
|
|
fb.open("f1_cg.log", std::ios::out | std::ios::app);
|
|
std::ostream os(&fb);
|
|
os << txt << std::endl;
|
|
fb.close();
|
|
}
|
|
|
|
bool TF1_log::show_log()
|
|
{
|
|
if (_log)
|
|
{
|
|
_log->preview();
|
|
delete _log;
|
|
_log = nullptr;
|
|
}
|
|
return true;
|
|
} |