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 "f901tab.h"
#include "f90100b.h" #include "f90100b.h"
#include "f90100d.h" #include "f90100d.h"
#include "sqlset.h"
#include "../f1/f1lib.h"
#include "../fp/fplib.h"
#include "f90.h"
#include "f90100.h"
#include "f90100c.h" #include "f90100c.h"
/** \file f90100.cpp /** \file f90100.cpp
@ -31,20 +31,13 @@
// Utilities // 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() TMask& descr_msk()
{ {
static std::unique_ptr<TMask> m = nullptr; static TMask * m = nullptr;
if (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_button_tool(DLG_OK, "Conferma", TOOL_OK);
m->add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, ""); m->add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, "");
m->add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40); m->add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40);
@ -54,10 +47,10 @@ TMask& descr_msk()
TMask& esclusi_mask() TMask& esclusi_mask()
{ {
static unique_ptr<TMask> _esclusi_mask = nullptr; static TMask * _esclusi_mask = nullptr;
if (_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; TMask& m = *_esclusi_mask;
((TSheet_field&)m.field(S_ESCL)).set_notify(TF9_app::select_escl_notify); // Handler dello sheet per selezione singola ((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 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; 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 // 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() int TEstrai_mask::estrai()
{ {
@ -135,12 +75,12 @@ int TEstrai_mask::estrai()
const TDate dataend = get_dataend(); const TDate dataend = get_dataend();
const char tipodoc = get_tipodoc(); const char tipodoc = get_tipodoc();
const bool flagpro = is_provviso(); const bool flagpro = is_provviso();
TFilename path; TFilename path;
f9_app().get_spotlite_path(path);
f9_app().get_spotlite_path(path);
// Vero e proprio oggetto estrazione // Vero e proprio oggetto estrazione
_estrazione = make_unique<TEstrazione>( _estrazione = new TEstrazione(
F9CONF.get_ambiente(), // Codice ambiente F9CONF.get_ambiente(), // Codice ambiente
flagpro, // Flag prov. flagpro, // Flag prov.
tipodoc, // Tipo doc. tipodoc, // Tipo doc.
@ -167,49 +107,24 @@ int TEstrai_mask::estrai()
const TipoIVA tipo = tipodoc == 'A' ? iva_acquisti : iva_vendite; const TipoIVA tipo = tipodoc == 'A' ? iva_acquisti : iva_vendite;
int count = 0; int count = 0;
// Prendo tutti i movimenti a partire da una data e li carico tutti fino alla data finale // 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 for (bool ok = mov.move_first(); progr->add_status() && ok; ok = mov.move_next())
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()); TToken_string elab_f9(mov.get_string(MOV_ELABF9), ';'); // Stringa del campo elaborazione f9 nel file mov
const bool stampato = recset_get_bool(mov, MOV_REGST); 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 TRegistro& reg = caus.reg();
const TipoIVA& iva = reg.iva(); const TipoIVA& iva = reg.iva();
TString numdoc = recset_get_string(mov, MOV_NUMDOCEXT); TString numdoc = mov.get_string(MOV_NUMDOCEXT);
if(numdoc.empty())
numdoc = recset_get_string(mov, MOV_NUMDOC); if (numdoc.empty())
numdoc = mov.get_string(MOV_NUMDOC);
// Se definitivo controllo il flag di stampato REGST // Se definitivo controllo il flag di stampato REGST
if ((flagpro || stampato) && numdoc.full() && iva == tipo) 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 // Creo il movimento da inserire
movimento_t t; movimento_t t(mov, tipo, escluso);
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;
}
// Effettivo inserimento del movimento // Effettivo inserimento del movimento
_estrazione->add_mov(t); _estrazione->add_mov(t);
@ -396,8 +311,11 @@ void TMonitor_mask::controllo_errori() const
void TMonitor_mask::delete_estr_fld(const TString& idestr) 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; TFilename dir(F9CONF.get_addr_doc_loc());
experimental::filesystem::remove_all((const char*)dir);
dir << SLASH << F9CONF.get_ambiente() << SLASH << idestr << SLASH << "*";
remove_files(dir, true);
} }
void TMonitor_mask::delete_pack(const bool all) const 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) 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->set_from_row_estrazione(*row_estrazione);
_inclusi_mask->fill_estr(); _inclusi_mask->fill_estr();
@ -610,7 +528,7 @@ void TMonitor_mask::sel() const
TSheet_field& sf = sfield(S_ELAB); TSheet_field& sf = sfield(S_ELAB);
FOR_EACH_SHEET_ROW_LOOP(sf, nr) 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.set_row_cell(F_SEL, false, nr);
} }
sf.force_update(); sf.force_update();
@ -653,16 +571,11 @@ void TControllo_mask::associa() // todo: levare gli ultimi residui del vecchio
if (ok) if (ok)
{ {
// Tolgo il flag di in errore sul vettore in modo da rifare la fill e non venir piu' contato come da controllare // 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; int count = -1;
while (count < _selected_mov && it != _controllo_mov.end())
{ FOR_EACH_ARRAY_ROW(_controllo_mov, r, row)
if (it->get(0)[0] == 'X') // Devo saltare tutti quelli che non hanno il flag e contare solo quelli che ce l'hanno 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++; count++;
if (count < _selected_mov)
++it;
}
it->add(' ', 0);
TF9_dberr::del_err(_cod_soc, _id_estr, mov_sel->get_int(cid2index(F_CNUMREG))); 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) FOR_EACH_SHEET_ROW_LOOP(sf, row)
{ {
const long nreg = sf.get_long_row_cell(row, F_CNUMREG); const long nreg = sf.get_long_row_cell(row, F_CNUMREG);
TRectype & movs = (TRectype&)cache().get(LF_MOV, nreg); 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); const TDate today(TODAY);
TToken_string stato("", ';'); TToken_string stato("", ';');
@ -715,9 +627,9 @@ void TControllo_mask::conferma_esclusi() const
sf.show(); 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; TF9_dberr dberr;
_tipo_doc_err = TF9_dberr::get_errori(_cod_soc, _id_estr, _controllo_mov); _tipo_doc_err = TF9_dberr::get_errori(_cod_soc, _id_estr, _controllo_mov);
return _controllo_mov; return _controllo_mov;
@ -726,24 +638,22 @@ vector<TToken_string>& TControllo_mask::import_error_list()
void TControllo_mask::fill() void TControllo_mask::fill()
{ {
TSheet_field& sf = sfield(S_CONTROLLO); TSheet_field& sf = sfield(S_CONTROLLO);
sf.hide();
sf.destroy(); sf.reset();
if (!_is_escluso) if (!_is_escluso)
import_error_list(); import_error_list();
else else
_controllo_mov = f9_app()._esclusi; _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); TToken_string& sfrow = sf.row(-1);
if (*it->get(0) == 'X') if (row->get_bool(0))
{ {
row = *it; sfrow = *row;
row[0] = (char&)" "; sf.set_row_cell(101, false, r);
} }
} }
sf.force_update(); sf.force_update();
sf.show();
// Fill fppro sheet // Fill fppro sheet
if (!_is_escluso && _tipo_doc_err == 'A' || _is_escluso && f9_app().get_tipoiva_escl() == iva_acquisti) if (!_is_escluso && _tipo_doc_err == 'A' || _is_escluso && f9_app().get_tipoiva_escl() == iva_acquisti)
fill_fppro_sheet(); 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()) 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_FDATA, fp_db().sq_get_date("DATA"), row);
sf.set_row_cell(F_FNUMDOC, fp_db().sq_get("NUMDOC"), row); sf.set_row_cell(F_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 void TControllo_mask::selfatt(TOperable_field& o, const long jolly) const
{ {
const TMask& mask = *this;
TSheet_field* sf; TSheet_field& sf = sfield(jolly == 1 ? S_CONTROLLO : S_FPPRO); // Sheet controllo o fppro
if (jolly == 1) // Sheet controllo const int id = jolly == 1 ? F_CSEL : F_FSEL;
sf = &mask.sfield(S_CONTROLLO);
else FOR_EACH_SHEET_ROW_LOOP(sf, row)
sf = &mask.sfield(S_FPPRO);
sf->hide();
FOR_EACH_SHEET_ROW(*sf, nr, row)
{ {
if (*row->get(0) == 'X') if (sf.get_bool_row_cell(row, id))
row->add("", 0); sf.set_row_cell(id, false, row);
} }
sf->force_update(); sf.force_update();
sf->show();
} }
bool TControllo_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) 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; _controllo_mov = f9_app()._esclusi;
_datada = EOTIME; _datada = EOTIME;
_dataa = 0L; _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) if (d < _datada)
_datada = d; _datada = d;
if (d > _dataa) if (d > _dataa)
@ -1099,52 +1006,60 @@ void TApri_estr_msk::fill_estr() const
"FROM " F9_IVA "\n" "FROM " F9_IVA "\n"
"WHERE " IVA_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " IVA_IDLAN " = '" << _idestr << "'"; "WHERE " IVA_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " IVA_IDLAN " = '" << _idestr << "'";
// REG + DATAREG + PROTIVA + DATAINC + DATA74TER + NUMREG // REG + DATAREG + PROTIVA + DATAINC + DATA74TER + NUMREG
TString sql;
TSQL_recordset rec(""); TSQL_recordset rec("");
fp_db().sq_set_exec(query, false); fp_db().sq_set_exec(query, false);
TSheet_field& sf = sfield(S_ESCL); TSheet_field& sf = sfield(S_ESCL);
sf.hide();
sf.destroy(); sf.reset();
TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione..."); TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione...");
for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next()) for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next())
{ {
if (!prog.add_status()) if (!prog.add_status())
break; 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" "FROM MOV\n"
"WHERE REG = '" << fp_db().sq_get(IVA_SEZIVA) << "' AND DATADOC='" << TDate(fp_db().sq_get_date(IVA_DATADOC)).date2ansi() << "'" "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) << "'"; " AND PROTIVA = '" << fp_db().sq_get(IVA_NPROT) << "'";
rec.set(sql); rec.set(sql);
rec.move_first(); rec.move_first();
TToken_string& r = sf.row(-1);
r.add(" ", 0); const int row = sf.set_row_cell(FI_NUMREG, rec.get(0).as_string()); // Numreg
r.add(rec.get(0).as_string()); // Numreg
r.add(rec.get(1).as_string()); // Data reg sf.set_row_cell(FI_DATAREG, rec.get(1).as_date(), row); // Data reg
r.add(rec.get(2).as_string()); // Data doc sf.set_row_cell(FI_DATADOC, rec.get(2).as_string(), row); // Data doc
TString codcaus; codcaus << rec.get(3).as_string(); TString codcaus;
const int len = codcaus.len();
for (int i = 0; i < 3 - len; ++i) codcaus << rec.get(3).as_string();
codcaus.add_front("0"); codcaus.lpad(3, '0');
r.add(codcaus); // Cod caus sf.set_row_cell(FI_CODCAUS, codcaus, row); // Cod caus
r.add(rec.get(4).as_string()); // Tipo doc sf.set_row_cell(FI_TIPOMOV, rec.get(4).as_string(), row); // Tipo doc
r.add(rec.get(5).as_string()); // Mese liq sf.set_row_cell(FI_MESELIQ, rec.get(5).as_string(), row); // Mese liq
r.add(rec.get(6).as_string()); // Num doc sf.set_row_cell(FI_NUMDOC, rec.get(6).as_string(), row); // Num doc
r.add(rec.get(7).as_string()); // Tot doc sf.set_row_cell(FI_IMPTOTDOC, rec.get(7).as_string(), row); // Tot doc
r.add(rec.get(8).as_string()); // Clifo sf.set_row_cell(FI_FORN, rec.get(8).as_string(), row); // Clifo
TLocalisamfile clifo(LF_CLIFO);
clifo.put(CLI_CODCF, rec.get(8).as_string()); TToken_string key(_tipodoc == 'A' ? "F" : "C");
clifo.put(CLI_TIPOCF, _tipodoc == 'A' ? "F" : "C");
clifo.read(); key.add(rec.get(8).as_string());
r.add(clifo.get(CLI_RAGSOC)); // Rag soc
r.add(TString(rec.get(9).as_string()) << "/" << rec.get(10).as_string()); // Prot iva const TRectype& clifo = cache().get(LF_CLIFO, key);
r.add(rec.get(11).as_string()); // Descr
r.add(""); // Flag escludi sf.set_row_cell(FI_RAGSOC, clifo.get(CLI_RAGSOC), row); // Rag soc
r.add(TToken_string(rec.get(12).as_string(), ';').get_bool(2)); // Escluso
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.force_update();
sf.show();
} }
void TApri_estr_msk::fill_res() const 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); fp_db().sq_set_exec(query, false);
TSheet_field& sf = sfield(S_RES); TSheet_field& sf = sfield(S_RES);
sf.destroy();
TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione..."); 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()) const TRectype & mov = cache().get(LF_MOV, fp_db().sq_get(MES_NUMREG));
break; const int row = sf.set_row_cell(F_RSEL, fp_db().sq_get_int(MES_ESTR) ? "X" : " "); // Estratto
TLocalisamfile mov(LF_MOV); sf.set_row_cell(F_RNUMREG, mov.get(MOV_NUMREG), row); // Numreg
mov.put(MOV_NUMREG, fp_db().sq_get(MES_NUMREG)); sf.set_row_cell(F_RDATAREG, mov.get_date(MOV_DATAREG), row); // Data reg
mov.read(); sf.set_row_cell(F_RDATADOC, mov.get_date(MOV_DATADOC), row); // Data doc
TToken_string& r = sf.row(-1); sf.set_row_cell(F_RCODCAUS, mov.get(MOV_CODCAUS), row); // Cod caus
r.add(fp_db().sq_get_int(MES_ESTR) ? "X" : " ", 0); // Estratto sf.set_row_cell(F_RTIPOMOV, mov.get(MOV_TIPODOC), row); // Tipo doc
r.add(mov.get(MOV_NUMREG)); // Numreg sf.set_row_cell(F_RMESELIQ, mov.get_int(MOV_MESELIQ), row); // Mese liq
r.add(mov.get_date(MOV_DATAREG)); // Data reg sf.set_row_cell(F_RNUMDOC, mov.get(MOV_NUMDOC), row); // Num doc
r.add(mov.get_date(MOV_DATADOC)); // Data doc sf.set_row_cell(F_RIMPTOTDOC, mov.get_real(MOV_TOTDOC), row); // Tot doc
r.add(mov.get(MOV_CODCAUS)); // Cod caus sf.set_row_cell(F_RFORN, mov.get_int(MOV_CODCF), row); // Clifo
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
TLocalisamfile clifo(LF_CLIFO); TToken_string key(mov.get(MOV_TIPO));
clifo.put(CLI_CODCF, mov.get(MOV_CODCF));
clifo.put(CLI_TIPOCF, mov.get(MOV_TIPO));
clifo.read();
r.add(clifo.get(CLI_RAGSOC)); // Rag soc key.add(mov.get(MOV_CODCF));
r.add(TString(mov.get(MOV_REG)) << "/" << mov.get(MOV_PROTIVA)); // Prot iva
r.add(mov.get(MOV_DESCR)); // Descr const TRectype & clifo = cache().get(LF_CLIFO, key);
r.add(fp_db().sq_get(MES_ERR)); // Descrizione errore
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) 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) 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.set_row_cell(FE_SEL, false, nr);
} }
sf.force_update(); sf.force_update();
@ -1339,7 +1256,7 @@ void TF9_app::open_esclusi()
/* Caricamento esclusi /* Caricamento esclusi
* LOADING DI QUEL MESE E ANNO */ * 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 anno = ym_msk->get_int(501);
const int mese = ym_msk->get_int(502); const int mese = ym_msk->get_int(502);
const int to_m = ym_msk->get_int(503); 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(clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : "");
m.add(TString(movs.get(MOV_REG)) << "/" << movs.get(MOV_PROTIVA)); m.add(TString(movs.get(MOV_REG)) << "/" << movs.get(MOV_PROTIVA));
m.add(movs.get(MOV_DESCR)); 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() 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); TSheet_field& sf = esclusi_mask().sfield(S_ESCL);
sf.destroy(); sf.destroy();
for (auto it = esclusi.begin(); it != esclusi.end(); ++it) FOR_EACH_ARRAY_ROW(esclusi, r, row)
sf.row(-1) = *it; sf.row(-1) = *row;
sf.force_update(); 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) bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
{ {
TMask& msk = esclusi_mask(); TMask descr_mask("Estrazione", 1, 60, 5);
TF9_app& a = f9_app();
vector<TToken_string>& _esclusi = a._esclusi_vect;
TSheet_field& sf = msk.sfield(S_ESCL);
descr_msk().run(); descr_mask.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
const TString descr = descr_msk().get(DES_TEXT); descr_mask.add_button_tool(DLG_CANCEL, "Annulla", TOOL_CANCEL);
descr_msk().set(DES_TEXT, ""); 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);
f9_app().get_spotlite_path(path); f9_app()._estr_escluso =new TEstrazione(F9CONF.get_ambiente(), f9_app()._flagprov_escl,
a._estr_escluso = f9_app()._tipodoc_escl, descr,
new TEstrazione(F9CONF.get_ambiente(), a._flagprov_escl, a._tipodoc_escl, descr, F9CONF.get_addr_doc(), true, path); F9CONF.get_addr_doc(), true, path);
// Prendo la riga selezionata (e controllo che sia selezionato qualcosa) // Prendo la riga selezionata (e controllo che sia selezionato qualcosa)
bool flag = false; bool flag = false;
FOR_EACH_SHEET_ROW(sf, nr, row) FOR_EACH_SHEET_ROW_LOOP(sf, row)
{ {
if (row->get(0)[0] == 'X') if (sf.get_bool_row_cell(row, FE_SEL))
{ {
const movimento_t mov = escl2mov(row); const movimento_t mov = f9_app().escl2mov(sf, row);
a._estr_escluso->add_mov(mov); f9_app()._estr_escluso->add_mov(mov);
_stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
const int stato = a._estr_escluso->estrai(); const int stato = f9_app()._estr_escluso->estrai();
if (stato == 1) if (stato == 1)
{ {
_esclusi.erase(_esclusi.begin() + nr); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov _esclusi.destroy(row); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov
a.segna_estratti(true, mov.numreg); f9_app().segna_estratti(true, mov.numreg());
} }
flag = true; flag = true;
break; break;
} }
} }
if (!flag) if (!flag)
message_box("Selezionare il movimento da estrarre"); message_box("Selezionare il movimento da estrarre");
else else
a.print_log(); f9_app().print_log();
fill_esclusi(); fill_esclusi();
}
return true; return true;
} }
@ -1505,35 +1405,26 @@ void TF9_app::print_log()
bool TF9_app::is_autofattura(const TLocalisamfile& mov) 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 TF9_app::segna_estratti(const bool escluso, const int numreg)
{ {
bool ok = true; bool ok = true;
TArray escl; // <movimento_t>
vector<movimento_t> escl;
if (escluso) if (escluso)
{ escl.add(movimento_t(numreg)); // todo: datareg?
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;
TLocalisamfile mov(LF_MOV); TArray& movs_v = escluso ? escl : _movs;
TToken_string elab("", ';'); TToken_string elab("X", ';'); // "[flag estratto];
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) 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; const movimento_t & t = (movimento_t &) *obj;
mov.zero(); TRectype& mov = (TRectype&) cache().get(LF_MOV, t.numreg());
mov.put(MOV_NUMREG, num_reg);
mov.read();
mov.put(MOV_ELABF9, elab); mov.put(MOV_ELABF9, elab);
ok &= mov.rewrite() == NOERR; ok &= mov.rewrite() == NOERR;
} }

