root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : 12.0 nopatch

Browse Source 
Files correlati     : f9

Commento:
Iniziata la modifica del modulo f9 per prendere da FPPRO il tipodocsdi
This commit is contained in:
Alessandro Bonazzi 2022-05-08 23:22:44 +02:00
parent 5ca6022d94
commit d0e06a5d6f
5 changed files with 609 additions and 607 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

483
src/f9/f90100.cpp
View File

@ -1,18 +1,18 @@
#include <experimental/filesystem>
#include <lffiles.h>
#include <isam.h>
#include <urldefid.h>
#include <progind.h>
#include <utility.h>
#include <sqlset.h>
#include "f90.h"
#include "f90100.h"
#include "lffiles.h"
#include "isam.h"
#include "../f1/f1lib.h"
#include "../fp/fplib.h"
#include "urldefid.h"
#include "progind.h"
#include "f901tab.h"
#include "f90100b.h"
#include "f90100d.h"
#include "sqlset.h"
#include "../f1/f1lib.h"
#include "../fp/fplib.h"
#include "f90.h"
#include "f90100.h"
#include "f90100c.h"
/** \file f90100.cpp
@ -31,20 +31,13 @@
// Utilities
////////////////////////////////////////////////////////
// Getters per semplificare i get dai TRecorset
const TString& recset_get_string(const TRecordset& rec, const char* field, int zero_filled = -1);
int recset_get_int(const TRecordset& rec, const char* field, int zero_filled = -1);
bool recset_get_bool(const TRecordset& rec, const char* field);
real recset_get_real(const TRecordset& rec, const char* field);
TDate recset_get_date(const TRecordset& rec, const char* field);
TMask& descr_msk()
{
static std::unique_ptr<TMask> m = nullptr;
static TMask * m = nullptr;
if (m == nullptr)
{
m = std::make_unique<TMask>("Estrazione", 1, 60, 5);
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);
@ -54,10 +47,10 @@ TMask& descr_msk()
TMask& esclusi_mask()
{
static unique_ptr<TMask> _esclusi_mask = nullptr;
static TMask * _esclusi_mask = nullptr;
if (_esclusi_mask == nullptr)
{
_esclusi_mask = std::make_unique<TMask>("f90100c.msk");
_esclusi_mask = new TMask("f90100c.msk");
TMask& m = *_esclusi_mask;
((TSheet_field&)m.field(S_ESCL)).set_notify(TF9_app::select_escl_notify); // Handler dello sheet per selezione singola
m.set_handler(DLG_FINDREC, TF9_app::controllo_escl_handler); // Bottone per aprire maschera di controllo movimenti
@ -71,63 +64,10 @@ TMask& esclusi_mask()
return *_esclusi_mask;
}
const TString& recset_get_string(const TRecordset& rec, const char* field, const int zero_filled)
{
const TString& str = rec.get(rec.find_column(field)).as_string();
if (zero_filled == -1)
return str;
static TString c;
c.cut(0);
const int len = str.len();
for (int i = len; i < zero_filled; i++) // Sistemo il codcaus per via del TVariant che non restituisce la stringa esattamente come l'originale
c << "0";
c << str;
return c;
}
int recset_get_int(const TRecordset& rec, const char* field, const int zero_filled)
{
return rec.get(rec.find_column(field)).as_int();
}
bool recset_get_bool(const TRecordset& rec, const char* field)
{
return rec.get(rec.find_column(field)).as_bool();
}
real recset_get_real(const TRecordset& rec, const char* field)
{
return rec.get(rec.find_column(field)).as_real();
}
TDate recset_get_date(const TRecordset& rec, const char* field)
{
return rec.get(rec.find_column(field)).as_date();
}
////////////////////////////////////////////////////////
// TEstrai_mask
////////////////////////////////////////////////////////
TString TEstrai_mask::get_numdoc_exp_fp(const int numreg)
{
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg);
if (mov.read() == NOERR)
{
const TString& dprovv = mov.get(MOV_DPROVV);
const int danno = mov.get_int(MOV_DANNO);
const TString& dcodnum = mov.get(MOV_DCODNUM);
const int dndoc = mov.get_int(MOV_DNDOC);
if (!dprovv.empty() && danno != 0 && !dcodnum.empty() && dndoc != 0)
{
const TDocumento doc(dprovv[0], danno, dcodnum, dndoc);
return complete_num_fp(doc.codice_numerazione(), doc.numero());
}
}
return "";
}
int TEstrai_mask::estrai()
{
@ -135,12 +75,12 @@ int TEstrai_mask::estrai()
const TDate dataend = get_dataend();
const char tipodoc = get_tipodoc();
const bool flagpro = is_provviso();
TFilename path;
f9_app().get_spotlite_path(path);
f9_app().get_spotlite_path(path);
// Vero e proprio oggetto estrazione
_estrazione = make_unique<TEstrazione>(
_estrazione = new TEstrazione(
F9CONF.get_ambiente(), // Codice ambiente
flagpro, // Flag prov.
tipodoc, // Tipo doc.
@ -167,49 +107,24 @@ int TEstrai_mask::estrai()
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
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
{
if (!progr->add_status())
break;
TToken_string elab_f9(recset_get_string(mov, MOV_ELABF9), ';'); // Stringa del campo elaborazione f9 nel file mov
const bool escluso = !(elab_f9.items() == 3 && elab_f9.get(2)[0] != 'X' || elab_f9.empty());
const TCausale caus(recset_get_string(mov, MOV_CODCAUS, 3), TDate(recset_get_string(mov, MOV_DATAREG)).year());
const bool stampato = recset_get_bool(mov, MOV_REGST);
for (bool ok = mov.move_first(); progr->add_status() && ok; ok = mov.move_next())
{
TToken_string elab_f9(mov.get_string(MOV_ELABF9), ';'); // Stringa del campo elaborazione f9 nel file mov
const bool escluso = !(elab_f9.items() == 3 && elab_f9.get_bool(2) || elab_f9.empty());
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 = recset_get_string(mov, MOV_NUMDOCEXT);
if(numdoc.empty())
numdoc = recset_get_string(mov, MOV_NUMDOC);
TString numdoc = mov.get_string(MOV_NUMDOCEXT);
if (numdoc.empty())
numdoc = mov.get_string(MOV_NUMDOC);
// Se definitivo controllo il flag di stampato REGST
if ((flagpro || stampato) && numdoc.full() && iva == tipo)
{
clifo.zero();
clifo.put(CLI_TIPOCF, tipo == iva_acquisti ? "F" : "C");
clifo.put(CLI_CODCF, recset_get_string(mov, MOV_CODCF));
// Creo il movimento da inserire
movimento_t t;
t.err = false;
t.numreg = recset_get_int (mov, MOV_NUMREG);
t.datareg = recset_get_date (mov, MOV_DATAREG);
t.datadoc = recset_get_date (mov, MOV_DATADOC);
t.codcaus = recset_get_string (mov, MOV_CODCAUS, 3);
t.meseliq = recset_get_int (mov, MOV_MESELIQ);
if (tipo == iva_vendite)
t.numdoc = get_numdoc_exp_fp(t.numreg);
if (t.numdoc.empty())
t.numdoc = numdoc;
t.tot = recset_get_real (mov, MOV_TOTDOC) + recset_get_real(mov, MOV_RITFIS) + recset_get_real(mov, MOV_RITSOC);
t.codcf = recset_get_int (mov, MOV_CODCF);
t.ragsoc = clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : " ";
t.reg_protiva = TString(recset_get_string(mov, MOV_REG)) << "/" << recset_get_string(mov, MOV_PROTIVA);
t.descr = recset_get_string (mov, MOV_DESCR);
if (escluso)
{
t.estratto = false;
t.descr_estr = movimento_t::escluso;
}
movimento_t t(mov, tipo, escluso);
// Effettivo inserimento del movimento
_estrazione->add_mov(t);
@ -396,8 +311,11 @@ void TMonitor_mask::controllo_errori() const
void TMonitor_mask::delete_estr_fld(const TString& idestr)
{
const TFilename dir = TString() << F9CONF.get_addr_doc_loc() << SLASH << F9CONF.get_ambiente() << SLASH << idestr << SLASH;
experimental::filesystem::remove_all((const char*)dir);
TFilename dir(F9CONF.get_addr_doc_loc());
dir << SLASH << F9CONF.get_ambiente() << SLASH << idestr << SLASH << "*";
remove_files(dir, true);
}
void TMonitor_mask::delete_pack(const bool all) const
@ -558,7 +476,7 @@ void TMonitor_mask::open_apri_estr_win()
if (last_fill_id != id)
{
_inclusi_mask = std::make_unique<TApri_estr_msk>();
_inclusi_mask = new TApri_estr_msk;
_inclusi_mask->set_from_row_estrazione(*row_estrazione);
_inclusi_mask->fill_estr();
@ -610,7 +528,7 @@ void TMonitor_mask::sel() const
TSheet_field& sf = sfield(S_ELAB);
FOR_EACH_SHEET_ROW_LOOP(sf, nr)
{
if (sf.get_bool_row_cell(F_SEL, nr))
if (sf.get_bool_row_cell(nr, F_SEL))
sf.set_row_cell(F_SEL, false, nr);
}
sf.force_update();
@ -653,16 +571,11 @@ void TControllo_mask::associa() // todo: levare gli ultimi residui del vecchio
if (ok)
{
// Tolgo il flag di in errore sul vettore in modo da rifare la fill e non venir piu' contato come da controllare
auto it = _controllo_mov.begin();
int count = -1;
while (count < _selected_mov && it != _controllo_mov.end())
{
if (it->get(0)[0] == 'X') // Devo saltare tutti quelli che non hanno il flag e contare solo quelli che ce l'hanno
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++;
if (count < _selected_mov)
++it;
}
it->add(' ', 0);
TF9_dberr::del_err(_cod_soc, _id_estr, mov_sel->get_int(cid2index(F_CNUMREG)));
}
}
@ -674,11 +587,10 @@ void TControllo_mask::conferma_esclusi() const
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(F_CESCLUDI, row))
if (sf.get_bool_row_cell(row, F_CESCLUDI))
{
const TDate today(TODAY);
TToken_string stato("", ';');
@ -715,9 +627,9 @@ void TControllo_mask::conferma_esclusi() const
sf.show();
}
vector<TToken_string>& TControllo_mask::import_error_list()
TArray& TControllo_mask::import_error_list()
{
_controllo_mov.clear();
_controllo_mov.destroy();
TF9_dberr dberr;
_tipo_doc_err = TF9_dberr::get_errori(_cod_soc, _id_estr, _controllo_mov);
return _controllo_mov;
@ -726,24 +638,22 @@ vector<TToken_string>& TControllo_mask::import_error_list()
void TControllo_mask::fill()
{
TSheet_field& sf = sfield(S_CONTROLLO);
sf.hide();
sf.destroy();
sf.reset();
if (!_is_escluso)
import_error_list();
else
_controllo_mov = f9_app()._esclusi;
for (auto it = _controllo_mov.begin(); it != _controllo_mov.end(); ++it)
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
{
TToken_string& row = sf.row(-1);
if (*it->get(0) == 'X')
TToken_string& sfrow = sf.row(-1);
if (row->get_bool(0))
{
row = *it;
row[0] = (char&)" ";
sfrow = *row;
sf.set_row_cell(101, false, r);
}
}
sf.force_update();
sf.show();
// Fill fppro sheet
if (!_is_escluso && _tipo_doc_err == 'A' || _is_escluso && f9_app().get_tipoiva_escl() == iva_acquisti)
fill_fppro_sheet();
@ -781,7 +691,7 @@ void TControllo_mask::fill_fppro_sheet() const
for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
{
const int row = sf.set_row_cell(F_FTIPODOC, "TIPODOC");
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);
@ -871,20 +781,16 @@ TToken_string* TControllo_mask::selected_fat() const
void TControllo_mask::selfatt(TOperable_field& o, const long jolly) const
{
const TMask& mask = *this;
TSheet_field* sf;
if (jolly == 1) // Sheet controllo
sf = &mask.sfield(S_CONTROLLO);
else
sf = &mask.sfield(S_FPPRO);
sf->hide();
FOR_EACH_SHEET_ROW(*sf, nr, row)
TSheet_field& sf = sfield(jolly == 1 ? S_CONTROLLO : S_FPPRO); // Sheet controllo o fppro
const int id = jolly == 1 ? F_CSEL : F_FSEL;
FOR_EACH_SHEET_ROW_LOOP(sf, row)
{
if (*row->get(0) == 'X')
row->add("", 0);
if (sf.get_bool_row_cell(row, id))
sf.set_row_cell(id, false, row);
}
sf->force_update();
sf->show();
sf.force_update();
}
bool TControllo_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
@ -976,11 +882,12 @@ TControllo_mask::TControllo_mask(const char* codsoc, const char* id_estr, const
_controllo_mov = f9_app()._esclusi;
_datada = EOTIME;
_dataa = 0L;
for (auto it = _controllo_mov.begin(); it != _controllo_mov.end(); ++it)
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
{
if (*it->get(0) == 'X')
if (row->get_bool(0))
{
TDate d = it->get(3);
const TDate& d = row->get_date(3);
if (d < _datada)
_datada = d;
if (d > _dataa)
@ -1099,52 +1006,60 @@ void TApri_estr_msk::fill_estr() const
"FROM " F9_IVA "\n"
"WHERE " IVA_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " IVA_IDLAN " = '" << _idestr << "'";
// REG + DATAREG + PROTIVA + DATAINC + DATA74TER + NUMREG
TString sql;
TSQL_recordset rec("");
fp_db().sq_set_exec(query, false);
TSheet_field& sf = sfield(S_ESCL);
sf.hide();
sf.destroy();
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;
sql.cut(0) << "SELECT NUMREG, DATAREG, DATADOC, CODCAUS, TIPODOC, MESELIQ, NUMDOC, TOTDOC, CODCF, REG, PROTIVA, DESCR, ELABF9\n"
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();
TToken_string& r = sf.row(-1);
r.add(" ", 0);
r.add(rec.get(0).as_string()); // Numreg
r.add(rec.get(1).as_string()); // Data reg
r.add(rec.get(2).as_string()); // Data doc
TString codcaus; codcaus << rec.get(3).as_string();
const int len = codcaus.len();
for (int i = 0; i < 3 - len; ++i)
codcaus.add_front("0");
r.add(codcaus); // Cod caus
r.add(rec.get(4).as_string()); // Tipo doc
r.add(rec.get(5).as_string()); // Mese liq
r.add(rec.get(6).as_string()); // Num doc
r.add(rec.get(7).as_string()); // Tot doc
r.add(rec.get(8).as_string()); // Clifo
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_CODCF, rec.get(8).as_string());
clifo.put(CLI_TIPOCF, _tipodoc == 'A' ? "F" : "C");
clifo.read();
r.add(clifo.get(CLI_RAGSOC)); // Rag soc
r.add(TString(rec.get(9).as_string()) << "/" << rec.get(10).as_string()); // Prot iva
r.add(rec.get(11).as_string()); // Descr
r.add(""); // Flag escludi
r.add(TToken_string(rec.get(12).as_string(), ';').get_bool(2)); // Escluso
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();
sf.show();
}
void TApri_estr_msk::fill_res() const
@ -1155,39 +1070,41 @@ void TApri_estr_msk::fill_res() const
fp_db().sq_set_exec(query, false);
TSheet_field& sf = sfield(S_RES);
sf.destroy();
TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione...");
for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
sf.reset();
for (bool ok = fp_db().sq_next(); prog.add_status() && ok; ok = fp_db().sq_next())
{
if (!prog.add_status())
break;
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
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, fp_db().sq_get(MES_NUMREG));
mov.read();
TToken_string& r = sf.row(-1);
r.add(fp_db().sq_get_int(MES_ESTR) ? "X" : " ", 0); // Estratto
r.add(mov.get(MOV_NUMREG)); // Numreg
r.add(mov.get_date(MOV_DATAREG)); // Data reg
r.add(mov.get_date(MOV_DATADOC)); // Data doc
r.add(mov.get(MOV_CODCAUS)); // Cod caus
r.add(mov.get(MOV_TIPODOC)); // Tipo doc
r.add(mov.get_int(MOV_MESELIQ)); // Mese liq
r.add(mov.get(MOV_NUMDOC)); // Num doc
r.add(mov.get_real(MOV_TOTDOC)); // Tot doc
r.add(mov.get_int(MOV_CODCF)); // Clifo
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_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
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_CODCF, mov.get(MOV_CODCF));
clifo.put(CLI_TIPOCF, mov.get(MOV_TIPO));
clifo.read();
TToken_string key(mov.get(MOV_TIPO));
r.add(clifo.get(CLI_RAGSOC)); // Rag soc
r.add(TString(mov.get(MOV_REG)) << "/" << mov.get(MOV_PROTIVA)); // Prot iva
r.add(mov.get(MOV_DESCR)); // Descr
r.add(fp_db().sq_get(MES_ERR)); // Descrizione errore
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_estr_msk::set_from_row_estrazione(TToken_string& row_estrazione)
@ -1265,7 +1182,7 @@ bool TF9_app::select_escl_notify(TSheet_field& s, int row, KEY key)
FOR_EACH_SHEET_ROW_LOOP(sf, nr)
{
if (sf.get_bool_row_cell(FE_SEL, nr))
if (sf.get_bool_row_cell(nr, FE_SEL))
sf.set_row_cell(FE_SEL, false, nr);
}
sf.force_update();
@ -1339,7 +1256,7 @@ void TF9_app::open_esclusi()
/* Caricamento esclusi
* LOADING DI QUEL MESE E ANNO */
f9_app()._esclusi_vect.clear();
f9_app()._esclusi_vect.destroy();
const int anno = ym_msk->get_int(501);
const int mese = ym_msk->get_int(502);
const int to_m = ym_msk->get_int(503);
@ -1378,7 +1295,7 @@ void TF9_app::open_esclusi()
m.add(clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : "");
m.add(TString(movs.get(MOV_REG)) << "/" << movs.get(MOV_PROTIVA));
m.add(movs.get(MOV_DESCR));
f9_app()._esclusi_vect.insert(f9_app()._esclusi_vect.end(), m);
f9_app()._esclusi_vect.add(m);
}
}
}
@ -1397,79 +1314,62 @@ void TF9_app::open_esclusi()
void TF9_app::fill_esclusi()
{
vector<TToken_string>& esclusi = f9_app()._esclusi_vect;
TArray & esclusi = f9_app()._esclusi_vect;
TSheet_field& sf = esclusi_mask().sfield(S_ESCL);
sf.destroy();
for (auto it = esclusi.begin(); it != esclusi.end(); ++it)
sf.row(-1) = *it;
FOR_EACH_ARRAY_ROW(esclusi, r, row)
sf.row(-1) = *row;
sf.force_update();
}
movimento_t TF9_app::escl2mov(TToken_string* row)
{
movimento_t t;
t.err = false;
t.numreg = row->get_int(1);
t.datareg = row->get(2);
t.datadoc = row->get(3);
t.codcaus = row->get(4);
t.meseliq = row->get_int(5);
t.numdoc = row->get(6);
t.tot = row->get(7);
t.codcf = row->get_int(8);
t.ragsoc = row->get_int(9);
t.reg_protiva = row->get(10);
t.descr = row->get(11);
t.state = null_state;
t.descr_err = "";
// todo: controllo attributi aggiunti.
t.estratto = true;
t.descr_estr = movimento_t::no_err;
return t;
}
bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
{
TMask& msk = esclusi_mask();
TF9_app& a = f9_app();
vector<TToken_string>& _esclusi = a._esclusi_vect;
TSheet_field& sf = msk.sfield(S_ESCL);
TMask descr_mask("Estrazione", 1, 60, 5);
descr_msk().run();
const TString descr = descr_msk().get(DES_TEXT);
descr_msk().set(DES_TEXT, "");
descr_mask.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
descr_mask.add_button_tool(DLG_CANCEL, "Annulla", TOOL_CANCEL);
descr_mask.add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, "");
descr_mask.add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40);
if (descr_mask.run() == K_ENTER)
{
TMask& msk = esclusi_mask();
TArray & _esclusi = f9_app()._esclusi_vect;
TSheet_field& sf = msk.sfield(S_ESCL);
const TString descr = descr_mask.get(DES_TEXT);
TFilename path;
TFilename path;
f9_app().get_spotlite_path(path);
a._estr_escluso =
new TEstrazione(F9CONF.get_ambiente(), a._flagprov_escl, a._tipodoc_escl, descr, F9CONF.get_addr_doc(), true, path);
f9_app().get_spotlite_path(path);
f9_app()._estr_escluso =new TEstrazione(F9CONF.get_ambiente(), f9_app()._flagprov_escl,
f9_app()._tipodoc_escl, descr,
F9CONF.get_addr_doc(), true, path);
// Prendo la riga selezionata (e controllo che sia selezionato qualcosa)
bool flag = false;
FOR_EACH_SHEET_ROW(sf, nr, row)
{
if (row->get(0)[0] == 'X')
{
const movimento_t mov = escl2mov(row);
a._estr_escluso->add_mov(mov);
_stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const int stato = a._estr_escluso->estrai();
if (stato == 1)
{
_esclusi.erase(_esclusi.begin() + nr); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov
a.segna_estratti(true, mov.numreg);
}
flag = true;
break;
}
}
if (!flag)
message_box("Selezionare il movimento da estrarre");
else
a.print_log();
fill_esclusi();
// Prendo la riga selezionata (e controllo che sia selezionato qualcosa)
bool flag = false;
FOR_EACH_SHEET_ROW_LOOP(sf, row)
{
if (sf.get_bool_row_cell(row, FE_SEL))
{
const movimento_t mov = f9_app().escl2mov(sf, row);
f9_app()._estr_escluso->add_mov(mov);
_stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const int stato = f9_app()._estr_escluso->estrai();
if (stato == 1)
{
_esclusi.destroy(row); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov
f9_app().segna_estratti(true, mov.numreg());
}
flag = true;
break;
}
}
if (!flag)
message_box("Selezionare il movimento da estrarre");
else
f9_app().print_log();
fill_esclusi();
}
return true;
}
@ -1505,35 +1405,26 @@ void TF9_app::print_log()
bool TF9_app::is_autofattura(const TLocalisamfile& mov)
{
return TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).tipo_doc() == "AF";
return cached_causale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).tipo_doc() == "AF";
}
bool TF9_app::segna_estratti(const bool escluso, const int numreg)
{
bool ok = true;
TArray escl; // <movimento_t>
vector<movimento_t> escl;
if (escluso)
{
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg);
mov.read();
TLocalisamfile clifo(LF_CLIFO); clifo.put(CLI_TIPOCF, mov.get(MOV_TIPO)); clifo.read();
const movimento_t m{ false, numreg, mov.get_date(MOV_DATAREG), mov.get_date(MOV_DATADOC), mov.get(MOV_CODCAUS), mov.get_int(MOV_MESELIQ), !mov.get(MOV_NUMDOCEXT).empty() ? mov.get(MOV_NUMDOCEXT) : mov.get(MOV_NUMDOC),
mov.get_real(MOV_TOTDOC), mov.get_int(MOV_CODCF), clifo.get(CLI_RAGSOC), mov.get(MOV_REG), mov.get(MOV_DESCR) };
escl.insert(escl.begin(), m); // todo: datareg?
}
vector<movimento_t>& movs_v = escluso ? escl : _movs;
escl.add(movimento_t(numreg)); // todo: datareg?
TLocalisamfile mov(LF_MOV);
TToken_string elab("", ';');
elab.add("X", 0); elab.add(today.date2ansi()); elab.add(" "); // "[flag estratto];[data estrazione];[flag escluso]"
for (auto it = movs_v.begin(); it != movs_v.end(); ++it)
TArray& movs_v = escluso ? escl : _movs;
TToken_string elab("X", ';'); // "[flag estratto];
elab.add(today.date2ansi()); elab.add(" "); // "[flag estratto];[data estrazione];[flag escluso]"
FOR_EACH_ARRAY_ITEM(movs_v, r, obj)
{
TString8 num_reg; num_reg << it->numreg;
mov.zero();
mov.put(MOV_NUMREG, num_reg);
mov.read();
const movimento_t & t = (movimento_t &) *obj;
TRectype& mov = (TRectype&) cache().get(LF_MOV, t.numreg());
mov.put(MOV_ELABF9, elab);
ok &= mov.rewrite() == NOERR;
}