35
src/f9/f90100.h
View File

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

200
src/f9/f9lib.h
View File

@ -21,6 +21,7 @@
// Controlla eventuali apostrofi e li raddoppia // Controlla eventuali apostrofi e li raddoppia
const char* check_str(const TString& str); const char* check_str(const TString& str);
const TString & get_numdoc_exp_fp(int numreg);
struct annesso_t struct annesso_t
{ {
@ -150,15 +151,15 @@ public:
bool obblig{ false }; // Definisce se deve essere per forza presente l'annesso. bool obblig{ false }; // Definisce se deve essere per forza presente l'annesso.
}; };
private: 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::vector<std::pair<TString, std::shared_ptr<TArray_sheet>>> _sheets_annessi;
std::shared_ptr<TArray_sheet> _sheet_catdocs; std::shared_ptr<TArray_sheet> _sheet_catdocs;
std::shared_ptr<std::set<TString>> _name_catdocs; std::shared_ptr<std::set<TString>> _name_catdocs;
int _mode_sheet; int _mode_sheet;
std::shared_ptr<TCategorie_doc::classe_doc> find_causcont(const TString& caus) const ; // OK 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 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_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 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); 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_ann(const TString& catdoc);
TString_array get_array_rows(bool traduci = false); 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::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_catdocs();
std::shared_ptr<TArray_sheet> get_sheet_ann(const TString& catdoc); std::shared_ptr<TArray_sheet> get_sheet_ann(const TString& catdoc);
std::shared_ptr<classe_doc> mov2cat(int numreg); classe_doc * mov2cat(const long 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 ""; } 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(); void reload();
static void remove_all(); static void remove_all();
static void remove_all_ann(); static void remove_all_ann();
@ -227,111 +228,93 @@ public:
TRecord_categorie(type table = catdocs); TRecord_categorie(type table = catdocs);
}; };
struct movimento_t enum err_mov
{ {
enum err_mov mov_no_error, // Estratto normalmente.
{ mov_escluso, // Movimento con flag escluso.
no_err, // Estratto normalmente. mov_no_catdoc, // Nessuna cat. doc. riconosciuta per questo movimento, o non e' una fattura.
escluso, // Movimento con flag escluso. mov_no_doc, // Il mov. di vendita non ha un documento generatore.
no_catdoc, // Nessuna cat. doc. riconosciuta per questo movimento, o non e' una fattura. mov_notfound_elet, // Non trovata fatt. elettronica mov vendita.
no_doc, // Il mov. di vendita non ha un documento generatore. mov_no_fa, // Movimento di acquisto non e' una fattura.
notfound_elet, // Non trovata fatt. elettronica mov vendita. mov_no_fv, // Movimento di vendita non e' una fattura.
no_fa, // Movimento di acquisto non e' una fattura. mov_no_cartaceo, // Movimento cartaceo che non ha bisogno di essere estratto.
no_fv, // Movimento di vendita non e' una fattura. mov_pura_iva, // Movimento di sola IVA (integrazione Rev. Charge)
no_cartaceo, // Movimento cartaceo che non ha bisogno di essere estratto. mov_no_filecart, // Il documento cartaceo non ha associato un file, o questo non e' stato trovato.
pura_iva, // Movimento di sola IVA (integrazione Rev. Charge) mov_annesso_nexist // Un annesso obbligatorio e' mancante.
no_filecart, // Il documento cartaceo non ha associato un file, o questo non e' stato trovato. };
annesso_nexist // Un annesso obbligatorio e' mancante.
};
bool err{ false }; class movimento_t : public TObject // aggiungere metodi per TArray
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{};
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 bool _err;
{ long _numreg;
return err_mov2name(descr_estr); 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 public:
{ static const char* err_mov2name(const err_mov descr_estr);
TString a; const char* get_descr_estr() const { return err_mov2name(_descr_estr); }
switch (i) bool err() const { return _err; }
{ bool no_err() const { return !err(); }
case 0: return err; long numreg() const { return _numreg; }
case 1: return a << numreg; const TDate & datareg() const { return _datareg; }
case 2: return (const char*)datareg; const TDate & datadoc() const { return _datadoc; }
case 3: return (const char*)datadoc; const TString & codcaus() const { return _codcaus; }
case 4: return codcaus; int meseliq() const { return _meseliq; }
case 5: return a << meseliq; const TString & numdoc() const { return _numdoc; }
case 6: return numdoc; real totale() const { return _tot; }
case 7: long codcf() const { return _codcf; }
a << tot; const TString & ragsoc() const { return _ragsoc; }
if (a == "0") const TString & protiva() const { return _reg_protiva; }
a << ".0"; const TString & descr() const { return _descr; }
return a; state_fppro state() const { return _state; }
case 8: return a << codcf; const TString & descr_err() const { return _descr_err; }
case 9: return ragsoc; bool estratto() const { return _estratto; }
case 10: return reg_protiva; err_mov descr_estr() const { return _descr_estr; }
case 11: return descr; TCategorie_doc::classe_doc* catdoc() const { return _catdoc; }
case 14: return descr_err; vector<annesso_t> annessi() const { return _annessi; }
default: return ""; 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 class TEstrazione : public TObject
{ {
drd _head; drd _head;
vector<movimento_t> _movs; vector<movimento_t> _movs;
unique_ptr<ofstream> _error_sql; ofstream * _error_sql;
bool _escluso; bool _escluso;
const TString _descr; const TString _descr;
bool _has_cartacei; bool _has_cartacei;
@ -360,9 +343,9 @@ class TEstrazione : public TObject
static state_fppro check_fppro(int numreg); static state_fppro check_fppro(int numreg);
bool check_periodo_def() const; bool check_periodo_def() const;
void copy_file_to_webapp_fld(const movimento_t& movimento) 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; } 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 find_movcoll(int numreg, _Out_ TString& numreg_rev_vend);
static bool load_annessi(movimento_t& movimento); 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. // 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(). * genera il progressivo seguente. Chiamata da \a estrai() e \a estrai_single().
* \return Nuovo id estrazione. */ * \return Nuovo id estrazione. */
TString next_estr_today(char tipo) const; 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; void write_errorsql_log(const TString& query) const;
static TCategorie_doc& categorie_doc(bool reload = false); 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, 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); 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"); } void add() { add_str("NULL"); }
bool send(); bool send();
static bool del_err(const TString& codsoc, const TString& id_estr, int numreg); 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(); TF9_dberr();
}; };
@ -489,10 +473,10 @@ class TF9_doccart
public: public:
static bool add_cart(const TFilename& file, const TString& numreg, bool is_annesso = false, static bool add_cart(const TFilename& file, const TString& numreg, bool is_annesso = false,
const TString& catannpadre = "", const TString& catdocann = "", bool suppress_errors = true); const TString& catannpadre = "", const TString& catdocann = "", bool suppress_errors = true);
bool doc_already_exists(const TFilename& file, _Out_ TString& numreg, _Out_ bool& annesso); bool doc_already_exists(const TFilename& file, TString& numreg, bool& annesso);
bool mov2doc(const TString& numreg, _Out_ TFilename& doc); bool mov2doc(const TString& numreg, TFilename& doc);
bool mov2listann(const TString& numreg, _Out_ TString_array& list_annessi); bool mov2listann(const TString& numreg, TString_array& list_annessi);
bool mov2listann_vect(const TString& numreg, _Out_ vector<annesso_t>& list_annessi); bool mov2listann_vect(const TString& numreg, vector<annesso_t>& list_annessi);
static TString get_full_path_file_cartaceo(const TString& filename) 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 "f9lib.h"
#include <dongle.h>
#include <execp.h>
#include "../f1/f1lib.h" #include "../f1/f1lib.h"
#include "f901tab.h" #include "f901tab.h"
#include "progind.h" #include "progind.h"
@ -10,13 +11,147 @@
#include "mov.h" #include "mov.h"
#include "../fp/fplib.h" #include "../fp/fplib.h"
#include "annessif9.h" #include "annessif9.h"
#include "dongle.h" #include "f90100c.h"
#include "execp.h"
#define MODE_SHEETS 0xC #define MODE_SHEETS 0xC
statistics _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 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 // 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) void TEstrazione::check_annessi(movimento_t& mov_i, const int numreg)
{ {
TToken_string ann_nexist; 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: "); TString msg_annessi_mancanti("Annessi obligatori mancanti: ");
for (int i = 0; i < ann_nexist.items(); ++i) for (int i = 0; i < ann_nexist.items(); ++i)
msg_annessi_mancanti << ann_nexist.get() << " "; msg_annessi_mancanti << ann_nexist.get() << " ";
mov_i.err = true;
mov_i.estratto = false; mov_i.set_err(msg_annessi_mancanti);
mov_i.descr_err = msg_annessi_mancanti;
mov_i.descr_estr = movimento_t::annesso_nexist;
} }
else else
{ {
@ -102,7 +236,7 @@ bool TEstrazione::check_cartaceo_acq(const movimento_t& movimento)
{ {
TF9_doccart filecart; TF9_doccart filecart;
TFilename file; TFilename file;
TString reg; reg << movimento.numreg; TString reg; reg << movimento.numreg();
return filecart.mov2doc(reg, file) && file.exist(); 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 categorie;
TToken_string files; TToken_string files;
if(movimento.cartaceo && movimento.catdoc != nullptr) if(movimento.cartaceo() && movimento.catdoc() != nullptr)
{ {
categorie.add(movimento.catdoc->catdoc, 0); categorie.add(movimento.catdoc()->catdoc, 0);
files.add(movimento.nomefilecart, 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); categorie.add(it->catdocann);
files.add(TF9_doccart::get_full_path_file_cartaceo(it->filename)); 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); idfisc.cut(0);
statopaiv = clifo.get(CLI_STATOPAIV); 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); TToken_string key(mov.get(MOV_TIPO));
const TString& codcf = mov.get(MOV_CODCF);
TLocalisamfile clifo(LF_CLIFO); key.add(mov.get(MOV_CODCF));
clifo.put(CLI_TIPOCF, tipocf);
clifo.put(CLI_CODCF, codcf); const TRectype & clifo= cache().get(LF_CLIFO, key);
clifo.read();
const TString& statopaiv = clifo.get(CLI_STATOPAIV); 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) 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) bool TEstrazione::load_annessi(movimento_t& movimento)
{ {
TF9_doccart doccart; TF9_doccart doccart;
TString numreg; numreg << movimento.numreg; TString numreg; numreg << movimento.numreg();
return doccart.mov2listann_vect(numreg, movimento.annessi);
return doccart.mov2listann_vect(numreg, movimento.annessi());
} }
bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file) 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; 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. // 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); TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, movimento.numreg); mov.put(MOV_NUMREG, movimento.numreg());
if (mov.read() == NOERR && if (mov.read() == NOERR &&
!mov.get(MOV_DPROVV).empty() && !mov.get(MOV_DANNO).empty() && !mov.get(MOV_DCODNUM).empty() && !mov.get(MOV_DNDOC).empty()) !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; file.cut(0) << pdf;
TString numreg; numreg << movimento.numreg; TString numreg; numreg << movimento.numreg();
// Controllo anche se false perche' potrebbe esistere gia'. // Controllo anche se false perche' potrebbe esistere gia'.
if(!TF9_doccart::add_cart(file, numreg)) 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 bool TEstrazione::grab_pdf_from_spotlite(const movimento_t& movimento, TFilename& file) const
{ {
TLocalisamfile mov(LF_MOV); TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, movimento.numreg);
mov.put(MOV_NUMREG, movimento.numreg());
if (mov.read() == NOERR && if (mov.read() == NOERR &&
!mov.get(MOV_DPROVV).empty() && !mov.get(MOV_DANNO).empty() && !mov.get(MOV_DCODNUM).empty() && !mov.get(MOV_DNDOC).empty()) !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; break;
query.cut(0) << "INSERT INTO " F9_MOVESTR " (" MES_CODSOC ", IDESTR, NUMREG, DATAREG, ESTRATTO, DESCR_ERR)\nVALUES " << 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() << "', " << " ('" << _head.cod_soc << "', '" << _head.id_estr << "', '" << it->numreg() << "', '" << it->datareg().date2ansi() << "', " <<
(it->estratto ? "1" : "0") << ", '" << check_str(it->get_descr_estr()) << "')"; (it->estratto() ? "1" : "0") << ", '" << check_str(it->get_descr_estr()) << "')";
ok &= fp_db().sq_set_exec(query) && fp_db().sq_commit(); ok &= fp_db().sq_set_exec(query) && fp_db().sq_commit();
if (!ok) if (!ok)
{ {
@ -499,24 +635,22 @@ bool TEstrazione::export_error_list() const
if (!pg.add_status()) if (!pg.add_status())
break; break;
if (it->err) if (it->err())
{ {
dberr.add(_head.cod_soc); dberr.add(_head.cod_soc);
dberr.add(_head.id_estr); dberr.add(_head.id_estr);
for (int i = 1; i < 15; i++) dberr.add(it->numreg());
{ dberr.add(it->datareg());
TString string(it->get(i)); dberr.add(it->datadoc());
dberr.add(it->codcaus());
if (i == 2 || i == 3) // Sono obbligato a far cosi' per aggiungere le date dberr.add(it->meseliq());
dberr.add(TDate(it->get(i))); dberr.add(it->numdoc());
else if (string.full()) dberr.add(it->totale().stringa());
{ dberr.add(it->codcf());
string.replace("'", "''"); dberr.add(it->ragsoc());
dberr.add(string); dberr.add(it->protiva());
} dberr.add(it->descr());
else dberr.add(it->descr_err());
dberr.add(); // Se vuoto metto NULL
}
if (!(ok &= dberr.send())) if (!(ok &= dberr.send()))
break; break;
++count; ++count;
@ -554,7 +688,7 @@ TString TEstrazione::next_estr_today(char tipo) const
return TString(estr); 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()) if (TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).soloiva())
return true; return true;
@ -631,16 +765,16 @@ const char* TEstrazione::diagnostica_mov()
movimento_t& mov_i = *it; movimento_t& mov_i = *it;
// Se gia' escluso passo avanti // 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; continue;
if (!mov_i.err && mov_i.estratto) if (mov_i.no_err() && mov_i.estratto())
{ {
const int numreg = mov_i.numreg; const long numreg = mov_i.numreg();
TLocalisamfile mov(LF_MOV); const TRectype & mov =cache().get(LF_MOV, numreg);
mov.put(MOV_NUMREG, numreg);
mov.read(); mov_i.set_cartaceo(!is_doc_xml(mov));
mov_i.cartaceo = !is_doc_xml(mov);
const state_fppro res = check_fppro(numreg); const state_fppro res = check_fppro(numreg);
switch (res) switch (res)
{ {
@ -649,32 +783,27 @@ const char* TEstrazione::diagnostica_mov()
ok &= fppro_db().associa_mov(numreg); ok &= fppro_db().associa_mov(numreg);
case correct: case correct:
ok &= true; ok &= true;
mov_i.err = false; mov_i.reset_err();
mov_i.numdoc = fppro_db().get_numdoc(); mov_i.set_numdoc(fppro_db().get_numdoc());
break; break;
// ERRORS // ERRORS
// Errore non bloccante (skip) // Errore non bloccante (skip)
case not_fa: case not_fa:
ok &= true; ok &= true;
mov_i.err = false; mov_i.set_err("", mov_no_fa);
mov_i.estratto = false; mov_i.set_estratto(false);
mov_i.descr_estr = movimento_t::no_fa;
++_stats.fa_skip; ++_stats.fa_skip;
break; break;
// ERRORI BLOCCANTI // ERRORI BLOCCANTI
case reg_with_err: case reg_with_err:
ok &= false; ok &= false;
mov_i.err = true; mov_i.set_err("Errore controllo movimento: associazione movimento con fattura elettronica passiva sbagliato.");
mov_i.estratto = false;
mov_i.descr_err = "Errore controllo movimento: associazione movimento con fattura elettronica passiva sbagliato.";
break; break;
case err_read_db: case err_read_db:
ok &= false; ok &= false;
mov_i.err = true; mov_i.set_err("Errore controllo movimento: errore lettura db.");
mov_i.estratto = false;
mov_i.descr_err = "Errore controllo movimento: errore lettura db.";
break; break;
case no_guessed: case no_guessed:
// Controllo se esiste il cartaceo es. forfettari => la considero cartacea. // 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)) if(check_cartaceo_acq(mov_i))
{ {
ok &= true; ok &= true;
mov_i.err = false; mov_i.set_err("");
mov_i.cartaceo = true; mov_i.set_cartaceo(true);
mov_i.estratto = true; mov_i.set_state(correct);
mov_i.descr_err = "";
mov_i.state = correct;
} }
else else
{ {
ok &= false; ok &= false;
mov_i.err = true; mov_i.set_err("Non associato a fattura elettr. abbinamento automatico non riuscito. Abbinare manualmente, o escludere");
mov_i.estratto = false;
mov_i.descr_err = "Non associato a fattura elettr. abbinamento automatico non riuscito. Abbinare manualmente, o escludere";
} }
default: break; default: break;
} }
if(mov_i.state == null_state) if(mov_i.state() == null_state)
mov_i.state = res; 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 /* Per quelli che hanno passato il primo controllo errori controllo che debba essere estratto
* secondo le categorie documentali. */ * 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 // Cerco la categoria documentale
std::shared_ptr<TCategorie_doc::classe_doc> cd = categorie_doc().mov2cat(mov_i.numreg); TCategorie_doc::classe_doc * cd = categorie_doc().mov2cat(mov_i.numreg());
mov_i.estratto = cd.get(); const bool found = cd != nullptr;
mov_i.descr_estr = cd ? movimento_t::no_err : movimento_t::no_catdoc;
mov_i.catdoc = cd;
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); check_annessi(mov_i, numreg);
} }
// Se cartaceo preparo il file. // Se cartaceo preparo il file.
if (F9CONF.get_has_cartexp()) // Se e' abilitata l'esportazione dei cartacei, altrimenti skip... 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; TF9_doccart filecart;
TFilename file; TFilename file;
TString reg; reg << it->numreg; TString reg; reg << it->numreg();
if (filecart.mov2doc(reg, file) && file.exist()) if (filecart.mov2doc(reg, file) && file.exist())
mov_i.nomefilecart << file; mov_i.set_nomefilecart(file);
else else
{ mov_i.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart);
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;
}
} }
else else
{ {
ok &= true; ok &= true;
mov_i.err = false; mov_i.set_err("", mov_no_cartaceo);
mov_i.estratto = false; mov_i.set_estratto(false);
mov_i.descr_estr = movimento_t::no_cartaceo; // Cartaceo che non ha bisogno di essere estratto.
++_stats.fa_skip; ++_stats.fa_skip;
} }
} }
copy_file_to_webapp_fld(mov_i); copy_file_to_webapp_fld(mov_i);
} }
} }
ok &= !mov_i.err; ok &= mov_i.no_err();
} }
} }
else if (tipo == iva_vendite) else if (tipo == iva_vendite)
@ -763,34 +886,35 @@ const char* TEstrazione::diagnostica_mov()
movimento_t& mov_i = *it; movimento_t& mov_i = *it;
// Se escluso passo avanti // 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; continue;
TString numreg; numreg << mov_i.numreg; const long numreg = mov_i.numreg();
TLocalisamfile mov(LF_MOV); const TRectype & mov = cache().get(LF_MOV, numreg);
mov.put(MOV_NUMREG, numreg);
mov.read();
/* Controlli per vendite cambiati: /* Controlli per vendite cambiati:
* Elettroniche solo quelle agli italiani, tutti gli altri sono cartacei * 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; unsigned short skip = 0;
if (!_has_cartacei && mov_i.cartaceo) skip |= 0x1;
else if (pura_iva(mov)) skip |= 0x2; if (!_has_cartacei && mov_i.cartaceo()) skip |= 0x1;
else if (mov_i.datadoc.empty() || mov_i.numdoc.empty()) skip |= 0x4; else
if (pura_iva(mov)) skip |= 0x2;
else if (mov_i.datadoc().empty() || mov_i.numdoc().empty()) skip |= 0x4;
if(skip) if(skip)
{ {
++_stats.fv_cart_skip; ++_stats.fv_cart_skip;
mov_i.err = false; mov_i.reset_err();
mov_i.estratto = false; mov_i.set_estratto(false);
switch(skip) switch(skip)
{ {
case 0x1: mov_i.descr_estr = movimento_t::no_cartaceo; break; case 0x1: mov_i.set_descr_estr(mov_no_cartaceo); break;
case 0x2: mov_i.descr_estr = movimento_t::pura_iva; break; case 0x2: mov_i.set_descr_estr(mov_pura_iva); break;
case 0x4: mov_i.descr_estr = movimento_t::no_fv; case 0x4: mov_i.set_descr_estr(mov_no_fv); break;
default: break; default: break;
} }
} }
@ -805,46 +929,42 @@ const char* TEstrazione::diagnostica_mov()
}*/ }*/
else else
{ {
std::shared_ptr<TCategorie_doc::classe_doc> cd = categorie_doc().mov2cat(mov_i.numreg); TCategorie_doc::classe_doc* cd = categorie_doc().mov2cat(mov_i.numreg());
mov_i.err = false; const bool found = cd != nullptr;
mov_i.estratto = cd.get();
mov_i.descr_estr = cd ? movimento_t::no_err : movimento_t::no_catdoc; if (found)
mov_i.catdoc = cd; 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) if (!mov_i.catdoc())
check_annessi(mov_i, mov_i.numreg);
if (!mov_i.catdoc)
++_stats.fv_nocatdoc; ++_stats.fv_nocatdoc;
if (mov_i.err) if (mov_i.err())
++_stats.fv_err; ++_stats.fv_err;
else if (mov_i.estratto) else if (mov_i.estratto())
++_stats.fv_estr; ++_stats.fv_estr;
} }
if (mov_i.estratto) if (mov_i.estratto())
{ {
if (mov_i.cartaceo) if (mov_i.cartaceo())
{ {
TF9_doccart filecart; TF9_doccart filecart;
TFilename file; 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()) if (filecart.mov2doc(reg, file) && file.exist() || grab_pdf_from_spotlite(mov_i, file) && file.exist())
{ mov_i.set_nomefilecart(file);
mov_i.nomefilecart << file; else
} mov_i.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart);
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;
}
} }
copy_file_to_webapp_fld(mov_i); 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; _head.stato_estr = ok ? D_GEST_OK : D_GEST_ERR;
@ -938,17 +1058,15 @@ bool TEstrazione::estrazione_iva(bool escluso)
if (!bar.add_status()) if (!bar.add_status())
break; break;
if (!it->estratto) if (!it->estratto())
continue; continue;
TLocalisamfile mov(LF_MOV); const TRectype& mov = cache().get(LF_MOV, it->numreg());
TLocalisamfile cli(LF_CLIFO); TToken_string key = mov.get(MOV_TIPO);
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();
key.add(mov.get(MOV_CODCF));
const TRectype& cli = cache().get(LF_CLIFO, key);
const char tipodoc = _head.tipo_doc; const char tipodoc = _head.tipo_doc;
const TString& name_registro = TRegistro(TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).reg()).name(); 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); 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_ANNOES, mov.get_int(MOV_ANNOES));
iva_query.add(IVA_GIVA, tipodoc); iva_query.add(IVA_GIVA, tipodoc);
iva_query.add(IVA_TIPOG, name_registro, 10); 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_TIPOCF, mov.get_char(MOV_TIPO));
iva_query.add(IVA_CODCF, mov.get_long(MOV_CODCF)); 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_IDFISC, idfisc, 30);
iva_query.add(IVA_PIVA, paiv, 28); iva_query.add(IVA_PIVA, paiv, 28);
iva_query.add(IVA_CODFIS, codfis, 16); iva_query.add(IVA_CODFIS, codfis, 16);
iva_query.add(IVA_CATDOC, it->catdoc->catdoc, 10); iva_query.add(IVA_CATDOC, it->catdoc()->catdoc, 10);
iva_query.add(IVA_CAUSSOS, it->catdoc->caus_sost, 6); 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_DATADOC, datadoc);
iva_query.add(IVA_SEZIVA, mov.get(MOV_REG), 10); 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_NPROT, mov.get(MOV_PROTIVA), 20);
iva_query.add(IVA_DATPROT, datareg); 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_DATAOR, TDate(20010101));
}*/ }*/
iva_query.add(IVA_CLASDOC, it->catdoc->class_sost, 10); iva_query.add(IVA_CLASDOC, it->catdoc()->class_sost, 10);
iva_query.add(IVA_NOMFD, it->nomefilecart.name(), 100); iva_query.add(IVA_NOMFD, it->nomefilecart().name(), 100);
// Load annessi... // 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; size_t i = 0;
const size_t size = ann.size(); const size_t size = ann.size();
iva_query.add(IVA_CLASAN1, ann[i].catdocann, 10); iva_query.add(IVA_CLASAN1, ann[i].catdocann, 10);
iva_query.add(IVA_NOMF1, ann[i++].filename, 100); iva_query.add(IVA_NOMF1, ann[i++].filename, 100);
// HOW DID MY LIFE COME TO THIS?... // 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(IVA_USERELA, user(), 10);
iva_query.add_getdate(IVA_TIMEELA); 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), ';'); TToken_string keys(mov.get(MOV_KEYFPPRO), ';');
fppro_db().set_keys(keys); fppro_db().set_keys(keys);
@ -1100,8 +1219,8 @@ void TEstrazione::set_dates()
{ {
if (_escluso) if (_escluso)
{ {
set_dataini(_movs[0].datareg); set_dataini(_movs[0].datareg());
set_dataend(_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; _head.addr_cart = addrcart;
_escluso = escluso; _escluso = escluso;
_error_sql = make_unique<ofstream>(); _error_sql = new ofstream("f9_TEstrazione_error_sql.txt");
_error_sql->open("f9_TEstrazione_error_sql.txt");
// Svuoto log. // Svuoto log.
FILE* f = fopen("TF9Prospetto_integr_error.txt", "w"); ofstream f("TF9Prospetto_integr_error.txt");
fwrite("\n", sizeof(char), 1, f);
fclose(f); f << "\n";
} }
@ -1159,8 +1277,12 @@ void TF9_dberr::write_sqlerrlog(const TString& query) const
void TF9_dberr::add(const TString& string) void TF9_dberr::add(const TString& string)
{ {
TString str; TString str = string;
add_str(str << "'" << string << "'");
str.replace("'", "''");
str.insert("'");
str << "'";
add_str(str);
} }
void TF9_dberr::add(const TDate& date) 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(); 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; TString query;
query << "SELECT * FROM " F9_ERR 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)); 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" << query.cut(0) << "SELECT " DRD_TIPODOC " FROM " F9_DRD "\n" <<
"WHERE " DRD_CODSOC " = '" << codsoc << "' AND " DRD_ID_EST " = '" << id_estr << "'"; "WHERE " DRD_CODSOC " = '" << codsoc << "' AND " DRD_ID_EST " = '" << id_estr << "'";
@ -1269,7 +1391,7 @@ TF9_dberr::TF9_dberr()
// TCategorie_doc // 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) 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; 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) 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) if (classe->causcont.blank() && classe->tipocaus == tipodoc)
return *it; return *it;
} }
return nullptr; 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) 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(); 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) for(auto it = _rows.begin(); it != _rows.end(); ++it)
{ {
@ -1328,12 +1450,14 @@ void TCategorie_doc::load_all()
while (true) while (true)
{ {
const TString& appo = ini_get_string(CONFIG_DITTA, INI_PAR_MOD, INI_CATDOC, "", idx++); const TString& appo = ini_get_string(CONFIG_DITTA, INI_PAR_MOD, INI_CATDOC, "", idx++);
if (appo == "STOP" || appo.blank()) /* STOP: Riga terminatrice */ if (appo == "STOP" || appo.blank()) /* STOP: Riga terminatrice */
break; 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; 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)) if(!(catdoc && *catdoc && class_sost && *class_sost && caus_sost && *caus_sost))
fatal_box("add_categoria failed: some parameters are NULL or keys are empty"); 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(); save_cat();
} }
@ -1532,8 +1658,9 @@ TString_array TCategorie_doc::get_array_rows(const bool traduci)
TString_array sa(_rows.size()); TString_array sa(_rows.size());
for(auto it = _rows.begin(); it != _rows.end(); ++it) for(auto it = _rows.begin(); it != _rows.end(); ++it)
{ {
const shared_ptr<classe_doc>& row = *it; classe_doc *row = *it; // qui
TToken_string ts; TToken_string ts;
ts.add(row->catdoc); ts.add(row->catdoc);
ts.add(row->descr); ts.add(row->descr);
ts.add(!traduci ? row->class_sost : traduci_class_sost(row->class_sost)); 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; 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'. // Leggo la causale e cerco la corrispondente nelle categorie documentali, se c'e'.
// Guardo le colonne causale cont., tipodoc, class. cat. (opcee) // Guardo le colonne causale cont., tipodoc, class. cat. (opcee)
TLocalisamfile mov(LF_MOV); const TRectype & mov = cache().get(LF_MOV, numreg);
mov.put(MOV_NUMREG, numreg);
mov.read();
const TString& caus = mov.get(MOV_CODCAUS); 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(); const TString& tipodoc = c.tipo_doc();
// Cerco se ho un record che abbia specificata quella caus. contabile // 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) if (cat != nullptr)
return cat; return cat;
// Altrimenti cerco per tipo documento // 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; 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 = ""; numreg = "";
annesso = false; annesso = false;
_tdocs.zero(); _tdocs.zero();
_tdocs.setkey(2); _tdocs.setkey(2);
_tdocs.put(F9C_FILENAME, file.name()); _tdocs.put(F9C_FILENAME, file.name());
bool ok = _tdocs.read() == NOERR; bool ok = _tdocs.read() == NOERR;
@ -593,7 +593,9 @@ bool TF9Prospetto_integr::operator()(const char* numreg_acq, const char* numreg_
_items = _prosp_rs->items(); _items = _prosp_rs->items();
if (_items == 0) 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 (!_prosp_rs->last_exec())
{ {
if (log != nullptr) if (log != nullptr)