35
src/f9/f90100.h
View File

@ -14,7 +14,7 @@
*/
class TEstrai_mask : public TMask
{
unique_ptr<TEstrazione> _estrazione; // Oggetto estrazione in corso di elaborazione
TEstrazione * _estrazione; // Oggetto estrazione in corso di elaborazione
void enable_fields(bool en = true);
@ -39,8 +39,8 @@ class TEstrai_mask : public TMask
static bool dataend_handler(TMask_field& f, KEY key);
public:
static TString get_numdoc_exp_fp(int numreg);
TEstrai_mask();
~TEstrai_mask() { safe_delete(_estrazione); };
};
@ -56,17 +56,16 @@ class TF9_app : public TSkeleton_application
friend class TEstrazione;
TEstrai_mask * _estr_msk;
TEstrai_mask * _estr_msk;
TMonitor_mask * _msk;
vector<movimento_t> _movs;
vector<TToken_string> _esclusi; // Vettore con i movimenti esclusi
vector<TToken_string> _esclusi_vect;
TToken_string _mov_escl;
char _tipodoc_escl;
char _flagprov_escl;
TString _log;
TEstrazione* _estr_escluso;
TArray _movs; // movimento_t
TArray _esclusi; // Vettore con i movimenti esclusi
TArray _esclusi_vect;
TToken_string _mov_escl;
char _tipodoc_escl;
char _flagprov_escl;
TString _log;
TEstrazione* _estr_escluso;
char get_tipodoc_escl() const { return _tipodoc_escl; }
@ -91,7 +90,7 @@ public:
void open_esclusi();
static void fill_esclusi();
static movimento_t escl2mov(TToken_string* row);
movimento_t TF9_app::escl2mov(TSheet_field & sf, int row) { return movimento_t(sf, row); }
static bool mov_handler_escl(TMask_field&, KEY key);
@ -121,6 +120,7 @@ public:
void main_loop() override;
TF9_app();
~TF9_app() { safe_delete(_estr_msk); safe_delete(_msk); }
};
inline TF9_app& f9_app()
@ -138,7 +138,7 @@ class TMonitor_mask : public TAutomask
{
friend class TF9_app;
vector<TToken_string> _fppro;
std::unique_ptr<TApri_estr_msk> _inclusi_mask;
TApri_estr_msk * _inclusi_mask;
// Configurazione mask
static bool save_conf_handler(TMask_field& f, KEY key);
@ -161,12 +161,13 @@ class TMonitor_mask : public TAutomask
void sel() const;
public:
TMonitor_mask();
TMonitor_mask();
~TMonitor_mask() { safe_delete(_inclusi_mask); }
};
class TControllo_mask : public TAutomask
{
vector<TToken_string> _controllo_mov; // Usare import_error_list().
TArray _controllo_mov; // Usare import_error_list().
char _ordin;
char _verso;
int _selected_mov;
@ -181,7 +182,7 @@ class TControllo_mask : public TAutomask
void associa();
void conferma_esclusi() const;
vector<TToken_string>& import_error_list();
TArray& import_error_list();
void fill();
void fill_fppro_sheet() const;
TMask& get_win_order();

200
src/f9/f9lib.h
View File

@ -21,6 +21,7 @@
// Controlla eventuali apostrofi e li raddoppia
const char* check_str(const TString& str);
const TString & get_numdoc_exp_fp(int numreg);
struct annesso_t
{
@ -150,15 +151,15 @@ public:
bool obblig{ false }; // Definisce se deve essere per forza presente l'annesso.
};
private:
std::vector<std::shared_ptr<classe_doc>> _rows;
std::vector<classe_doc *> _rows;
std::vector<std::pair<TString, std::shared_ptr<TArray_sheet>>> _sheets_annessi;
std::shared_ptr<TArray_sheet> _sheet_catdocs;
std::shared_ptr<std::set<TString>> _name_catdocs;
int _mode_sheet;
std::shared_ptr<TCategorie_doc::classe_doc> find_causcont(const TString& caus) const ; // OK
std::shared_ptr<TCategorie_doc::classe_doc> find_tipodoc(const TString& tipodoc) const ; // OK
std::shared_ptr<TCategorie_doc::classe_doc> find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const ; // OK
TCategorie_doc::classe_doc * find_causcont(const TString& caus) const ; // OK
TCategorie_doc::classe_doc * find_tipodoc(const TString& tipodoc) const ; // OK
TCategorie_doc::classe_doc * find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const ; // OK
std::vector<pair<TString, std::shared_ptr<TArray_sheet>>>::iterator find_sheet_annessi(const TString& catdoc); // OK
@ -189,12 +190,12 @@ public:
bool get_ann(const TString & catdoc, const TString& catann, _Out_ annesso& _Annesso_out);
TString_array get_array_ann(const TString& catdoc);
TString_array get_array_rows(bool traduci = false);
std::shared_ptr<classe_doc> get_classe_doc(const TString& catdoc);
classe_doc* get_classe_doc(const TString& catdoc);
std::set<TString>& get_name_catdocs() { get_sheet_catdocs(); return *_name_catdocs; }
std::shared_ptr<TArray_sheet> get_sheet_catdocs();
std::shared_ptr<TArray_sheet> get_sheet_ann(const TString& catdoc);
std::shared_ptr<classe_doc> mov2cat(int numreg);
const char * tipo2caus_cont(const TString & tipodoc, const char * tipocaus) { std::shared_ptr<TCategorie_doc::classe_doc> c = find_tipodocsdi(tipodoc, tipocaus); if (c != nullptr) return c->causcont; else return ""; }
classe_doc * mov2cat(const long numreg);
const TString & tipo2caus_cont(const TString & tipodoc, const char * tipocaus) { TCategorie_doc::classe_doc * c = find_tipodocsdi(tipodoc, tipocaus); if (c != nullptr) return c->causcont; else return EMPTY_STRING; }
void reload();
static void remove_all();
static void remove_all_ann();
@ -227,111 +228,93 @@ public:
TRecord_categorie(type table = catdocs);
};
struct movimento_t
enum err_mov
{
enum err_mov
{
no_err, // Estratto normalmente.
escluso, // Movimento con flag escluso.
no_catdoc, // Nessuna cat. doc. riconosciuta per questo movimento, o non e' una fattura.
no_doc, // Il mov. di vendita non ha un documento generatore.
notfound_elet, // Non trovata fatt. elettronica mov vendita.
no_fa, // Movimento di acquisto non e' una fattura.
no_fv, // Movimento di vendita non e' una fattura.
no_cartaceo, // Movimento cartaceo che non ha bisogno di essere estratto.
pura_iva, // Movimento di sola IVA (integrazione Rev. Charge)
no_filecart, // Il documento cartaceo non ha associato un file, o questo non e' stato trovato.
annesso_nexist // Un annesso obbligatorio e' mancante.
};
mov_no_error, // Estratto normalmente.
mov_escluso, // Movimento con flag escluso.
mov_no_catdoc, // Nessuna cat. doc. riconosciuta per questo movimento, o non e' una fattura.
mov_no_doc, // Il mov. di vendita non ha un documento generatore.
mov_notfound_elet, // Non trovata fatt. elettronica mov vendita.
mov_no_fa, // Movimento di acquisto non e' una fattura.
mov_no_fv, // Movimento di vendita non e' una fattura.
mov_no_cartaceo, // Movimento cartaceo che non ha bisogno di essere estratto.
mov_pura_iva, // Movimento di sola IVA (integrazione Rev. Charge)
mov_no_filecart, // Il documento cartaceo non ha associato un file, o questo non e' stato trovato.
mov_annesso_nexist // Un annesso obbligatorio e' mancante.
};
bool err{ false };
int numreg;
TDate datareg;
TDate datadoc;
TString codcaus;
int meseliq;
TString numdoc;
real tot;
int codcf;
TString ragsoc;
TString reg_protiva;
TString descr;
state_fppro state{ null_state };
TString descr_err{}; // Messaggio di errore visibile dal controllo estrazione.
bool estratto{ true };
err_mov descr_estr{ no_err }; // Messaggio di informazioni visibile dal 'Apri Estr.'
std::shared_ptr<TCategorie_doc::classe_doc> catdoc{ nullptr };
bool cartaceo{ false };
TFilename nomefilecart{};
vector<annesso_t> annessi{};
class movimento_t : public TObject // aggiungere metodi per TArray
{
static const char* err_mov2name(const err_mov descr_estr)
{
switch (descr_estr)
{
case no_err:
return "OK";
case escluso:
return "Il movimento e' segnato come escluso. Saltato.";
case no_catdoc:
return "Nessuna categoria documentale riconosciuta per questo movimento, o non e' una fattura.";
case no_doc:
return "Il mov. di vendita non ha un documento generatore";
case notfound_elet:
return "Non trovata fatt. elettronica mov vendita";
case no_fa:
return "Questo movimento di acquisto non e' una fattura";
case no_fv:
return "Movimento di vendita non e' una fattura.";
case no_cartaceo:
return "Movimento cartaceo che non ha bisogno di essere estratto";
case pura_iva:
return "Movimento di sola IVA. (Le integrazioni Rev. Charge sono gestite come annessi alle vendite)";
case annesso_nexist:
return "Un annesso obbligatorio e' mancante.";
default: return "";
}
}
const char* get_descr_estr() const
{
return err_mov2name(descr_estr);
}
bool _err;
long _numreg;
TDate _datareg;
TDate _datadoc;
TString _codcaus;
int _meseliq;
TString _numdoc;
real _tot;
long _codcf;
TString _ragsoc;
TString _reg_protiva;
TString _descr;
state_fppro _state;
TString _descr_err; // Messaggio di errore visibile dal controllo estrazione.
bool _estratto;
err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.'
TCategorie_doc::classe_doc* _catdoc;
bool _cartaceo;
TFilename _nomefilecart;
vector<annesso_t> _annessi;
TString get(const int i) const
{
TString a;
switch (i)
{
case 0: return err;
case 1: return a << numreg;
case 2: return (const char*)datareg;
case 3: return (const char*)datadoc;
case 4: return codcaus;
case 5: return a << meseliq;
case 6: return numdoc;
case 7:
a << tot;
if (a == "0")
a << ".0";
return a;
case 8: return a << codcf;
case 9: return ragsoc;
case 10: return reg_protiva;
case 11: return descr;
case 14: return descr_err;
default: return "";
}
}
public:
static const char* err_mov2name(const err_mov descr_estr);
const char* get_descr_estr() const { return err_mov2name(_descr_estr); }
bool err() const { return _err; }
bool no_err() const { return !err(); }
long numreg() const { return _numreg; }
const TDate & datareg() const { return _datareg; }
const TDate & datadoc() const { return _datadoc; }
const TString & codcaus() const { return _codcaus; }
int meseliq() const { return _meseliq; }
const TString & numdoc() const { return _numdoc; }
real totale() const { return _tot; }
long codcf() const { return _codcf; }
const TString & ragsoc() const { return _ragsoc; }
const TString & protiva() const { return _reg_protiva; }
const TString & descr() const { return _descr; }
state_fppro state() const { return _state; }
const TString & descr_err() const { return _descr_err; }
bool estratto() const { return _estratto; }
err_mov descr_estr() const { return _descr_estr; }
TCategorie_doc::classe_doc* catdoc() const { return _catdoc; }
vector<annesso_t> annessi() const { return _annessi; }
bool cartaceo() const { return _cartaceo; } // todo
const TFilename & nomefilecart() const { return _nomefilecart; }
bool is_cartaceo() const { return false; } // todo
// void set_err(bool err) { _err = err; }
void set_err(const char * descr = "", err_mov descr_estr = mov_no_error);
void reset_err() { set_err(); }
void set_cartaceo(bool cartaceo) { _cartaceo = cartaceo; }
void set_state(state_fppro state) { _state = state; }
void set_descr_estr(err_mov descr_estr) { _descr_estr = descr_estr; }
void set_numdoc(const char * numdoc) { _numdoc = numdoc; }
void set_estratto(bool estratto) { _estratto = estratto; }
void set_catdoc(TCategorie_doc::classe_doc* catdoc) { _catdoc = catdoc; }
void set_nomefilecart(const char * nomefilecart) { _nomefilecart = nomefilecart; }
movimento_t(TSheet_field& sf, int row);
movimento_t(const long numreg);
movimento_t(TISAM_recordset & mov, TipoIVA tipo, bool escl);
~movimento_t() { safe_delete(_catdoc); }
};
class TEstrazione : public TObject
{
drd _head;
vector<movimento_t> _movs;
unique_ptr<ofstream> _error_sql;
ofstream * _error_sql;
bool _escluso;
const TString _descr;
bool _has_cartacei;
@ -360,9 +343,9 @@ class TEstrazione : public TObject
static state_fppro check_fppro(int numreg);
bool check_periodo_def() const;
void copy_file_to_webapp_fld(const movimento_t& movimento) const;
static void fill_id(TLocalisamfile& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis);
static void fill_id(const TRectype& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis);
TipoIVA get_tipoiva() const { return _head.tipo_doc == 'A' ? iva_acquisti : iva_vendite; }
static bool is_doc_xml(const TLocalisamfile& mov);
static bool is_doc_xml(const TRectype& mov);
static bool find_movcoll(int numreg, _Out_ TString& numreg_rev_vend);
static bool load_annessi(movimento_t& movimento);
// Se il movimento e' di vendita e ha i riferimenti al documento generatore provo a stamparlo con ve, e lo inserisco tra i cartacei F9.
@ -384,7 +367,7 @@ private:
* genera il progressivo seguente. Chiamata da \a estrai() e \a estrai_single().
* \return Nuovo id estrazione. */
TString next_estr_today(char tipo) const;
static bool pura_iva(const TLocalisamfile& mov);
static bool pura_iva(const TRectype& mov);
void write_errorsql_log(const TString& query) const;
static TCategorie_doc& categorie_doc(bool reload = false);
@ -437,6 +420,7 @@ public:
TEstrazione(const TString& ambiente, bool flag_prov, char tipodoc, const TString& descr, const TString& addrcart,
bool escluso, TFilename& spotlite_path, const TDate* dal = nullptr, const TDate* al = nullptr, bool has_cartacei = false);
~TEstrazione() { safe_delete(_error_sql); }
};
@ -457,7 +441,7 @@ public:
void add() { add_str("NULL"); }
bool send();
static bool del_err(const TString& codsoc, const TString& id_estr, int numreg);
static char get_errori(const TString& codsoc, const TString& id_estr, vector<TToken_string>& controllo_mov);
static char get_errori(const TString& codsoc, const TString& id_estr, TArray& controllo_mov);
TF9_dberr();
};
@ -489,10 +473,10 @@ class TF9_doccart
public:
static bool add_cart(const TFilename& file, const TString& numreg, bool is_annesso = false,
const TString& catannpadre = "", const TString& catdocann = "", bool suppress_errors = true);
bool doc_already_exists(const TFilename& file, _Out_ TString& numreg, _Out_ bool& annesso);
bool mov2doc(const TString& numreg, _Out_ TFilename& doc);
bool mov2listann(const TString& numreg, _Out_ TString_array& list_annessi);
bool mov2listann_vect(const TString& numreg, _Out_ vector<annesso_t>& list_annessi);
bool doc_already_exists(const TFilename& file, TString& numreg, bool& annesso);
bool mov2doc(const TString& numreg, TFilename& doc);
bool mov2listann(const TString& numreg, TString_array& list_annessi);
bool mov2listann_vect(const TString& numreg, vector<annesso_t>& list_annessi);
static TString get_full_path_file_cartaceo(const TString& filename)
{

490
src/f9/f9lib01.cpp
View File

@ -1,7 +1,8 @@
//#include <Windows.h>
#include "f9lib.h"
#include <dongle.h>
#include <execp.h>
#include "../f1/f1lib.h"
#include "f901tab.h"
#include "progind.h"
@ -10,13 +11,147 @@
#include "mov.h"
#include "../fp/fplib.h"
#include "annessif9.h"
#include "dongle.h"
#include "execp.h"
#include "f90100c.h"
#define MODE_SHEETS 0xC
statistics _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const TString & get_numdoc_exp_fp(const int numreg)
{
TRectype & mov = (TRectype&)cache().get(LF_MOV, numreg);
TString & numdoc = get_tmp_string();
if (mov.full())
{
const TString& dprovv = mov.get(MOV_DPROVV);
const int danno = mov.get_int(MOV_DANNO);
const TString& dcodnum = mov.get(MOV_DCODNUM);
const int dndoc = mov.get_int(MOV_DNDOC);
if (!dprovv.empty() && danno != 0 && !dcodnum.empty() && dndoc != 0)
{
const TDocumento doc(dprovv[0], danno, dcodnum, dndoc);
numdoc = complete_num_fp(doc.codice_numerazione(), doc.numero());
}
}
return numdoc;
}
///////////////////////////////////////////////////////////////////////////////
// movimento_t
///////////////////////////////////////////////////////////////////////////////
const char* movimento_t::err_mov2name(const err_mov descr_estr)
{
switch (descr_estr)
{
case mov_no_error:
return "OK";
case mov_escluso:
return "Il movimento e' segnato come escluso. Saltato.";
case mov_no_catdoc:
return "Nessuna categoria documentale riconosciuta per questo movimento, o non e' una fattura.";
case mov_no_doc:
return "Il mov. di vendita non ha un documento generatore";
case mov_notfound_elet:
return "Non trovata fatt. elettronica mov vendita";
case mov_no_fa:
return "Questo movimento di acquisto non e' una fattura";
case mov_no_fv:
return "Movimento di vendita non e' una fattura.";
case mov_no_cartaceo:
return "Movimento cartaceo che non ha bisogno di essere estratto";
case mov_pura_iva:
return "Movimento di sola IVA. (Le integrazioni Rev. Charge sono gestite come annessi alle vendite)";
case mov_annesso_nexist:
return "Un annesso obbligatorio e' mancante.";
default: return "";
}
}
movimento_t::movimento_t(TSheet_field& sf, int row) : _err(false), _state(null_state), _estratto(true),
_descr_estr(mov_no_error), _catdoc(nullptr), _cartaceo(false)
{
_numreg = sf.get_long_row_cell(row, FE_NUMREG);
_datareg = sf.get_date_row_cell(row, FE_DATAREG);
_datadoc = sf.get_date_row_cell(row, FE_DATADOC);
_codcaus = sf.get_str_row_cell(row, FE_CODCAUS);
_meseliq = sf.get_int_row_cell(row, FE_MESELIQ);
_numdoc = sf.get_str_row_cell(row, FE_NUMDOC);
_tot = sf.get_real_row_cell(row, FE_IMPTOTDOC);
_codcf = sf.get_long_row_cell(row, FE_FORN);
_ragsoc = sf.get_long_row_cell(row, FE_RAGSOC);
_reg_protiva = sf.get_str_row_cell(row, FE_PROTIVA);
_descr = sf.get_long_row_cell(row, FE_DESCR);
}
void movimento_t::set_err(const char * descr, err_mov descr_estr)
{
bool error = descr && *descr;
_err = error ;
_estratto = !error || (descr_estr != mov_no_fa && descr_estr != mov_no_cartaceo);
_descr_err = descr;
if (descr_estr != mov_no_error)
_descr_estr = descr_estr;
else
_descr_estr = error ? mov_annesso_nexist : mov_no_error;
}
movimento_t::movimento_t(const long numreg) : _err(false), _state(null_state), _estratto(true), _descr_estr(mov_no_error),
_catdoc(nullptr), _cartaceo(false)
{
const TRectype & mov = cache().get(LF_MOV, numreg);
TToken_string key(mov.get(MOV_TIPO));
key.add(mov.get(MOV_CODCF));
const TRectype & clifo = cache().get(LF_CLIFO, key);
_numreg = numreg;
_datareg = mov.get_date(MOV_DATAREG);
_datadoc = mov.get_date(MOV_DATADOC);
_codcaus = mov.get(MOV_CODCAUS);
_meseliq = mov.get_int(MOV_MESELIQ);
_numdoc = mov.get(MOV_NUMDOCEXT).full() ? mov.get(MOV_NUMDOCEXT) : mov.get(MOV_NUMDOC);
_tot = mov.get_real(MOV_TOTDOC); // perchè no ? +mov.get_real(MOV_RITFIS) + mov.get_real(MOV_RITSOC);
_codcf = mov.get_long(MOV_CODCF);
_ragsoc = clifo.get(CLI_RAGSOC);
_reg_protiva = mov.get(MOV_REG);
_reg_protiva << "/" << mov.get(MOV_PROTIVA); // perchè c'era solo mov_reg ?
_descr = mov.get(MOV_DESCR);
}
movimento_t::movimento_t(TISAM_recordset & mov, TipoIVA tipo, bool escl) : _err(false), _state(null_state),
_estratto(true), _descr_estr(mov_no_error),
_catdoc(nullptr), _cartaceo(false)
{
_numreg = mov.get_long(MOV_NUMREG);
_datareg = mov.get_date(MOV_DATAREG);
_datadoc = mov.get_date(MOV_DATADOC);
_codcaus = mov.get_string(MOV_CODCAUS).left(3); // perchè 3 caratteri ?
_meseliq = mov.get_int(MOV_MESELIQ);
if (tipo == iva_vendite)
_numdoc = get_numdoc_exp_fp(_numreg);
if (_numdoc.empty())
_numdoc = mov.get_string(MOV_NUMDOCEXT);
_tot = mov.get_real(MOV_TOTDOC) + mov.get_real(MOV_RITFIS) + mov.get_real(MOV_RITSOC);
_codcf = mov.get_long(MOV_CODCF);
TToken_string key(tipo == iva_acquisti ? "F" : "C");
key.add(_codcf);
_ragsoc = cache().get(LF_CLIFO, key, CLI_RAGSOC);
_reg_protiva = mov.get_string(MOV_REG);
_reg_protiva << "/" << mov.get_string(MOV_PROTIVA);
_descr = mov.get_string(MOV_DESCR);
if (escl)
{
_estratto = false;
_descr_estr = mov_escluso;
}
}
///////////////////////////////////////////////////////////////////////////////
// TEstrazione
///////////////////////////////////////////////////////////////////////////////
@ -41,15 +176,14 @@ const char* TEstrazione::caus_sos(const TLocalisamfile& mov, const TipoIVA iva)
void TEstrazione::check_annessi(movimento_t& mov_i, const int numreg)
{
TToken_string ann_nexist;
if (!check_annessi_oblig(mov_i.catdoc->catdoc, numreg, ann_nexist))
if (!check_annessi_oblig(mov_i.catdoc()->catdoc, numreg, ann_nexist))
{
TString msg_annessi_mancanti("Annessi obligatori mancanti: ");
for (int i = 0; i < ann_nexist.items(); ++i)
msg_annessi_mancanti << ann_nexist.get() << " ";
mov_i.err = true;
mov_i.estratto = false;
mov_i.descr_err = msg_annessi_mancanti;
mov_i.descr_estr = movimento_t::annesso_nexist;
mov_i.set_err(msg_annessi_mancanti);
}
else
{
@ -102,7 +236,7 @@ bool TEstrazione::check_cartaceo_acq(const movimento_t& movimento)
{
TF9_doccart filecart;
TFilename file;
TString reg; reg << movimento.numreg;
TString reg; reg << movimento.numreg();
return filecart.mov2doc(reg, file) && file.exist();
}
@ -178,14 +312,14 @@ void TEstrazione::copy_file_to_webapp_fld(const movimento_t& movimento) const
TToken_string categorie;
TToken_string files;
if(movimento.cartaceo && movimento.catdoc != nullptr)
if(movimento.cartaceo() && movimento.catdoc() != nullptr)
{
categorie.add(movimento.catdoc->catdoc, 0);
files.add(movimento.nomefilecart, 0);
categorie.add(movimento.catdoc()->catdoc, 0);
files.add(movimento.nomefilecart(), 0);
}
if(!movimento.annessi.empty())
if(!movimento.annessi().empty())
{
for (auto it = movimento.annessi.begin(); it != movimento.annessi.end(); ++it)
for (auto it = movimento.annessi().begin(); it != movimento.annessi().end(); ++it)
{
categorie.add(it->catdocann);
files.add(TF9_doccart::get_full_path_file_cartaceo(it->filename));
@ -207,7 +341,7 @@ void TEstrazione::copy_file_to_webapp_fld(const movimento_t& movimento) const
}
}
void TEstrazione::fill_id(TLocalisamfile& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis)
void TEstrazione::fill_id(const TRectype& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis)
{
idfisc.cut(0);
statopaiv = clifo.get(CLI_STATOPAIV);
@ -252,16 +386,16 @@ void TEstrazione::fill_id(TLocalisamfile& clifo, TString& statopaiv, TString& id
}
}
bool TEstrazione::is_doc_xml(const TLocalisamfile& mov)
bool TEstrazione::is_doc_xml(const TRectype& mov)
{
const TString& tipocf = mov.get(MOV_TIPO);
const TString& codcf = mov.get(MOV_CODCF);
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_TIPOCF, tipocf);
clifo.put(CLI_CODCF, codcf);
clifo.read();
TToken_string key(mov.get(MOV_TIPO));
key.add(mov.get(MOV_CODCF));
const TRectype & clifo= cache().get(LF_CLIFO, key);
const TString& statopaiv = clifo.get(CLI_STATOPAIV);
return (IS_ITALIANO(statopaiv)) && clifo.get(CLI_COMCF) != "B513"; // Campione d'Italia
return (IS_ITALIANO(statopaiv)) && clifo.get(CLI_COMCF) != "B513"; // Campione d'Italia
}
bool TEstrazione::find_movcoll(const int numreg, _Out_ TString& numreg_rev_vend)
@ -298,8 +432,9 @@ bool TEstrazione::find_movcoll(const int numreg, _Out_ TString& numreg_rev_vend)
bool TEstrazione::load_annessi(movimento_t& movimento)
{
TF9_doccart doccart;
TString numreg; numreg << movimento.numreg;
return doccart.mov2listann_vect(numreg, movimento.annessi);
TString numreg; numreg << movimento.numreg();
return doccart.mov2listann_vect(numreg, movimento.annessi());
}
bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file)
@ -307,7 +442,7 @@ bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file
bool ok = false;
// Se il movimento e' di vendita e ha i riferimenti al documento generatore provo a stamparlo con ve, e lo inserisco tra i cartacei F9.
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, movimento.numreg);
mov.put(MOV_NUMREG, movimento.numreg());
if (mov.read() == NOERR &&
!mov.get(MOV_DPROVV).empty() && !mov.get(MOV_DANNO).empty() && !mov.get(MOV_DCODNUM).empty() && !mov.get(MOV_DNDOC).empty())
{
@ -327,7 +462,7 @@ bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file
{
file.cut(0) << pdf;
TString numreg; numreg << movimento.numreg;
TString numreg; numreg << movimento.numreg();
// Controllo anche se false perche' potrebbe esistere gia'.
if(!TF9_doccart::add_cart(file, numreg))
{
@ -347,7 +482,8 @@ bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file
bool TEstrazione::grab_pdf_from_spotlite(const movimento_t& movimento, TFilename& file) const
{
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, movimento.numreg);
mov.put(MOV_NUMREG, movimento.numreg());
if (mov.read() == NOERR &&
!mov.get(MOV_DPROVV).empty() && !mov.get(MOV_DANNO).empty() && !mov.get(MOV_DCODNUM).empty() && !mov.get(MOV_DNDOC).empty())
{
@ -475,8 +611,8 @@ bool TEstrazione::insert_into_f9movestr() const
break;
query.cut(0) << "INSERT INTO " F9_MOVESTR " (" MES_CODSOC ", IDESTR, NUMREG, DATAREG, ESTRATTO, DESCR_ERR)\nVALUES " <<
" ('" << _head.cod_soc << "', '" << _head.id_estr << "', '" << it->numreg << "', '" << it->datareg.date2ansi() << "', " <<
(it->estratto ? "1" : "0") << ", '" << check_str(it->get_descr_estr()) << "')";
" ('" << _head.cod_soc << "', '" << _head.id_estr << "', '" << it->numreg() << "', '" << it->datareg().date2ansi() << "', " <<
(it->estratto() ? "1" : "0") << ", '" << check_str(it->get_descr_estr()) << "')";
ok &= fp_db().sq_set_exec(query) && fp_db().sq_commit();
if (!ok)
{
@ -499,24 +635,22 @@ bool TEstrazione::export_error_list() const
if (!pg.add_status())
break;
if (it->err)
if (it->err())
{
dberr.add(_head.cod_soc);
dberr.add(_head.id_estr);
for (int i = 1; i < 15; i++)
{
TString string(it->get(i));
if (i == 2 || i == 3) // Sono obbligato a far cosi' per aggiungere le date
dberr.add(TDate(it->get(i)));
else if (string.full())
{
string.replace("'", "''");
dberr.add(string);
}
else
dberr.add(); // Se vuoto metto NULL
}
dberr.add(it->numreg());
dberr.add(it->datareg());
dberr.add(it->datadoc());
dberr.add(it->codcaus());
dberr.add(it->meseliq());
dberr.add(it->numdoc());
dberr.add(it->totale().stringa());
dberr.add(it->codcf());
dberr.add(it->ragsoc());
dberr.add(it->protiva());
dberr.add(it->descr());
dberr.add(it->descr_err());
if (!(ok &= dberr.send()))
break;
++count;
@ -554,7 +688,7 @@ TString TEstrazione::next_estr_today(char tipo) const
return TString(estr);
}
bool TEstrazione::pura_iva(const TLocalisamfile& mov)
bool TEstrazione::pura_iva(const TRectype& mov)
{
if (TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).soloiva())
return true;
@ -631,16 +765,16 @@ const char* TEstrazione::diagnostica_mov()
movimento_t& mov_i = *it;
// Se gia' escluso passo avanti
if (!mov_i.estratto && mov_i.descr_estr == movimento_t::escluso)
if (!mov_i.estratto() && mov_i.descr_estr() == mov_escluso)
continue;
if (!mov_i.err && mov_i.estratto)
if (mov_i.no_err() && mov_i.estratto())
{
const int numreg = mov_i.numreg;
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg);
mov.read();
mov_i.cartaceo = !is_doc_xml(mov);
const long numreg = mov_i.numreg();
const TRectype & mov =cache().get(LF_MOV, numreg);
mov_i.set_cartaceo(!is_doc_xml(mov));
const state_fppro res = check_fppro(numreg);
switch (res)
{
@ -649,32 +783,27 @@ const char* TEstrazione::diagnostica_mov()
ok &= fppro_db().associa_mov(numreg);
case correct:
ok &= true;
mov_i.err = false;
mov_i.numdoc = fppro_db().get_numdoc();
mov_i.reset_err();
mov_i.set_numdoc(fppro_db().get_numdoc());
break;
// ERRORS
// Errore non bloccante (skip)
case not_fa:
ok &= true;
mov_i.err = false;
mov_i.estratto = false;
mov_i.descr_estr = movimento_t::no_fa;
mov_i.set_err("", mov_no_fa);
mov_i.set_estratto(false);
++_stats.fa_skip;
break;
// ERRORI BLOCCANTI
case reg_with_err:
ok &= false;
mov_i.err = true;
mov_i.estratto = false;
mov_i.descr_err = "Errore controllo movimento: associazione movimento con fattura elettronica passiva sbagliato.";
mov_i.set_err("Errore controllo movimento: associazione movimento con fattura elettronica passiva sbagliato.");
break;
case err_read_db:
ok &= false;
mov_i.err = true;
mov_i.estratto = false;
mov_i.descr_err = "Errore controllo movimento: errore lettura db.";
mov_i.set_err("Errore controllo movimento: errore lettura db.");
break;
case no_guessed:
// Controllo se esiste il cartaceo es. forfettari => la considero cartacea.
@ -682,73 +811,67 @@ const char* TEstrazione::diagnostica_mov()
if(check_cartaceo_acq(mov_i))
{
ok &= true;
mov_i.err = false;
mov_i.cartaceo = true;
mov_i.estratto = true;
mov_i.descr_err = "";
mov_i.state = correct;
mov_i.set_err("");
mov_i.set_cartaceo(true);
mov_i.set_state(correct);
}
else
{
ok &= false;
mov_i.err = true;
mov_i.estratto = false;
mov_i.descr_err = "Non associato a fattura elettr. abbinamento automatico non riuscito. Abbinare manualmente, o escludere";
mov_i.set_err("Non associato a fattura elettr. abbinamento automatico non riuscito. Abbinare manualmente, o escludere");
}
default: break;
}
if(mov_i.state == null_state)
mov_i.state = res;
if(mov_i.state() == null_state)
mov_i.set_state(res);
if (mov_i.err) ++_stats.fa_err;
if (mov_i.err())
++_stats.fa_err;
/* Per quelli che hanno passato il primo controllo errori controllo che debba essere estratto
* secondo le categorie documentali. */
if (mov_i.estratto)
if (mov_i.estratto())
{
if (!mov_i.err)
if (mov_i.no_err())
{
// Cerco la categoria documentale
std::shared_ptr<TCategorie_doc::classe_doc> cd = categorie_doc().mov2cat(mov_i.numreg);
mov_i.estratto = cd.get();
mov_i.descr_estr = cd ? movimento_t::no_err : movimento_t::no_catdoc;
mov_i.catdoc = cd;
TCategorie_doc::classe_doc * cd = categorie_doc().mov2cat(mov_i.numreg());
const bool found = cd != nullptr;
if (mov_i.catdoc)
mov_i.set_estratto(found);
mov_i.set_descr_estr(cd ? mov_no_error : mov_no_catdoc);
mov_i.set_catdoc(cd);
if (found)
check_annessi(mov_i, numreg);
}
// Se cartaceo preparo il file.
if (F9CONF.get_has_cartexp()) // Se e' abilitata l'esportazione dei cartacei, altrimenti skip...
{
if (mov_i.cartaceo)
if (mov_i.cartaceo())
{
TF9_doccart filecart;
TFilename file;
TString reg; reg << it->numreg;
TString reg; reg << it->numreg();
if (filecart.mov2doc(reg, file) && file.exist())
mov_i.nomefilecart << file;
mov_i.set_nomefilecart(file);
else
{
mov_i.err = true;
mov_i.estratto = false;
mov_i.descr_err = "Non e' stato possibile reperire il file del documento cartaceo per questo movimento.";
mov_i.descr_estr = movimento_t::no_filecart;
}
mov_i.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart);
}
else
{
ok &= true;
mov_i.err = false;
mov_i.estratto = false;
mov_i.descr_estr = movimento_t::no_cartaceo; // Cartaceo che non ha bisogno di essere estratto.
mov_i.set_err("", mov_no_cartaceo);
mov_i.set_estratto(false);
++_stats.fa_skip;
}
}
copy_file_to_webapp_fld(mov_i);
}
}
ok &= !mov_i.err;
ok &= mov_i.no_err();
}
}
else if (tipo == iva_vendite)
@ -763,34 +886,35 @@ const char* TEstrazione::diagnostica_mov()
movimento_t& mov_i = *it;
// Se escluso passo avanti
if (!mov_i.estratto && mov_i.descr_estr == movimento_t::escluso)
if (!mov_i.estratto() && mov_i.descr_estr() == mov_escluso)
continue;
TString numreg; numreg << mov_i.numreg;
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg);
mov.read();
const long numreg = mov_i.numreg();
const TRectype & mov = cache().get(LF_MOV, numreg);
/* Controlli per vendite cambiati:
* Elettroniche solo quelle agli italiani, tutti gli altri sono cartacei
*/
if (!mov_i.err && mov_i.estratto)
if (!mov_i.err() && mov_i.estratto())
{
mov_i.cartaceo = !is_doc_xml(mov);
mov_i.set_cartaceo(!is_doc_xml(mov));
unsigned short skip = 0;
if (!_has_cartacei && mov_i.cartaceo) skip |= 0x1;
else if (pura_iva(mov)) skip |= 0x2;
else if (mov_i.datadoc.empty() || mov_i.numdoc.empty()) skip |= 0x4;
if (!_has_cartacei && mov_i.cartaceo()) skip |= 0x1;
else
if (pura_iva(mov)) skip |= 0x2;
else if (mov_i.datadoc().empty() || mov_i.numdoc().empty()) skip |= 0x4;
if(skip)
{
++_stats.fv_cart_skip;
mov_i.err = false;
mov_i.estratto = false;
mov_i.reset_err();
mov_i.set_estratto(false);
switch(skip)
{
case 0x1: mov_i.descr_estr = movimento_t::no_cartaceo; break;
case 0x2: mov_i.descr_estr = movimento_t::pura_iva; break;
case 0x4: mov_i.descr_estr = movimento_t::no_fv;
case 0x1: mov_i.set_descr_estr(mov_no_cartaceo); break;
case 0x2: mov_i.set_descr_estr(mov_pura_iva); break;
case 0x4: mov_i.set_descr_estr(mov_no_fv); break;
default: break;
}
}
@ -805,46 +929,42 @@ const char* TEstrazione::diagnostica_mov()
}*/
else
{
std::shared_ptr<TCategorie_doc::classe_doc> cd = categorie_doc().mov2cat(mov_i.numreg);
mov_i.err = false;
mov_i.estratto = cd.get();
mov_i.descr_estr = cd ? movimento_t::no_err : movimento_t::no_catdoc;
mov_i.catdoc = cd;
TCategorie_doc::classe_doc* cd = categorie_doc().mov2cat(mov_i.numreg());
const bool found = cd != nullptr;
if (found)
mov_i.reset_err();
else
mov_i.set_err("Categoria assente", mov_no_catdoc);
mov_i.set_catdoc(cd);
if (mov_i.catdoc())
check_annessi(mov_i, mov_i.numreg());
if (mov_i.catdoc)
check_annessi(mov_i, mov_i.numreg);
if (!mov_i.catdoc)
if (!mov_i.catdoc())
++_stats.fv_nocatdoc;
if (mov_i.err)
if (mov_i.err())
++_stats.fv_err;
else if (mov_i.estratto)
else if (mov_i.estratto())
++_stats.fv_estr;
}
if (mov_i.estratto)
if (mov_i.estratto())
{
if (mov_i.cartaceo)
if (mov_i.cartaceo())
{
TF9_doccart filecart;
TFilename file;
TString reg; reg << it->numreg;
TString reg; reg << it->numreg();
if (filecart.mov2doc(reg, file) && file.exist() || grab_pdf_from_spotlite(mov_i, file) && file.exist())
{
mov_i.nomefilecart << file;
}
else
{
mov_i.err = true;
mov_i.estratto = false;
mov_i.descr_err = "Non e' stato possibile reperire il file del documento cartaceo per questo movimento.";
mov_i.descr_estr = movimento_t::no_filecart;
}
mov_i.set_nomefilecart(file);
else
mov_i.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart);
}
copy_file_to_webapp_fld(mov_i);
}
}
ok &= !mov_i.err;
ok &= mov_i.no_err();
}
}
_head.stato_estr = ok ? D_GEST_OK : D_GEST_ERR;
@ -938,17 +1058,15 @@ bool TEstrazione::estrazione_iva(bool escluso)
if (!bar.add_status())
break;
if (!it->estratto)
if (!it->estratto())
continue;
TLocalisamfile mov(LF_MOV);
TLocalisamfile cli(LF_CLIFO);
mov.put(MOV_NUMREG, it->numreg);
mov.read();
cli.put(CLI_TIPOCF, mov.get(MOV_TIPO));
cli.put(CLI_CODCF, mov.get(MOV_CODCF));
cli.read();
const TRectype& mov = cache().get(LF_MOV, it->numreg());
TToken_string key = mov.get(MOV_TIPO);
key.add(mov.get(MOV_CODCF));
const TRectype& cli = cache().get(LF_CLIFO, key);
const char tipodoc = _head.tipo_doc;
const TString& name_registro = TRegistro(TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).reg()).name();
fill_id(cli, statopaiv, idfisc, paiv, codfis);
@ -963,7 +1081,7 @@ bool TEstrazione::estrazione_iva(bool escluso)
iva_query.add(IVA_ANNOES, mov.get_int(MOV_ANNOES));
iva_query.add(IVA_GIVA, tipodoc);
iva_query.add(IVA_TIPOG, name_registro, 10);
iva_query.add(IVA_DOCXML, it->cartaceo ? 'N' : 'S');
iva_query.add(IVA_DOCXML, it->cartaceo() ? 'N' : 'S');
iva_query.add(IVA_TIPOCF, mov.get_char(MOV_TIPO));
iva_query.add(IVA_CODCF, mov.get_long(MOV_CODCF));
@ -971,13 +1089,13 @@ bool TEstrazione::estrazione_iva(bool escluso)
iva_query.add(IVA_IDFISC, idfisc, 30);
iva_query.add(IVA_PIVA, paiv, 28);
iva_query.add(IVA_CODFIS, codfis, 16);
iva_query.add(IVA_CATDOC, it->catdoc->catdoc, 10);
iva_query.add(IVA_CAUSSOS, it->catdoc->caus_sost, 6);
iva_query.add(IVA_CATDOC, it->catdoc()->catdoc, 10);
iva_query.add(IVA_CAUSSOS, it->catdoc()->caus_sost, 6);
iva_query.add(IVA_NUMDOC, it->numdoc, 20);
iva_query.add(IVA_NUMDOC, it->numdoc(), 20);
iva_query.add(IVA_DATADOC, datadoc);
iva_query.add(IVA_SEZIVA, mov.get(MOV_REG), 10);
iva_query.add(IVA_TIPOREG, "", 6);
iva_query.add(IVA_TIPOREG, "", 6);
iva_query.add(IVA_NPROT, mov.get(MOV_PROTIVA), 20);
iva_query.add(IVA_DATPROT, datareg);
@ -989,15 +1107,16 @@ bool TEstrazione::estrazione_iva(bool escluso)
iva_query.add(IVA_DATAOR, TDate(20010101));
}*/
iva_query.add(IVA_CLASDOC, it->catdoc->class_sost, 10);
iva_query.add(IVA_NOMFD, it->nomefilecart.name(), 100);
iva_query.add(IVA_CLASDOC, it->catdoc()->class_sost, 10);
iva_query.add(IVA_NOMFD, it->nomefilecart().name(), 100);
// Load annessi...
if(!it->annessi.empty())
if(!it->annessi().empty())
{
vector<annesso_t>& ann = it->annessi;
vector<annesso_t>& ann = it->annessi();
size_t i = 0;
const size_t size = ann.size();
iva_query.add(IVA_CLASAN1, ann[i].catdocann, 10);
iva_query.add(IVA_NOMF1, ann[i++].filename, 100);
// HOW DID MY LIFE COME TO THIS?...
@ -1051,7 +1170,7 @@ bool TEstrazione::estrazione_iva(bool escluso)
iva_query.add(IVA_USERELA, user(), 10);
iva_query.add_getdate(IVA_TIMEELA);
if (_head.tipo_doc == 'A' && !it->cartaceo)
if (_head.tipo_doc == 'A' && !it->cartaceo())
{
TToken_string keys(mov.get(MOV_KEYFPPRO), ';');
fppro_db().set_keys(keys);
@ -1100,8 +1219,8 @@ void TEstrazione::set_dates()
{
if (_escluso)
{
set_dataini(_movs[0].datareg);
set_dataend(_movs[0].datareg);
set_dataini(_movs[0].datareg());
set_dataend(_movs[0].datareg());
}
}
@ -1121,13 +1240,12 @@ TEstrazione::TEstrazione(const TString& ambiente, const bool flag_prov, const ch
_head.addr_cart = addrcart;
_escluso = escluso;
_error_sql = make_unique<ofstream>();
_error_sql->open("f9_TEstrazione_error_sql.txt");
_error_sql = new ofstream("f9_TEstrazione_error_sql.txt");
// Svuoto log.
FILE* f = fopen("TF9Prospetto_integr_error.txt", "w");
fwrite("\n", sizeof(char), 1, f);
fclose(f);
ofstream f("TF9Prospetto_integr_error.txt");
f << "\n";
}
@ -1159,8 +1277,12 @@ void TF9_dberr::write_sqlerrlog(const TString& query) const
void TF9_dberr::add(const TString& string)
{
TString str;
add_str(str << "'" << string << "'");
TString str = string;
str.replace("'", "''");
str.insert("'");
str << "'";
add_str(str);
}
void TF9_dberr::add(const TDate& date)
@ -1212,7 +1334,7 @@ bool TF9_dberr::del_err(const TString& codsoc, const TString& id_estr, const int
return fp_db().sq_set_exec(query) && fp_db().sq_commit();
}
char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, vector<TToken_string>& controllo_mov)
char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, TArray& controllo_mov)
{
TString query;
query << "SELECT * FROM " F9_ERR
@ -1231,7 +1353,7 @@ char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, vector
row.add(fp_db().sq_get(i));
}
controllo_mov.insert(controllo_mov.end(), row);
controllo_mov.add(row);
}
query.cut(0) << "SELECT " DRD_TIPODOC " FROM " F9_DRD "\n" <<
"WHERE " DRD_CODSOC " = '" << codsoc << "' AND " DRD_ID_EST " = '" << id_estr << "'";
@ -1269,7 +1391,7 @@ TF9_dberr::TF9_dberr()
// TCategorie_doc
///////////////////////////////////////////////////////////////////////////////////////////
std::shared_ptr<TCategorie_doc::classe_doc> TCategorie_doc::find_causcont(const TString& caus) const
TCategorie_doc::classe_doc * TCategorie_doc::find_causcont(const TString& caus) const
{
for (auto it = _rows.begin(); it != _rows.end(); ++it)
{
@ -1279,18 +1401,18 @@ std::shared_ptr<TCategorie_doc::classe_doc> TCategorie_doc::find_causcont(const
return nullptr;
}
std::shared_ptr<TCategorie_doc::classe_doc> TCategorie_doc::find_tipodoc(const TString& tipodoc) const
TCategorie_doc::classe_doc * TCategorie_doc::find_tipodoc(const TString& tipodoc) const
{
for (auto it = _rows.begin(); it != _rows.end(); ++it)
{
const std::shared_ptr<classe_doc>& classe = *it;
const classe_doc* classe = *it; // qui
if (classe->causcont.blank() && classe->tipocaus == tipodoc)
return *it;
}
return nullptr;
}
std::shared_ptr<TCategorie_doc::classe_doc> TCategorie_doc::find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const
TCategorie_doc::classe_doc * TCategorie_doc::find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const
{
for (auto it = _rows.begin(); it != _rows.end(); ++it)
{
@ -1310,7 +1432,7 @@ std::vector<pair<TString, std::shared_ptr<TArray_sheet>>>::iterator TCategorie_d
return _sheets_annessi.end();
}
std::shared_ptr<TCategorie_doc::classe_doc> TCategorie_doc::get_classe_doc(const TString& catdoc)
TCategorie_doc::classe_doc* TCategorie_doc::get_classe_doc(const TString& catdoc)
{
for(auto it = _rows.begin(); it != _rows.end(); ++it)
{
@ -1328,12 +1450,14 @@ void TCategorie_doc::load_all()
while (true)
{
const TString& appo = ini_get_string(CONFIG_DITTA, INI_PAR_MOD, INI_CATDOC, "", idx++);
if (appo == "STOP" || appo.blank()) /* STOP: Riga terminatrice */
break;
TToken_string row(appo);
classe_doc cd = { row.get(1), row.get(), row.get(), row.get(), row.get(), row.get() };
_rows.emplace_back(std::make_shared<classe_doc>(cd));
TToken_string row(appo);
classe_doc * cd = new classe_doc{ row.get(1), row.get(), row.get(), row.get(), row.get(), row.get() };
_rows.emplace_back(cd);
}
idx = 0;
@ -1482,8 +1606,10 @@ void TCategorie_doc::add_categoria(const TString& catdoc, const TString& descr,
{
if(!(catdoc && *catdoc && class_sost && *class_sost && caus_sost && *caus_sost))
fatal_box("add_categoria failed: some parameters are NULL or keys are empty");
classe_doc cd = { catdoc, descr, class_sost, caus_sost, causcont, tipocaus };
_rows.emplace_back(std::make_shared<classe_doc>(cd));
classe_doc * cd = new classe_doc{ catdoc, descr, class_sost, caus_sost, causcont, tipocaus };
_rows.emplace_back(cd);
save_cat();
}
@ -1532,8 +1658,9 @@ TString_array TCategorie_doc::get_array_rows(const bool traduci)
TString_array sa(_rows.size());
for(auto it = _rows.begin(); it != _rows.end(); ++it)
{
const shared_ptr<classe_doc>& row = *it;
classe_doc *row = *it; // qui
TToken_string ts;
ts.add(row->catdoc);
ts.add(row->descr);
ts.add(!traduci ? row->class_sost : traduci_class_sost(row->class_sost));
@ -1607,20 +1734,17 @@ std::shared_ptr<TArray_sheet> TCategorie_doc::get_sheet_ann(const TString& catdo
return it->second;
}
std::shared_ptr<TCategorie_doc::classe_doc> TCategorie_doc::mov2cat(const int numreg)
TCategorie_doc::classe_doc * TCategorie_doc::mov2cat(const long numreg)
{
// Leggo la causale e cerco la corrispondente nelle categorie documentali, se c'e'.
// Guardo le colonne causale cont., tipodoc, class. cat. (opcee)
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg);
mov.read();
const TRectype & mov = cache().get(LF_MOV, numreg);
const TString& caus = mov.get(MOV_CODCAUS);
const TCausale c(caus, mov.get_date(MOV_DATAREG).year());
const TCausale & c = cached_causale(caus, mov.get_date(MOV_DATAREG).year());
const TString& tipodoc = c.tipo_doc();
// Cerco se ho un record che abbia specificata quella caus. contabile
std::shared_ptr<classe_doc> cat = find_causcont(caus);
classe_doc * cat = find_causcont(caus);
if (cat != nullptr)
return cat;
// Altrimenti cerco per tipo documento

8
src/f9/f9lib02.cpp
View File

@ -162,11 +162,11 @@ bool TF9_doccart::add_cart(const TFilename& file, const TString& numreg, const b
return true;
}
bool TF9_doccart::doc_already_exists(const TFilename& file, _Out_ TString& numreg, _Out_ bool& annesso)
bool TF9_doccart::doc_already_exists(const TFilename& file, TString& numreg, bool& annesso)
{
numreg = "";
annesso = false;
_tdocs.zero();
_tdocs.zero();
_tdocs.setkey(2);
_tdocs.put(F9C_FILENAME, file.name());
bool ok = _tdocs.read() == NOERR;
@ -593,7 +593,9 @@ bool TF9Prospetto_integr::operator()(const char* numreg_acq, const char* numreg_
_items = _prosp_rs->items();
if (_items == 0)
{
FILE* log = fopen("TF9Prospetto_integr_error.txt", "a");
FILE* log;
fopen_s(&log, "TF9Prospetto_integr_error.txt", "a");
if (!_prosp_rs->last_exec())
{
if (log != nullptr)