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

Merge branch 'R12.00.1136' of http://10.65.20.33/sirio/CAMPO/campo into R12.00.1136

Browse Source
This commit is contained in:
New_Macchina_Compilatrice 2022-11-25 12:04:13 +01:00
commit 1f0e7624fe
17 changed files with 558 additions and 488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build/f90.vcxproj
View File

@ -93,6 +93,7 @@
</DataExecutionPrevention> </DataExecutionPrevention>
<TargetMachine>MachineX86</TargetMachine> <TargetMachine>MachineX86</TargetMachine>
<AdditionalLibraryDirectories>..\lib</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\lib</AdditionalLibraryDirectories>
<ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
</Link> </Link>
<Bscmake> <Bscmake>
<SuppressStartupBanner>true</SuppressStartupBanner> <SuppressStartupBanner>true</SuppressStartupBanner>

5
build/f90.vcxproj.filters
View File

@ -68,10 +68,13 @@
<ClCompile Include="..\src\f9\f90200.cpp"> <ClCompile Include="..\src\f9\f90200.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\src\f9\f90400.cpp">
<Filter>Sources</Filter>
</ClCompile>
<ClCompile Include="..\src\f9\f90300.cpp"> <ClCompile Include="..\src\f9\f90300.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\src\f9\f90400.cpp"> <ClCompile Include="..\src\f9\f90500.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\src\f9\f90500.cpp"> <ClCompile Include="..\src\f9\f90500.cpp">

46
src/f9/f90100.cpp
View File

@ -38,6 +38,7 @@ int TEstrai_mask::estrai()
const char tipodoc = get_tipodoc(); const char tipodoc = get_tipodoc();
const bool flagpro = is_provviso(); const bool flagpro = is_provviso();
TFilename path; TFilename path;
TLog_report log("Log estrazione");
f9_app().get_spotlite_path(path); f9_app().get_spotlite_path(path);
@ -50,6 +51,7 @@ int TEstrai_mask::estrai()
F9CONF.get_addr_doc(), // Cartella documenti F9CONF.get_addr_doc(), // Cartella documenti
false, // Estrazione di un escluso false, // Estrazione di un escluso
path, // Spotlight path path, // Spotlight path
&log, // Log
&dataini, // Data estr. mov dal &dataini, // Data estr. mov dal
&dataend, // Data estr. mov al &dataend, // Data estr. mov al
F9CONF.get_has_cartexp() // Flag per estrarre anche i doc. cartacei F9CONF.get_has_cartexp() // Flag per estrarre anche i doc. cartacei
@ -82,7 +84,7 @@ int TEstrai_mask::estrai()
long nreg = mov.get_long(MOV_NUMREG); long nreg = mov.get_long(MOV_NUMREG);
if (nreg == 20045) if (nreg == 207)
int here = 0; int here = 0;
if (escluso) if (escluso)
@ -132,6 +134,8 @@ int TEstrai_mask::estrai()
#endif #endif
// Ricalcolo sheet estrazioni // Ricalcolo sheet estrazioni
f9_app().notify_estraction(); f9_app().notify_estraction();
if (log.rows() > 0)
log.preview();
return result; return result;
} }
@ -165,7 +169,6 @@ bool TEstrai_mask::estrai_handler(TMask_field& f, KEY key)
if (stato == 0) // Errore scrittura F9IVA, non segno in errore in testata... if (stato == 0) // Errore scrittura F9IVA, non segno in errore in testata...
msk.segna_in_errore(); // ... se l'errore e' dovuto alla scrittura sul db. msk.segna_in_errore(); // ... se l'errore e' dovuto alla scrittura sul db.
} }
app.print_log();
msk.field(ES_DESCR).set(""); msk.field(ES_DESCR).set("");
msk.stop_run(K_FORCE_CLOSE); msk.stop_run(K_FORCE_CLOSE);
return true; return true;
@ -620,7 +623,7 @@ void TControllo_mask::associa() // todo: levare gli ultimi residui del vecchio
FOR_EACH_ARRAY_ROW(_controllo_mov, r, row) 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 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++;
TF9_dberr::del_err(_cod_soc, _id_estr, mov_sel->get_int(cid2index(F_CNUMREG))); dberr_del_err(_cod_soc, _id_estr, mov_sel->get_int(cid2index(F_CNUMREG)));
} }
} }
@ -674,9 +677,7 @@ void TControllo_mask::conferma_esclusi() const
TArray& TControllo_mask::import_error_list() TArray& TControllo_mask::import_error_list()
{ {
_controllo_mov.destroy(); _tipo_doc_err = dberr_get_err(_cod_soc, _id_estr, _controllo_mov);
TF9_dberr dberr;
_tipo_doc_err = TF9_dberr::get_errori(_cod_soc, _id_estr, _controllo_mov);
return _controllo_mov; return _controllo_mov;
} }
@ -1345,20 +1346,6 @@ bool TF9_app::year_handler(TMask_field& field, KEY key)
return true; return true;
} }
void TF9_app::add_msg_log(const char* msg)
{
_log << msg << "\n\n";
}
void TF9_app::add_sqlerror_msg_log(const char* query)
{
TString msg;
msg << query << "\n" <<
fp_db().sq_get_string_error() << "\n" <<
fp_db().sq_get_text_error();
add_msg_log(msg);
}
void TF9_app::open_esclusi() void TF9_app::open_esclusi()
{ {
/* Prima chiedo quale mese e anno visualizzare /* Prima chiedo quale mese e anno visualizzare
@ -1460,6 +1447,7 @@ void TF9_app::fill_esclusi()
bool TF9_app::estrai_escl_handler(TMask_field&, KEY key) bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
{ {
TMask descr_mask("Estrazione", 1, 60, 5); TMask descr_mask("Estrazione", 1, 60, 5);
TLog_report log("Log estrazione esclusi");
descr_mask.add_button_tool(DLG_OK, "Conferma", TOOL_OK); descr_mask.add_button_tool(DLG_OK, "Conferma", TOOL_OK);
descr_mask.add_button_tool(DLG_CANCEL, "Annulla", TOOL_CANCEL); descr_mask.add_button_tool(DLG_CANCEL, "Annulla", TOOL_CANCEL);
@ -1476,7 +1464,7 @@ bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
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, f9_app()._estr_escluso =new TEstrazione(F9CONF.get_ambiente(), f9_app()._flagprov_escl,
f9_app()._tipodoc_escl, descr, f9_app()._tipodoc_escl, descr,
F9CONF.get_addr_doc(), true, path); F9CONF.get_addr_doc(), true, path, &log);
// 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;
@ -1499,9 +1487,9 @@ bool TF9_app::estrai_escl_handler(TMask_field&, KEY key)
} }
if (!flag) if (!flag)
message_box("Selezionare il movimento da estrarre"); message_box("Selezionare il movimento da estrarre");
else
f9_app().print_log();
f9_app().fill_esclusi(); f9_app().fill_esclusi();
if (log.rows() > 0)
log.preview();
} }
return true; return true;
} }
@ -1528,14 +1516,6 @@ void TF9_app::edit_wa(TString& old_codsoc) const
fp_db().sq_set_exec(query) && fp_db().sq_commit(); fp_db().sq_set_exec(query) && fp_db().sq_commit();
} }
void TF9_app::print_log()
{
ofstream fout;
fout.open("f9exp_err.txt");
fout << _log;
_log.cut(0);
}
bool TF9_app::is_autofattura(const TLocalisamfile& mov) bool TF9_app::is_autofattura(const TLocalisamfile& mov)
{ {
return cached_causale(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";
@ -1618,7 +1598,8 @@ bool TF9_app::aggiorna_tab_f9(int version) const
const int end = sql.find(';'); // Se trovo un comma lancio la query const int end = sql.find(';'); // Se trovo un comma lancio la query
if (end != int(std::string::npos)) if (end != int(std::string::npos))
{ {
TString query; query << sql.c_str(); TString query(sql.c_str());
ok &= fp_db().sq_set_exec(query, false); ok &= fp_db().sq_set_exec(query, false);
ok &= fp_db().sq_commit(); ok &= fp_db().sq_commit();
sql.erase(); sql.erase();
@ -1678,6 +1659,7 @@ bool TF9_app::check_table() const
if (!check_tab_version()) if (!check_tab_version())
{ {
TString msg; TString msg;
std::ofstream fout; std::ofstream fout;
fout.open("f9checktaberr.txt"); fout.open("f9checktaberr.txt");
fout << fp_db().sq_get_text_error(false) << std::endl; fout << fp_db().sq_get_text_error(false) << std::endl;

9
src/f9/f90100.h
View File

@ -162,10 +162,7 @@ public:
class TF9_app : public TSkeleton_application class TF9_app : public TSkeleton_application
{ {
// friend class TMonitor_mask;
friend class TEstrai_mask; friend class TEstrai_mask;
// friend class TControllo_mask;
// friend class TApri_estr_msk;
friend class TEstrazione; friend class TEstrazione;
TMask * _esclusi_mask; TMask * _esclusi_mask;
@ -177,7 +174,6 @@ class TF9_app : public TSkeleton_application
TToken_string _mov_escl; TToken_string _mov_escl;
char _tipodoc_escl; char _tipodoc_escl;
char _flagprov_escl; char _flagprov_escl;
TString _log;
TEstrazione* _estr_escluso; TEstrazione* _estr_escluso;
@ -212,11 +208,6 @@ public:
void edit_wa(TString& old_codsoc) const; void edit_wa(TString& old_codsoc) const;
// logs // logs
void print_log();
void add_msg_log(const char* msg);
void add_sqlerror_msg_log(const char* query);
static bool is_autofattura(const TLocalisamfile& mov); static bool is_autofattura(const TLocalisamfile& mov);
/** Segna su mov che il movimento e' stato estratto. */ /** Segna su mov che il movimento e' stato estratto. */

8
src/f9/f90200.cpp
View File

@ -117,11 +117,9 @@ bool TF9_categorie_doc_msk::on_key(KEY key)
if (key == K_DEL) if (key == K_DEL)
{ {
TSheet_field& sf = sfield(S_CLASSDOC); TSheet_field& sf = sfield(S_CLASSDOC);
sf.hide();
TString_array& arr = sf.rows_array(); sf.destroy(sf.selected(), true);
arr.destroy(sf.selected(), true);
sf.force_update();
sf.show();
} }
return TAutomask::on_key(key); return TAutomask::on_key(key);
} }

46
src/f9/f90300.cpp
View File

@ -350,7 +350,7 @@ void TGestione_doc_cartacei_f9_msk::edit_ann()
f9ann.put(F9A_NUMREG, numreg); f9ann.put(F9A_NUMREG, numreg);
f9ann.put(F9A_FILENAME, filename); f9ann.put(F9A_FILENAME, filename);
f9ann.read(); f9ann.read();
win.set_fields(TF9_doccart::get_full_path_file_cartaceo(filename), numreg, true, f9ann.get(F9A_CATDOCPAD), f9ann.get(F9A_CATDOCANN)); win.set_fields(get_full_path_file_cartaceo(filename), numreg, true, f9ann.get(F9A_CATDOCPAD), f9ann.get(F9A_CATDOCANN));
win.disable(F_IMPADDRESS); win.disable(F_IMPADDRESS);
win.disable(F_ISANNESSO); win.disable(F_ISANNESSO);
@ -390,7 +390,7 @@ void TGestione_doc_cartacei_f9_msk::edit_file()
f9docs.put(F9C_NUMREG, numreg); f9docs.put(F9C_NUMREG, numreg);
f9docs.put(F9C_NUMREG, nrig); f9docs.put(F9C_NUMREG, nrig);
f9docs.read(); f9docs.read();
win.set_fields(TF9_doccart::get_full_path_file_cartaceo(filename), numreg); win.set_fields(get_full_path_file_cartaceo(filename), numreg);
win.disable(F_IMPADDRESS); win.disable(F_IMPADDRESS);
win.disable(F_ISANNESSO); win.disable(F_ISANNESSO);
@ -486,11 +486,14 @@ void TGestione_doc_cartacei_f9_msk::fill_docs()
sf.reset(); sf.reset();
for (int err = files.first(); err == NOERR; err = files.next()) for (int err = files.first(); err == NOERR; err = files.next())
{ {
const TString& namefile = files.get(F9C_FILENAME); const TFilename namefile = files.get(F9C_FILENAME);
TFilename source_file(F9CONF.get_addr_cart());
const long numreg = files.get_long(F9C_NUMREG); const long numreg = files.get_long(F9C_NUMREG);
const TRectype & mov = cache().get(LF_MOV, numreg); const TRectype & mov = cache().get(LF_MOV, numreg);
const bool not_exist = !check_file_exist(namefile); const bool exist = check_file_exist(namefile);
source_file = source_file.make_absolute_path();
source_file.add(namefile);
if (files.get_int(F9C_NRIG) == 0) if (files.get_int(F9C_NRIG) == 0)
{ {
TRectype rec(files.curr()); TRectype rec(files.curr());
@ -502,7 +505,7 @@ void TGestione_doc_cartacei_f9_msk::fill_docs()
} }
} }
if (not_exist) if (!exist)
file_err.add(namefile, numreg); file_err.add(namefile, numreg);
const int row = sf.set_row_cell(F_FILENAME, namefile); const int row = sf.set_row_cell(F_FILENAME, namefile);
@ -524,7 +527,38 @@ void TGestione_doc_cartacei_f9_msk::fill_docs()
sf.set_row_cell(F_NPROTOCOL, nprot, row); sf.set_row_cell(F_NPROTOCOL, nprot, row);
sf.set_row_cell(F_DESCRMOV, mov.get(MOV_DESCR), row); sf.set_row_cell(F_DESCRMOV, mov.get(MOV_DESCR), row);
sf.set_row_cell(F_DATACARIC, files.get(F9C_LOADDATE), row); sf.set_row_cell(F_DATACARIC, files.get(F9C_LOADDATE), row);
sf.set_row_cell(F_INFO, not_exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : "", row); sf.set_row_cell(F_INFO, !exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : "", row);
if (exist)
{
TRectype mov = (TRectype &)cache().get(LF_MOV, numreg);
if (mov.full())
{
TToken_string cartacei(mov.get(MOV_CARTACEI), '\n');
if (cartacei.find(namefile) < 0)
{
TFilename dest_file;
dest_file = firm2dir(prefix().get_codditta());
dest_file.add("golem");
if (!dexist(dest_file))
make_dir(dest_file);
dest_file.add(namefile);
if (fcopy(source_file, dest_file))
{
TToken_string row(dest_file);
row.add(namefile);
cartacei.add(row);
mov.put(MOV_CARTACEI, cartacei);
mov.rewrite();
}
}
}
}
} }
sf.force_update(); sf.force_update();

22
src/f9/f90400.cpp
View File

@ -149,30 +149,10 @@ void TF9_test_app::main_loop()
} }
} }
if (false)
{
TF9_doccart doccart;
long old_numreg = 95752;
TFilename doc;
TString_array list_annessi;
TArray vect_annessi; // TAnnesso_mov
bool movdoc = doccart.mov2doc(old_numreg, doc);
TString msg("Error retriving filename from reg n. "); msg << old_numreg;
CHECK(movdoc && TString(doc.name()) == "ve1300_F01_0000000011_0002237.pdf", (const char*)msg);
old_numreg = 95222; // Doppio annesso
bool movann = doccart.mov2listann(old_numreg, list_annessi);
//CHECK(movann && list_annessi.items() == 2, "Error retriving list annessi from numreg %s", (const char*)old_numreg);
bool movannvect = doccart.mov2listann_vect(old_numreg, vect_annessi);
//CHECK(movannvect && vect_annessi.size() == 2, "Error retriving vector annessi from numreg %s", (const char*)old_numreg);
}
if(false) if(false)
{ {
TF9Prospetto_integr prosp; TF9Prospetto_integr prosp;
if (prosp("96951", "96952")) if (prosp(96951, 96952))
{ {
TFilename tmp; tmp.tempdir(); TFilename tmp; tmp.tempdir();
tmp.add(prosp.filename().name()); tmp.add(prosp.filename().name());

30
src/f9/f90500.cpp
View File

@ -8,7 +8,10 @@
#include "f90.h" #include "f90.h"
#include "f90500.h" #include "f90500.h"
#include "f9lib.h"
#include "../cg/cglib.h" #include "../cg/cglib.h"
#include "annessif9.h"
#include "docf9.h"
class TRipristina_estrazione : public TSkeleton_application class TRipristina_estrazione : public TSkeleton_application
{ {
@ -42,6 +45,8 @@ bool TRipristina_estrazione::restore(const TString & tipomov,
filter << "(" << MOV_ELABF9 << "!=\"\")"; filter << "(" << MOV_ELABF9 << "!=\"\")";
TCursor c(&rel, filter, 2, &from, &to); TCursor c(&rel, filter, 2, &from, &to);
TLocalisamfile f9ann(LF_F9ANNESSI);
TLocalisamfile f9docs(LF_F9DOCS);
TRectype & mov = c.curr(); TRectype & mov = c.curr();
long last_num = 0L; long last_num = 0L;
const long items = c.items(); const long items = c.items();
@ -58,13 +63,36 @@ bool TRipristina_estrazione::restore(const TString & tipomov,
if (reg.tipo() == tipo) if (reg.tipo() == tipo)
{ {
const long numreg = mov.get_long(MOV_NUMREG);
mov.zero(MOV_ELABF9); mov.zero(MOV_ELABF9);
const int err = mov.rewrite(rel.lfile()); const int err = mov.rewrite(rel.lfile());
if (err != NOERR) if (err != NOERR)
return error_box(FR("Errore nell'aggiornamento del movimento %ld.\n Errore n. %d"), return error_box(FR("Errore nell'aggiornamento del movimento %ld.\n Errore n. %d"),
mov.get_long(MOV_NUMREG), err); numreg, err);
f9ann.put(F9A_NUMREG, numreg);
if (f9ann.read() == NOERR)
{
TFilename file(F9CONF.get_addr_cart());
file.make_absolute_path();
file.add(f9ann.get(F9A_FILENAME));
if (file.exist())
file.fremove();
f9ann.remove();
}
f9docs.put(F9A_NUMREG, numreg);
for (int err = f9docs.read(_isgteq); err == NOERR && numreg == f9docs.get_long(F9C_NUMREG); err = f9docs.next())
{
TFilename file(F9CONF.get_addr_cart());
file.make_absolute_path();
file.add(f9docs.get(F9C_FILENAME));
if (file.exist())
file.fremove();
f9docs.remove();
}
} }
} }
} }

98
src/f9/f9lib.h
View File

@ -12,6 +12,7 @@
#include "sheet.h" #include "sheet.h"
#include "sqlset.h" #include "sqlset.h"
#include "reprint.h" #include "reprint.h"
#include "reputils.h"
#define INI_PAR_MOD "F9" #define INI_PAR_MOD "F9"
#define INI_CATDOC "CATDOC" #define INI_CATDOC "CATDOC"
@ -328,9 +329,11 @@ class TMovimento_estr : public TObject // aggiungere metodi per TArray
bool _estratto; bool _estratto;
err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.' err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.'
bool _cartaceo; bool _cartaceo;
TFilename _nomefilecart; TString_array _documenti_allegati;
TArray _annessi; // TAnnesso_mov TString _cat_doc_padre;
TDate _data_estr;
TString _user;
TFilename _nomefiledoc;
TMovimento_estr & copy(const TMovimento_estr & m); TMovimento_estr & copy(const TMovimento_estr & m);
public: public:
@ -356,19 +359,28 @@ public:
bool estratto() const { return _estratto; } bool estratto() const { return _estratto; }
err_mov descr_estr() const { return _descr_estr; } err_mov descr_estr() const { return _descr_estr; }
TClasse_doc* catdoc(TCategorie_doc& catdoc) const { return catdoc.mov2cat(numreg()); } TClasse_doc* catdoc(TCategorie_doc& catdoc) const { return catdoc.mov2cat(numreg()); }
TArray & annessi() { return _annessi; } bool cartaceo() const { return _cartaceo || allegati(); }
bool cartaceo() const { return _cartaceo; } // todo const TFilename & nomefiledoc() const { return _nomefiledoc; }
const TFilename & nomefilecart() const { return _nomefilecart; } bool allegati() const { return _documenti_allegati.items() > 0; }
TString_array & documenti_allegati() { return _documenti_allegati; }
const TString & cat_doc_padre() const { return _cat_doc_padre; }
TDate data_estr() const { return _data_estr; }
const TString& user() const { return _user; };
// void set_err(bool err) { _err = err; }
void set_err(const char * descr = "", err_mov descr_estr = mov_no_error); void set_err(const char * descr = "", err_mov descr_estr = mov_no_error);
void reset_err() { set_err(); } void reset_err() { set_err(); }
void set_cartaceo(bool cartaceo) { _cartaceo = cartaceo; }
void set_state(state_fppro state) { _state = state; } void set_state(state_fppro state) { _state = state; }
void set_descr_estr(err_mov descr_estr) { _descr_estr = descr_estr; } void set_descr_estr(err_mov descr_estr) { _descr_estr = descr_estr; }
void set_numdoc(const char * numdoc) { _numdoc = numdoc; } void set_numdoc(const char * numdoc) { _numdoc = numdoc; }
void set_estratto(bool estratto) { _estratto = estratto; } void set_estratto(bool estratto) { _estratto = estratto; }
void set_nomefilecart(const char * nomefilecart) { _nomefilecart = nomefilecart; } void set_nomefiledoc(const char * nomefiledoc) { _nomefiledoc = nomefiledoc; }
void set_cartaceo(bool cartaceo) { _cartaceo = cartaceo; }
void set_cat_doc_padre(const char *cat) { _cat_doc_padre = cat; }
void set_data_estr(TDate data) { _data_estr = data; }
void set_user(const char *user) { _user = user; };
bool load_docs();
bool fill_doc_list(TString_array& list_docs);
TMovimento_estr(TSheet_field& sf, int row); TMovimento_estr(TSheet_field& sf, int row);
TMovimento_estr(const long numreg); TMovimento_estr(const long numreg);
@ -378,11 +390,13 @@ public:
~TMovimento_estr() {} ~TMovimento_estr() {}
}; };
long find_movcoll(long numreg); // ma serve ??
class TEstrazione : public TObject class TEstrazione : public TObject
{ {
drd _head; drd _head;
TArray _movs; // TMovimento_estr TArray _movs; // TMovimento_estr
ofstream * _error_sql; TLog_report * _log;
bool _escluso; bool _escluso;
const TString _descr; const TString _descr;
bool _has_cartacei; bool _has_cartacei;
@ -391,12 +405,12 @@ class TEstrazione : public TObject
/** Aggiorna stato estrazione. Utilizzato ad esempio dopo la diagnostica per riportare /** Aggiorna stato estrazione. Utilizzato ad esempio dopo la diagnostica per riportare
* il nuovo stato sul db. * il nuovo stato sul db.
*/ */
bool update_drd_stato_estr() const; bool update_drd_stato_estr();
static const char* caus_sos(const TLocalisamfile& mov, TipoIVA iva); const char* caus_sos(const TLocalisamfile& mov, TipoIVA iva);
static void check_annessi(TMovimento_estr& mov_i, int numreg); // Controllo se ci sono tutti gli annessi obbligatori. void check_annessi(TMovimento_estr& mov); // Controllo se ci sono tutti gli annessi obbligatori.
// Controllo se esistono tutti gli annessi cartacei obbligatori e se ci sono annessi reverse charge li genero. // Controllo se esistono tutti gli annessi cartacei obbligatori e se ci sono annessi reverse charge li genero.
static bool check_annessi_oblig(const TString& catdoc, int numreg, TToken_string& ann_nexist); bool check_annessi_oblig(TMovimento_estr& mov, TToken_string& ann_nexist);
static bool check_cartaceo_acq(const TMovimento_estr& movimento); bool check_cartaceo_acq(TMovimento_estr& movimento);
static bool check_documento_vendita(const TLocalisamfile& mov, bool& exist_doc); static bool check_documento_vendita(const TLocalisamfile& mov, bool& exist_doc);
/** CHECK RIFERIMENTO FPPRO /** CHECK RIFERIMENTO FPPRO
* Per le fatture di acquisto controllo se ho il riferimento nell'FPPRO. * Per le fatture di acquisto controllo se ho il riferimento nell'FPPRO.
@ -411,13 +425,12 @@ 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(TMovimento_estr& movimento) const; void copy_file_to_webapp_fld(TMovimento_estr& movimento) const;
static void fill_id(const TRectype& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis); 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 TRectype& mov); bool is_doc_xml(const TRectype& mov);
static bool find_movcoll(int numreg, TString& numreg_rev_vend); bool load_docs(TMovimento_estr& movimento) { return movimento.load_docs(); }
static bool load_annessi(TMovimento_estr& 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.
static bool stampa_documento(const TMovimento_estr& movimento, TFilename& file); // bool stampa_documento(const TMovimento_estr& movimento, TFilename& file);
bool grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const; bool grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const;
public: public:
@ -427,16 +440,16 @@ private:
static TString& drd_attr(); static TString& drd_attr();
TString& drd_tovalues() const; TString& drd_tovalues() const;
bool insert_into_drd() const; /**< Scrittura testata estrazione. Tabella F9DRD. */ bool insert_into_drd(); /**< Scrittura testata estrazione. Tabella F9DRD. */
bool insert_into_f9movestr() const; /**< Scrittura su db dell'elenco di movimenti presi. */ bool insert_into_f9movestr(); /**< Scrittura su db dell'elenco di movimenti presi. */
bool export_error_list() const; /**< Esporta sheet controllo fatture sul db. */ bool export_error_list(); /**< Esporta sheet controllo fatture sul db. */
/** Controlla ultimo id estrazione della giornata e in base al tipo di estrazione, /** Controlla ultimo id estrazione della giornata e in base al tipo di estrazione,
* 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 TRectype& mov); static bool pura_iva(const TRectype& mov);
void write_errorsql_log(const TString& query) const; void write_errorsql_log(const TString& query);
public: public:
@ -485,8 +498,8 @@ public:
void set_addrcart(const TString& addrcart) { _head.addr_cart = addrcart; } void set_addrcart(const TString& addrcart) { _head.addr_cart = addrcart; }
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, TLog_report * log, const TDate* dal = nullptr, const TDate* al = nullptr, bool has_cartacei = false);
~TEstrazione() { safe_delete(_error_sql); } ~TEstrazione() {}
}; };
@ -494,7 +507,7 @@ class TF9_dberr
{ {
TString _str; TString _str;
TString _insert; TString _insert;
ofstream* _fout; TLog_report * _log;
protected: protected:
void add_str(const TString& string); void add_str(const TString& string);
@ -507,11 +520,12 @@ public:
void add(long num); void add(long num);
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); TF9_dberr(TLog_report * log);
static char get_errori(const TString& codsoc, const TString& id_estr, TArray& controllo_mov);
TF9_dberr();
}; };
bool dberr_del_err(const TString& codsoc, const TString& id_estr, int numreg);
char dberr_get_err(const TString& codsoc, const TString& id_estr, TArray& controllo_mov);
class TIva_insert_prepared_stat class TIva_insert_prepared_stat
{ {
TAssoc_array _fields; // TString TAssoc_array _fields; // TString
@ -534,26 +548,22 @@ public:
void reset(); void reset();
}; };
bool doc_already_exists(const TFilename& file, long& numreg);
const TString & get_full_path_file_cartaceo(const TString& filename);
class TF9_doccart class TF9_doccart
{ {
TLocalisamfile _tannessi;
public: public:
static bool add_cart(const TFilename& file, long numreg, bool is_annesso = false, static bool add_cart(const TFilename& file, long 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, long & numreg, bool& TAnnesso); bool doc_already_exists(const TFilename& file, long & numreg, bool& TAnnesso);
bool mov2doc(long numreg, TFilename& doc); bool mov2doc(long numreg, TFilename& doc);
bool mov2listann(const TString& numreg, TString_array & list_annessi); bool mov2listann(long numreg, TMovimento_estr& movimento, TString_array & list_annessi);
bool mov2listann_vect(const long numreg, TArray & list_annessi); bool mov2listann_vect(const long numreg, TArray & list_annessi);
bool load_docs(long numreg, TMovimento_estr& movimento);
static TString & get_full_path_file_cartaceo(const TString& filename)
{
TString & s = get_tmp_string();
s << TFilename(F9CONF.get_addr_cart()).slash_terminate() << filename;
return s;
}
TF9_doccart() : _tannessi(LF_F9ANNESSI) { } TF9_doccart() { }
}; };
@ -601,9 +611,9 @@ class TProspetto_recset final : public TSQL_recordset
public: public:
const TString& get_query() const { return _query; } const TString& get_query() const { return _query; }
static void get_sum_imponibile_imposta(const char* numreg_ven, real& s_imponibili, real& s_imposte); static void get_sum_imponibile_imposta(long numreg_ven, real& s_imponibili, real& s_imposte);
TProspetto_recset(const char* numreg_acq, const char* numreg_ven); TProspetto_recset(long numreg_acq, long numreg_ven);
~TProspetto_recset(); ~TProspetto_recset();
}; };
@ -624,7 +634,7 @@ public:
bool preview(); bool preview();
const TFilename& filename() const { return _rep.filename(); } const TFilename& filename() const { return _rep.filename(); }
bool operator()(const char* numreg_acq, const char* numreg_ven); bool operator()(long numreg_acq, long numreg_ven);
TF9Prospetto_integr(); TF9Prospetto_integr();
}; };

489
src/f9/f9lib01.cpp
View File

@ -73,8 +73,7 @@ TMovimento_estr & TMovimento_estr::copy(const TMovimento_estr & m)
_state = m._state; _state = m._state;
_estratto = m._estratto; _estratto = m._estratto;
_descr_estr = m._descr_estr; _descr_estr = m._descr_estr;
// _catdoc = m._catdoc == nullptr ? nullptr : new TClasse_doc(*m._catdoc); _documenti_allegati = m._documenti_allegati;
_cartaceo = m._cartaceo;
_numreg = m._numreg; _numreg = m._numreg;
_datareg = m._datareg; _datareg = m._datareg;
_datadoc = m._datadoc; _datadoc = m._datadoc;
@ -86,11 +85,14 @@ TMovimento_estr & TMovimento_estr::copy(const TMovimento_estr & m)
_ragsoc = m._ragsoc; _ragsoc = m._ragsoc;
_reg_protiva = m._reg_protiva; _reg_protiva = m._reg_protiva;
_descr = m._descr; _descr = m._descr;
_cat_doc_padre = m._cat_doc_padre;
_data_estr = m._data_estr;
_user = m._user;
return *this; return *this;
} }
TMovimento_estr::TMovimento_estr(TSheet_field& sf, int row) : _err(false), _state(null_state), _estratto(true), TMovimento_estr::TMovimento_estr(TSheet_field& sf, int row) : _err(false), _state(null_state), _estratto(true),
_descr_estr(mov_no_error), /*_catdoc(nullptr),*/ _cartaceo(false) _descr_estr(mov_no_error), _data_estr(today), _user(user())
{ {
_numreg = sf.get_long_row_cell(row, FE_NUMREG); _numreg = sf.get_long_row_cell(row, FE_NUMREG);
_datareg = sf.get_date_row_cell(row, FE_DATAREG); _datareg = sf.get_date_row_cell(row, FE_DATAREG);
@ -103,6 +105,12 @@ TMovimento_estr::TMovimento_estr(TSheet_field& sf, int row) : _err(false), _stat
_ragsoc = sf.get_long_row_cell(row, FE_RAGSOC); _ragsoc = sf.get_long_row_cell(row, FE_RAGSOC);
_reg_protiva = sf.get_str_row_cell(row, FE_PROTIVA); _reg_protiva = sf.get_str_row_cell(row, FE_PROTIVA);
_descr = sf.get_long_row_cell(row, FE_DESCR); _descr = sf.get_long_row_cell(row, FE_DESCR);
TClasse_doc * classe = catdoc(categorie_doc());
if (classe != nullptr)
{
_cat_doc_padre = classe->catdoc();
}
} }
void TMovimento_estr::set_err(const char * descr, err_mov descr_estr) void TMovimento_estr::set_err(const char * descr, err_mov descr_estr)
@ -118,8 +126,77 @@ void TMovimento_estr::set_err(const char * descr, err_mov descr_estr)
_descr_estr = error ? mov_annesso_nexist : mov_no_error; _descr_estr = error ? mov_annesso_nexist : mov_no_error;
} }
bool TMovimento_estr::load_docs()
{
TLocalisamfile annessi(LF_F9ANNESSI);
bool found = false;
documenti_allegati().destroy();
const TRectype & mov = cache().get(LF_MOV, numreg());
TToken_string cartacei(mov.get(MOV_CARTACEI), '\n');
FOR_EACH_STR_TOKEN(cartacei, str)
{
TToken_string orig(str);
TToken_string row(orig.get());
row.add(cat_doc_padre());
row.add(orig.get(4));
row.add(data_estr());
row.add(user());
documenti_allegati().add(row);
found = true;
}
annessi.put(F9A_NUMREG, numreg());
// Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta.
for (int err = annessi.read(_isgteq) == NOERR; err == NOERR && annessi.get_long(F9A_NUMREG) == numreg(); err = annessi.next())
{
if (!found)
{
set_cat_doc_padre(annessi.get(F9A_CATDOCPAD));
set_data_estr(annessi.get_date(F9A_LOADDATE));
set_user(annessi.get(F9A_USER));
}
TToken_string row(annessi.get(F9A_FILENAME));
row.add(cat_doc_padre());
row.add(annessi.get(F9A_CATDOCANN));
row.add(data_estr());
row.add(user());
documenti_allegati().add(row);
found = true;
}
return found;
}
bool TMovimento_estr::fill_doc_list(TString_array& list_docs)
{
bool ok = load_docs();
list_docs.destroy();
if (ok)
{
// Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta.
FOR_EACH_ARRAY_ROW(_documenti_allegati, r, str)
{
TToken_string t;
t.add(numreg());
t.add(str->get());
t.add(str->get());
t.add(str->get());
t.add(str->get());
t.add(str->get());
list_docs.add(t);
}
}
return ok;
}
TMovimento_estr::TMovimento_estr(const long numreg) : _err(false), _state(null_state), _estratto(true), _descr_estr(mov_no_error), TMovimento_estr::TMovimento_estr(const long numreg) : _err(false), _state(null_state), _estratto(true), _descr_estr(mov_no_error),
/* _catdoc(nullptr),*/ _cartaceo(false) _data_estr(today), _user(user())
{ {
const TRectype & mov = cache().get(LF_MOV, numreg); const TRectype & mov = cache().get(LF_MOV, numreg);
TToken_string key(mov.get(MOV_TIPO)); TToken_string key(mov.get(MOV_TIPO));
@ -142,9 +219,8 @@ TMovimento_estr::TMovimento_estr(const long numreg) : _err(false), _state(null_s
_descr = mov.get(MOV_DESCR); _descr = mov.get(MOV_DESCR);
} }
TMovimento_estr::TMovimento_estr(TISAM_recordset & mov, TipoIVA tipo, bool escl) : _err(false), _state(null_state), TMovimento_estr::TMovimento_estr(TISAM_recordset & mov, TipoIVA tipo, bool escl) : _err(false), _state(null_state), _estratto(true),
_estratto(true), _descr_estr(mov_no_error), _descr_estr(mov_no_error), _data_estr(today), _user(user())
/* _catdoc(nullptr), */ _cartaceo(false)
{ {
_numreg = mov.get_long(MOV_NUMREG); _numreg = mov.get_long(MOV_NUMREG);
_datareg = mov.get_date(MOV_DATAREG); _datareg = mov.get_date(MOV_DATAREG);
@ -225,32 +301,37 @@ const char* TEstrazione::caus_sos(const TLocalisamfile& mov, const TipoIVA iva)
return ""; return "";
} }
void TEstrazione::check_annessi(TMovimento_estr& mov_i, const int numreg) void TEstrazione::check_annessi(TMovimento_estr& mov)
{ {
TToken_string ann_nexist; TToken_string ann_nexist;
if (!check_annessi_oblig(mov_i.catdoc(categorie_doc())->catdoc(), numreg, ann_nexist)) if (!check_annessi_oblig(mov, 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.set_err(msg_annessi_mancanti); mov.set_err(msg_annessi_mancanti);
} }
else else
{ load_docs(mov);
load_annessi(mov_i);
}
} }
bool TEstrazione::check_annessi_oblig(const TString& catdoc, const int numreg,TToken_string& ann_nexist) bool TEstrazione::check_annessi_oblig(TMovimento_estr& mov, TToken_string& ann_nexist)
{ {
ann_nexist.destroy(-1);
const TString_array lista_cat_annessi = categorie_doc().get_array_ann(catdoc); // Lista cat annessi
TF9_doccart file_cart; TF9_doccart file_cart;
TArray list_file_ann; // Lista file annessi TString_array list_file_ann; // Lista file annessi
TClasse_doc * classe = mov.catdoc(categorie_doc());
TString catdoc;
file_cart.mov2listann_vect(numreg, list_file_ann); if (classe != nullptr)
catdoc = classe->catdoc();
const TString_array lista_cat_annessi = categorie_doc().get_array_ann(catdoc); // Lista cat annessi
ann_nexist.cut(0);
mov.fill_doc_list(list_file_ann);
bool ok_ann = true; bool ok_ann = true;
@ -266,11 +347,11 @@ bool TEstrazione::check_annessi_oblig(const TString& catdoc, const int numreg,TT
// Controllo che esista l'annesso per questo mov. // Controllo che esista l'annesso per questo mov.
bool exist = false; bool exist = false;
FOR_EACH_ARRAY_ITEM(list_file_ann, r, obj) FOR_EACH_ARRAY_ROW(list_file_ann, r, row)
{ {
TAnnesso_mov * f_ann = (TAnnesso_mov *)obj; TString catdocann = row->get(3);
if (f_ann->catdocann() == ann_name) if (catdocann == ann_name)
{ {
exist = true; exist = true;
break; break;
@ -280,25 +361,41 @@ bool TEstrazione::check_annessi_oblig(const TString& catdoc, const int numreg,TT
if (!exist) if (!exist)
ann_nexist.add(ann_name); ann_nexist.add(ann_name);
} }
else if(ok_cat && ann->opcee() == "RC") else
if(ok_cat && ann->opcee() == "RC")
{ {
// Generazione prospetto integrativo. // Generazione prospetto integrativo.
const bool ok = make_prosp_int_revc(numreg, ann); const bool ok = make_prosp_int_revc(mov.numreg(), ann);
if (!ok) if (!ok)
ann_nexist.add(TString() << "Prospetto integrativo (" << ann->catdoc() << ")"); {
TString msg(TR("Prospetto integrativo"));
msg << "(" << ann->catdoc() << ")";
ann_nexist.add(msg);
}
ok_ann &= ok; ok_ann &= ok;
} }
} }
return ok_ann; return ok_ann;
} }
bool TEstrazione::check_cartaceo_acq(const TMovimento_estr& movimento) bool TEstrazione::check_cartaceo_acq(TMovimento_estr& movimento)
{ {
TF9_doccart filecart; bool ok = movimento.load_docs();
TFilename file;
return filecart.mov2doc(movimento.numreg(), file) && file.exist(); if (ok)
{
FOR_EACH_ARRAY_ROW(movimento.documenti_allegati(), r, str)
{
TFilename file = str->get();
ok &= file.exist();
if (!ok)
break;
}
}
return ok;
} }
bool TEstrazione::check_documento_vendita(const TLocalisamfile& mov, _Out_ bool& exist_doc) bool TEstrazione::check_documento_vendita(const TLocalisamfile& mov, _Out_ bool& exist_doc)
@ -370,42 +467,37 @@ void TEstrazione::copy_file_to_webapp_fld(TMovimento_estr& movimento) const
// f9pwa + ambiente + idlancio(ID drd) + categoria_documento(drt) + nome_documento // f9pwa + ambiente + idlancio(ID drd) + categoria_documento(drt) + nome_documento
TFilename base(F9CONF.get_addr_doc_loc()); TFilename base(F9CONF.get_addr_doc_loc());
base.add(_head.cod_soc).add(_head.id_estr).slash_terminate(); base.add(_head.cod_soc).add(_head.id_estr).slash_terminate();
TToken_string categorie;
TToken_string files;
TClasse_doc * cd = movimento.catdoc(categorie_doc()); TClasse_doc * cd = movimento.catdoc(categorie_doc());
TFilename file = movimento.nomefilecart(); const bool has_allegati = movimento.allegati();
file.trim(); if (has_allegati)
if (movimento.cartaceo() && cd != nullptr && file.full())
{ {
categorie.add(cd->catdoc(), 0); TString_array & docs = movimento.documenti_allegati();
files.add(file, 0);
}
if(!movimento.annessi().empty()) //qui
{
FOR_EACH_ARRAY_ITEM(movimento.annessi(), r, obj)
{
TAnnesso_mov & ann = (TAnnesso_mov &) *obj;
categorie.add(ann.catdocann()); FOR_EACH_ARRAY_ROW(docs, r, str)
files.add(TF9_doccart::get_full_path_file_cartaceo(ann.filename())); {
TFilename file = str->get(0);
if (file.full())
{
TFilename dest(base);
if (file.is_relative_path())
{
const TString studio = prefix().get_studio();
file.insert(studio);
}
if (cd != nullptr && file.full())
dest.add(cd->catdoc());
else
dest.add("cartaceo");
dest.add(file.name());
make_dir(dest.path());
if (!fcopy(file, dest))
error_box(FR("Errore nel copiare il %s in %s"), (const char*)file, (const char*)dest);
} }
} }
#ifdef DBG
CHECK(files.items() == categorie.items(), "copy_file_to_webapp_fld: Numero di file diverso dal numero di categorie");
#endif
for(int i = 0; i < files.items(); ++i)
{
TFilename file = files.get(i);
TFilename dest(base);
dest.add(categorie.get(i)).add(file.name());
make_dir(dest.path());
const bool f = fcopy(file, dest);
if (!f)
error_box("Errore nel copiare il file nella cartella di destinazione: %s", (const char*)dest);
} }
} }
@ -466,45 +558,7 @@ bool TEstrazione::is_doc_xml(const TRectype& mov)
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::stampa_documento(const TMovimento_estr& movimento, TFilename& file)
{
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg);
mov.read();
const TCausale& cau = cached_causale(mov.get(MOV_CODCAUS), mov.get_int(MOV_ANNOES));
const TString4 cau_reg = cau.causale_reg_iva();
const TString numdoc = mov.get(MOV_NUMDOC);
TString query("USE ");
query << LF_MOV << " KEY 1 SELECT " << MOV_CODCAUS << "==\"" << cau_reg << "\"\nFROM " << MOV_NUMREG << "==" << numreg;
TISAM_recordset mov_rs(query);
long movcoll = 0L;
for (bool ok = mov_rs.move_first(); ok; ok = mov_rs.move_next())
{
TRectype& curr = (TRectype&)mov_rs.cursor()->curr();
const long movcoll_found = curr.get_long(MOV_MOVCOLL);
if (curr.get(MOV_NUMDOC) == numdoc && (movcoll_found == 0L || movcoll_found == numreg))
{
movcoll = mov_rs.get(MOV_NUMREG).as_int();
curr.put(MOV_MOVCOLL, numreg);
break;
}
}
numreg_rev_vend.cut(0) << movcoll;
return numreg_rev_vend.full();
}
bool TEstrazione::load_annessi(TMovimento_estr& movimento)
{
TF9_doccart doccart;
return doccart.mov2listann_vect(movimento.numreg(), movimento.annessi());
}
bool TEstrazione::stampa_documento(const TMovimento_estr& 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.
@ -531,10 +585,9 @@ bool TEstrazione::stampa_documento(const TMovimento_estr& movimento, TFilename&
// Controllo anche se false perche' potrebbe esistere gia'. // Controllo anche se false perche' potrebbe esistere gia'.
if(!TF9_doccart::add_cart(file, movimento.numreg())) if(!TF9_doccart::add_cart(file, movimento.numreg()))
{ {
TF9_doccart filecart;
TFilename fdoc; TFilename fdoc;
ok = filecart.mov2doc(movimento.numreg(), fdoc) && fdoc.name() == file.name(); ok = movimento.load_docs() && fdoc.name() == file.name();
} }
else else
ok = true; ok = true;
@ -543,7 +596,7 @@ bool TEstrazione::stampa_documento(const TMovimento_estr& movimento, TFilename&
} }
} }
return ok; return ok;
} } */
bool TEstrazione::grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const bool TEstrazione::grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const
{ {
@ -582,33 +635,38 @@ bool TEstrazione::make_prosp_int_revc(const int numreg, TAnnesso * annesso)
TLocalisamfile mov(LF_MOV); TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, numreg); mov.put(MOV_NUMREG, numreg);
mov.read(); mov.read();
TString rev_vend = mov.get(MOV_MOVCOLL);
if((rev_vend.full() || find_movcoll(numreg, rev_vend)) && rev_vend != "0") long rev_vend = mov.get_long(MOV_MOVCOLL);
if (rev_vend == 0)
rev_vend = find_movcoll(numreg);
if (rev_vend > 0)
{ {
TF9Prospetto_integr prosp; TF9Prospetto_integr prosp;
TString acq; acq << numreg; const long acq = numreg;
if (prosp(acq, rev_vend)) if (prosp(acq, rev_vend))
{ {
// [ NUMREG][ CAT.ANN.].pdf // [ NUMREG][ CAT.ANN.].pdf
// [0000000][AAAAAAAAAA].pdf // [0000000][AAAAAAAAAA].pdf
TFilename tmp_file; tmp_file.tempdir(); TFilename tmp_file; tmp_file.tempdir();
TString name; name << format("%07d%10s", numreg, (const char*)annesso->catdoc()); TString name; name << format("%07d%10s", numreg, (const char*)annesso->catdoc());
name.replace(' ', '_'); name.replace(' ', '_');
tmp_file.add(name); tmp_file.add(name);
tmp_file.ext("pdf"); tmp_file.ext("pdf");
if(prosp.export_pdf(tmp_file)) if (prosp.export_pdf(tmp_file))
{ {
// Sposto il file nella cartella dei documenti cartacei. // Sposto il file nella cartella dei documenti cartacei.
const TFilename newfile(TF9_doccart::get_full_path_file_cartaceo(tmp_file.name())); const TFilename newfile(get_full_path_file_cartaceo(tmp_file.name()));
// if (newfile.exist()) // if (newfile.exist())
// DeleteFile(newfile); // DeleteFile(newfile);
fcopy(tmp_file, newfile); fcopy(tmp_file, newfile);
// Controllo che non esista gia' altrimenti elimino il record // Controllo che non esista gia' altrimenti elimino il record
TF9_doccart doccart; TF9_doccart doccart;
bool a;
long numreg_old; long numreg_old;
if (doccart.doc_already_exists(newfile, numreg_old, a)) if (doc_already_exists(newfile, numreg_old))
{ {
TLocalisamfile lf_ann(LF_F9ANNESSI); TLocalisamfile lf_ann(LF_F9ANNESSI);
lf_ann.setkey(2); lf_ann.setkey(2);
@ -654,7 +712,7 @@ TString& TEstrazione::drd_tovalues() const
_head.stato_estr << "', '" << _head.addr_cart << "'"; _head.stato_estr << "', '" << _head.addr_cart << "'";
} }
bool TEstrazione::insert_into_drd() const bool TEstrazione::insert_into_drd()
{ {
TString query; TString query;
query << "INSERT INTO " F9_DRD " ( " << drd_attr() << " ) \nVALUES ( " << drd_tovalues() << " );"; query << "INSERT INTO " F9_DRD " ( " << drd_attr() << " ) \nVALUES ( " << drd_tovalues() << " );";
@ -665,7 +723,7 @@ bool TEstrazione::insert_into_drd() const
return ok; return ok;
} }
bool TEstrazione::insert_into_f9movestr() const bool TEstrazione::insert_into_f9movestr()
{ {
TString query; TString query;
bool ok = true; bool ok = true;
@ -694,9 +752,9 @@ bool TEstrazione::insert_into_f9movestr() const
return ok; return ok;
} }
bool TEstrazione::export_error_list() const bool TEstrazione::export_error_list()
{ {
TF9_dberr dberr; TF9_dberr dberr(_log);
const TArray & movs = _movs; // <TMovimento_estr> const TArray & movs = _movs; // <TMovimento_estr>
bool ok = true; bool ok = true;
int count = 0; int count = 0;
@ -771,23 +829,17 @@ bool TEstrazione::pura_iva(const TRectype& mov)
return rel->cg_rows() == 0; return rel->cg_rows() == 0;
} }
void TEstrazione::write_errorsql_log(const TString& query) const void TEstrazione::write_errorsql_log(const TString& query)
{ {
TString msg; _log->log(2, query);
msg << query << "\n" << _log->log(2, fp_db().sq_get_string_error());
fp_db().sq_get_string_error() << "\n" << _log->log(2, fp_db().sq_get_text_error());
fp_db().sq_get_text_error(); _log->line();
if (_error_sql->is_open())
*_error_sql << msg << "\n\n";
#ifdef DBG
else
warning_box("Impossibile aprire il file f9_TEstrazione_error_sql.txt\nper scrivere errori scrittura db.");
#endif
} }
// Public methods ///////////////////////////////////////////////////////////////////////////////////////////// // Public methods /////////////////////////////////////////////////////////////////////////////////////////////
bool TEstrazione::update_drd_stato_estr() const bool TEstrazione::update_drd_stato_estr()
{ {
bool ok; bool ok;
do do
@ -833,7 +885,7 @@ const char* TEstrazione::diagnostica_mov()
const long numreg = mov_i.numreg(); const long numreg = mov_i.numreg();
if (numreg == 20045) { if (numreg == 210) {
int here = 0; int here = 0;
} }
@ -916,30 +968,12 @@ const char* TEstrazione::diagnostica_mov()
// DA CONTROLLARE // DA CONTROLLARE
if (found) if (found)
check_annessi(mov_i, numreg); check_annessi(mov_i);
} }
// 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...
{ mov_i.load_docs();
if (mov_i.cartaceo())
{
TF9_doccart filecart;
TFilename file;
if (filecart.mov2doc(mov_i.numreg(), file) && file.exist())
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);
}
else
{
ok &= true;
mov_i.set_err("", mov_no_cartaceo);
mov_i.set_estratto(false);
++_stats.fa_skip;
}
}
copy_file_to_webapp_fld(mov_i); copy_file_to_webapp_fld(mov_i);
} }
} }
@ -969,7 +1003,7 @@ const char* TEstrazione::diagnostica_mov()
*/ */
if (!mov_i.err() && mov_i.estratto()) if (!mov_i.err() && mov_i.estratto())
{ {
mov_i.set_cartaceo(!is_doc_xml(mov)); // mov_i.set_cartaceo(!is_doc_xml(mov)); ci deve essere ?
unsigned short skip = 0; unsigned short skip = 0;
@ -1010,7 +1044,7 @@ const char* TEstrazione::diagnostica_mov()
else else
mov_i.set_err("Categoria assente", mov_no_catdoc); mov_i.set_err("Categoria assente", mov_no_catdoc);
if (cd != nullptr) if (cd != nullptr)
check_annessi(mov_i, mov_i.numreg()); check_annessi(mov_i);
if (!mov_i.catdoc(categorie_doc())) if (!mov_i.catdoc(categorie_doc()))
++_stats.fv_nocatdoc; ++_stats.fv_nocatdoc;
@ -1024,16 +1058,29 @@ const char* TEstrazione::diagnostica_mov()
{ {
if (mov_i.cartaceo()) if (mov_i.cartaceo())
{ {
TF9_doccart filecart;
TFilename file; TFilename file;
if (filecart.mov2doc(mov_i.numreg(), file) && file.exist() || grab_pdf_from_spotlite(mov_i, file) && file.exist()) // if (filecart.mov2doc(mov_i.numreg(), file) && file.exist() || grab_pdf_from_spotlite(mov_i, file) && file.exist())
mov_i.set_nomefilecart(file); if (grab_pdf_from_spotlite(mov_i, file) && file.exist())
mov_i.set_nomefiledoc(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.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart);
} }
TToken_string cartacei(mov.get(MOV_CARTACEI), '\n');
FOR_EACH_STR_TOKEN(cartacei, s)
{
TFilename file(s);
if (file.exist())
mov_i.documenti_allegati().add(file);
else
mov_i.set_err(format(FR("Non e' stato possibile reperire il file cartaceo %s per questo movimento."), (const char *) file), mov_no_filecart);
}
copy_file_to_webapp_fld(mov_i); copy_file_to_webapp_fld(mov_i);
} }
} }
ok &= mov_i.no_err(); ok &= mov_i.no_err();
} }
@ -1048,6 +1095,7 @@ result_estr TEstrazione::estrai()
// Se non c'e' nessun movimento non sto nemmeno a scrivere il record di estrazione. // Se non c'e' nessun movimento non sto nemmeno a scrivere il record di estrazione.
// Se estrazione definitiva controllo che il periodo non si sovrapponga alle altre estrazioni def. // Se estrazione definitiva controllo che il periodo non si sovrapponga alle altre estrazioni def.
// Do' errore ed esco subito. // Do' errore ed esco subito.
result_estr res = estr_ok;
if (_movs.empty()) if (_movs.empty())
{ {
warning_box("Non esistono movimenti estraibili per il periodo selezionato."); warning_box("Non esistono movimenti estraibili per il periodo selezionato.");
@ -1086,9 +1134,11 @@ result_estr TEstrazione::estrai()
// Scrivo record estrazione (in stato '01': in diagnostica). // Scrivo record estrazione (in stato '01': in diagnostica).
const bool ok = insert_into_drd(); const bool ok = insert_into_drd();
if (!ok) if (!ok)
{ {
TString msg; TString msg;
msg << "Errore database: impossibile scrivere nuova estrazione.\n" msg << "Errore database: impossibile scrivere nuova estrazione.\n"
<< fp_db().sq_get_text_error(false); << fp_db().sq_get_text_error(false);
error_box(msg); error_box(msg);
@ -1106,16 +1156,18 @@ result_estr TEstrazione::estrai()
// Se in errore, esporto lista errori sul db // Se in errore, esporto lista errori sul db
if (!export_error_list()) if (!export_error_list())
warning_box("Errore scrittura db. Controllare log errori."); warning_box("Errore scrittura db. Controllare log errori.");
update_drd_stato_estr(); res = estr_diag_err; // Errore diagnostica gestionale
return estr_diag_err; // Errore diagnostica gestionale
} }
// Se va tutto ben fino a qui, posso andare a scrivere nella // Se va tutto ben fino a qui, posso andare a scrivere nella
// tabella IVA i movimenti. F9IVA // tabella IVA i movimenti. F9IVA
const result_estr res = estrazione_iva() ? estr_ok : estr_err_db_iva; if (res == estr_ok)
if (res == estr_err_db_iva) {
_head.stato_estr = D_GEST_ERR; res = estrazione_iva() ? estr_ok : estr_err_db_iva;
update_drd_stato_estr(); if (res == estr_err_db_iva)
_head.stato_estr = D_GEST_ERR;
}
update_drd_stato_estr();
return res; return res;
} }
@ -1129,18 +1181,10 @@ bool TEstrazione::estrazione_iva(bool escluso)
FOR_EACH_ARRAY_ITEM(_movs, r, obj) FOR_EACH_ARRAY_ITEM(_movs, r, obj)
{ {
TMovimento_estr & mov_i = (TMovimento_estr &)*obj; TMovimento_estr & mov_i = (TMovimento_estr &)*obj;
const TRectype& mov = cache().get(LF_MOV, mov_i.numreg());
const TCausale caus(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year());
bool harambe = caus.escludi2archiviazione(); if (bar.add_status() && mov_i.estratto())
if (caus.escludi2archiviazione()) {
int siamodentro = 0;
}
if (bar.add_status() && mov_i.estratto() && !caus.escludi2archiviazione())
{ {
const TRectype& mov = cache().get(LF_MOV, mov_i.numreg());
TToken_string key = mov.get(MOV_TIPO); TToken_string key = mov.get(MOV_TIPO);
key.add(mov.get(MOV_CODCF)); key.add(mov.get(MOV_CODCF));
@ -1169,32 +1213,27 @@ 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, mov_i.catdoc(categorie_doc())->catdoc(), 10);
const TClasse_doc* catdoc = mov_i.catdoc(categorie_doc());
if (catdoc != nullptr)
iva_query.add(IVA_CATDOC, catdoc->catdoc(), 10);
const TRegistro& reg = cached_registro(mov.get(MOV_REG), mov.get_int(MOV_ANNOIVA)); const TRegistro& reg = cached_registro(mov.get(MOV_REG), mov.get_int(MOV_ANNOIVA));
if (reg.iva() == iva_vendite) if (reg.iva() == iva_vendite)
{ {
const int anno_doc = mov.get_int(MOV_DANNO); int anno = mov.get_int(MOV_DANNO);
if (anno_doc > 0) if (anno > 0)
{ {
const char provv = mov.get(MOV_DPROVV)[0]; const char provv = mov.get(MOV_DPROVV)[0];
const TString& codnum = mov.get(MOV_DCODNUM); const TString& codnum = mov.get(MOV_DCODNUM);
const long ndoc = mov.get_long(MOV_DNDOC); const long ndoc = mov.get_long(MOV_DNDOC);
TDocumento doc(provv, anno_doc, codnum, ndoc); TDocumento doc(provv, anno, codnum, ndoc);
iva_query.add(IVA_CAUSSOS, tipo_doc_sdi(doc) , 6); iva_query.add(IVA_CAUSSOS, tipo_doc_sdi(doc) , 6);
} }
else else
if(catdoc!=nullptr) iva_query.add(IVA_CAUSSOS, mov_i.catdoc(categorie_doc())->caus_sost(), 6);
iva_query.add(IVA_CAUSSOS, catdoc->caus_sost(), 6);
} }
//
else else
{ {
TToken_string key(mov.get((MOV_KEYFPPRO)), ';'); TToken_string key(mov.get((MOV_KEYFPPRO)), ';');
@ -1207,12 +1246,10 @@ bool TEstrazione::estrazione_iva(bool escluso)
if(tipodoc.full()) if(tipodoc.full())
iva_query.add(IVA_CAUSSOS, tipodoc, 6); iva_query.add(IVA_CAUSSOS, tipodoc, 6);
else else
if (catdoc != nullptr) iva_query.add(IVA_CAUSSOS, mov_i.catdoc(categorie_doc())->caus_sost(), 6);
iva_query.add(IVA_CAUSSOS, catdoc->caus_sost(), 6);
} }
else else
if (catdoc != nullptr) iva_query.add(IVA_CAUSSOS, mov_i.catdoc(categorie_doc())->caus_sost(), 6);
iva_query.add(IVA_CAUSSOS, catdoc->caus_sost(), 6);
} }
iva_query.add(IVA_NUMDOC, mov_i.numdoc(), 20); iva_query.add(IVA_NUMDOC, mov_i.numdoc(), 20);
iva_query.add(IVA_DATADOC, datadoc); iva_query.add(IVA_DATADOC, datadoc);
@ -1221,66 +1258,67 @@ bool TEstrazione::estrazione_iva(bool escluso)
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);
if (catdoc != nullptr) /*if(is_autofattura(mov))
iva_query.add(IVA_CLASDOC, catdoc->class_sost(), 10); {
iva_query.add(IVA_FORNOR, "");
iva_query.add(IVA_REGOR, "");
iva_query.add(IVA_NUMOR, N ORI);
iva_query.add(IVA_DATAOR, TDate(20010101));
}*/
iva_query.add(IVA_NOMFD, mov_i.nomefilecart().name(), 100); iva_query.add(IVA_CLASDOC, mov_i.catdoc(categorie_doc())->class_sost(), 10);
iva_query.add(IVA_NOMFD, mov_i.nomefiledoc().name(), 100);
// Load annessi... // Load annessi...
if(!mov_i.annessi().empty()) if(mov_i.allegati())
{ {
TArray & ann = mov_i.annessi(); TString_array & docs = mov_i.documenti_allegati();
int i = 0; int i = 0;
const int size = ann.items(); const int size = docs.items();
iva_query.add(IVA_CLASAN1, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN1, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF1, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF1, docs.row(i++).get(0), 100);
// HOW DID MY LIFE COME TO THIS?... // HOW DID MY LIFE COME TO THIS?...
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN2, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN2, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF2, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF2, docs.row(i++).get(0), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN3, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN3, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF3, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF3, docs.row(i++).get(0), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN4, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN4, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF4, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF4, docs.row(i++).get(0), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN5, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN5, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF5, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF5, docs.row(i++).get(0), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN4, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN6, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF4, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF6, docs.row(i++).get(0), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN6, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN7, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF6, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF7, docs.row(i++).get(0), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN7, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN8, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF7, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF8, docs.row(i++), 100);
} }
if (size > i) if (size > i)
{ {
iva_query.add(IVA_CLASAN8, ((TAnnesso_mov &)ann[i]).catdocann(), 10); iva_query.add(IVA_CLASAN9, docs.row(i).get(2), 10);
iva_query.add(IVA_NOMF8, ((TAnnesso_mov &)ann[i++]).filename(), 100); iva_query.add(IVA_NOMF9, docs.row(i++).get(0), 100);
} }
if (size > i)
{
iva_query.add(IVA_CLASAN9, ((TAnnesso_mov &)ann[i]).catdocann(), 10);
iva_query.add(IVA_NOMF9, ((TAnnesso_mov &)ann[i++]).filename(), 100);
}
} }
iva_query.add(IVA_USERELA, user(), 10); iva_query.add(IVA_USERELA, user(), 10);
@ -1342,8 +1380,8 @@ void TEstrazione::set_dates()
} }
TEstrazione::TEstrazione(const TString& ambiente, const bool flag_prov, const char tipodoc, const TString& descr, TEstrazione::TEstrazione(const TString& ambiente, const bool flag_prov, const char tipodoc, const TString& descr,
const TString& addrcart, const bool escluso, TFilename& spotlite_path, const TDate* const dal, const TDate* const al, const bool has_cartacei) const TString& addrcart, const bool escluso, TFilename& spotlite_path, TLog_report * log, const TDate* const dal, const TDate* const al, const bool has_cartacei)
: _descr(descr), _has_cartacei(has_cartacei), _spotlite_path(spotlite_path) : _descr(descr), _has_cartacei(has_cartacei), _spotlite_path(spotlite_path), _log(log)
{ {
_head.cod_soc = ambiente; _head.cod_soc = ambiente;
_head.flag_prov = flag_prov; _head.flag_prov = flag_prov;
@ -1357,12 +1395,6 @@ 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 = new ofstream("f9_TEstrazione_error_sql.txt");
// Svuoto log.
ofstream f("TF9Prospetto_integr_error.txt");
f << "\n";
} }
@ -1382,14 +1414,10 @@ void TF9_dberr::add_str(const TString& string)
void TF9_dberr::write_sqlerrlog(const TString& query) const void TF9_dberr::write_sqlerrlog(const TString& query) const
{ {
if (_fout->is_open()) _log->log_error(query);
{ _log->log_error(fp_db().sq_get_string_error());
TString msg; _log->log_error(fp_db().sq_get_text_error());
msg << query << "\n" << _log->line();
fp_db().sq_get_string_error() << "\n" <<
fp_db().sq_get_text_error();
*_fout << msg << "\n";
}
} }
void TF9_dberr::add(const TString& string) void TF9_dberr::add(const TString& string)
@ -1443,22 +1471,25 @@ bool TF9_dberr::send()
return ok; return ok;
} }
bool TF9_dberr::del_err(const TString& codsoc, const TString& id_estr, const int numreg) bool dberr_del_err(const TString& codsoc, const TString& id_estr, const int numreg)
{ {
TString query; TString query;
query << "DELETE FROM " F9_ERR query << "DELETE FROM " F9_ERR
"\nWHERE " ERR_CODSOC " = '" << codsoc << "'" "\nWHERE " ERR_CODSOC " = '" << codsoc << "'"
"\nAND " ERR_IDESTR " = '" << id_estr << "' AND " ERR_NUMREG " = '" << numreg << "';"; "\nAND " ERR_IDESTR " = '" << id_estr << "' AND " ERR_NUMREG " = '" << numreg << "';";
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, TArray& controllo_mov) char dberr_get_err(const TString& codsoc, const TString& id_estr, TArray& controllo_mov)
{ {
TString query; TString query;
query << "SELECT * FROM " F9_ERR query << "SELECT * FROM " F9_ERR
"\nWHERE " ERR_CODSOC " = '" << codsoc << "' AND " "\nWHERE " ERR_CODSOC " = '" << codsoc << "' AND "
ERR_IDESTR " = '" << id_estr << "';"; ERR_IDESTR " = '" << id_estr << "';";
fp_db().sq_set_exec(query, false); fp_db().sq_set_exec(query, false);
controllo_mov.destroy();
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())
{ {
TToken_string row("", '|'); TToken_string row("", '|');
@ -1479,7 +1510,7 @@ char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, TArray
return fp_db().sq_get((unsigned)0)[0]; return fp_db().sq_get((unsigned)0)[0];
} }
TF9_dberr::TF9_dberr() TF9_dberr::TF9_dberr(TLog_report * log) : _log(log)
{ {
_insert.cut(0) << "INSERT INTO " F9_ERR " (" _insert.cut(0) << "INSERT INTO " F9_ERR " ("
ERR_CODSOC ", " ERR_CODSOC ", "
@ -1496,8 +1527,6 @@ TF9_dberr::TF9_dberr()
ERR_PROTIVA ", " ERR_PROTIVA ", "
ERR_DESCR ", " ERR_DESCR ", "
ERR_DESCERR ") VALUES ()"; ERR_DESCERR ") VALUES ()";
_fout = new ofstream;
_fout->open("f9_dberr.txt");
} }
; ;
TString _user; TString _user;

110
src/f9/f9lib02.cpp
View File

@ -100,10 +100,21 @@ bool TF9_doccart::add_cart(const TFilename& file, long numreg, const bool is_ann
"Se si tratta di un annesso inserire le informazioni per la cat. documentale.", (const char*)numreg, (const char*)doc); "Se si tratta di un annesso inserire le informazioni per la cat. documentale.", (const char*)numreg, (const char*)doc);
return false; return false;
} }
f9docs.zero();
f9docs.put(F9C_NUMREG, numreg);
f9docs.put(F9C_NRIG, 9);
f9docs.read();
if (f9docs.get_long(F9C_NUMREG) != numreg)
f9docs.prev();
int nrig = 1;
if (f9docs.get_long(F9C_NUMREG) == numreg)
nrig += f9docs.get_long(F9C_NRIG);
f9docs.zero(); f9docs.zero();
f9docs.put(F9C_FILENAME, file.name()); f9docs.put(F9C_FILENAME, file.name());
f9docs.put(F9C_NUMREG, numreg); f9docs.put(F9C_NUMREG, numreg);
f9docs.put(F9C_NRIG, nrig);
f9docs.put(F9C_LOADDATE, TDate(TODAY)); f9docs.put(F9C_LOADDATE, TDate(TODAY));
f9docs.put(F9C_USER, user()); f9docs.put(F9C_USER, user());
} }
@ -154,39 +165,27 @@ bool TF9_doccart::add_cart(const TFilename& file, long numreg, const bool is_ann
return false; return false;
} }
if (!is_annesso) if (!is_annesso)
{ f9docs.write_rewrite();
f9docs.write();
f9docs.rewrite();
}
else else
{ f9annessi.write_rewrite();
f9annessi.write();
f9annessi.rewrite();
}
return true; return true;
} }
bool TF9_doccart::doc_already_exists(const TFilename& file, long& numreg, bool& annesso) bool TF9_doccart::doc_already_exists(const TFilename& file, long& numreg, bool& annesso)
{ {
const TRectype & docs_cart = cache().get(LF_F9DOCS, file.name(), 2);
bool ok = docs_cart.full();
annesso = false; annesso = false;
const TRectype & tdocs = cache().get(LF_F9DOCS, file.name(), 2);
bool ok = tdocs.full();
if (ok) if (ok)
numreg = tdocs.get_long(F9C_NUMREG); numreg = docs_cart.get_long(F9C_NUMREG);
else else
{ {
numreg = 0L; const TRectype & annessi = cache().get(LF_F9ANNESSI, file.name(), 2);
_tannessi.zero();
_tannessi.setkey(2); ok = annesso = annessi.full();
_tannessi.put(F9A_FILENAME, file.name());
ok = _tannessi.read() == NOERR;
if (ok) if (ok)
{ numreg = annessi.get_long(F9A_NUMREG);
numreg = _tannessi.get_long(F9A_NUMREG);
annesso = true;
}
} }
return ok; return ok;
} }
@ -202,64 +201,54 @@ bool TF9_doccart::mov2doc(long numreg, TFilename& doc)
return ok; return ok;
} }
bool TF9_doccart::mov2listann(const TString& numreg, _Out_ TString_array& list_annessi) bool doc_already_exists(const TFilename& file, long& numreg)
{ {
list_annessi.destroy(); const TRectype & annessi = cache().get(LF_F9ANNESSI, file.name(), 2);
_tannessi.zero(); bool ok = annessi.full();
_tannessi.setkey(1);
_tannessi.put(F9A_NUMREG, numreg);
TString numreg_fetched; if (ok)
bool ok = false; numreg = annessi.get_long(F9A_NUMREG);
// Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta.
for (_tannessi.read(_isgteq); (numreg_fetched = _tannessi.get(F9A_NUMREG)) == numreg; _tannessi.next())
{
ok = true;
TString filename = _tannessi.get(F9A_FILENAME);
TToken_string t;
t.add(numreg_fetched);
t.add(_tannessi.get(F9A_FILENAME));
t.add(_tannessi.get(F9A_CATDOCPAD));
t.add(_tannessi.get(F9A_CATDOCANN));
t.add(_tannessi.get(F9A_LOADDATE));
t.add(_tannessi.get(F9A_USER));
list_annessi.add(t);
#ifdef DBG
CHECK(numreg_fetched == numreg_fetched, "*Maledetooo*");
#endif
}
return ok; return ok;
} }
bool TF9_doccart::mov2listann_vect(const long numreg, TArray & list_annessi) bool TF9_doccart::mov2listann_vect(const long numreg, TArray & list_annessi)
{ {
list_annessi.destroy(); list_annessi.destroy();
_tannessi.zero();
_tannessi.setkey(1); TLocalisamfile annessi(LF_F9ANNESSI);
_tannessi.put(F9A_NUMREG, numreg);
annessi.put(F9A_NUMREG, numreg);
bool ok = false; bool ok = false;
// Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta. // Si posiziona nl primo record giusto. Poi per sapere quando terminare guardo se la chiave e' ancora quella giusta.
for (int err = _tannessi.read(_isgteq) == NOERR; err == NOERR; err = _tannessi.next()) for (int err = annessi.read(_isgteq) == NOERR; err == NOERR; err = annessi.next())
{ {
long numreg_fetched = _tannessi.get_long(F9A_NUMREG); long numreg_fetched = annessi.get_long(F9A_NUMREG);
if (numreg_fetched == numreg) if (numreg_fetched == numreg)
{ {
ok = true; ok = true;
TString filename = _tannessi.get(F9A_FILENAME); TString filename = annessi.get(F9A_FILENAME);
TAnnesso_mov t(numreg_fetched, _tannessi.get(F9A_FILENAME), _tannessi.get(F9A_CATDOCPAD), TAnnesso_mov t(numreg_fetched, annessi.get(F9A_FILENAME), annessi.get(F9A_CATDOCPAD),
_tannessi.get(F9A_CATDOCANN), _tannessi.get_date(F9A_LOADDATE), _tannessi.get(F9A_USER)); annessi.get(F9A_CATDOCANN), annessi.get_date(F9A_LOADDATE), annessi.get(F9A_USER));
list_annessi.add(t); list_annessi.add(t);
} }
else else
break; break;
} }
return ok; return ok;
} }
const TString & get_full_path_file_cartaceo(const TString& filename)
{
TFilename name = (F9CONF.get_addr_cart());
name = name.make_absolute_path();
name.add(filename);
return get_tmp_string() = name;
}
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// TIva_insert_prepared_stat // TIva_insert_prepared_stat
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -362,10 +351,11 @@ void TProspetto_recset::precarica_tabelle()
} }
} }
void TProspetto_recset::get_sum_imponibile_imposta(const char* numreg_ven, real& s_imponibili, real& s_imposte) void TProspetto_recset::get_sum_imponibile_imposta(long numreg_ven, real& s_imponibili, real& s_imposte)
{ {
TRecord_array iva(LF_RMOVIVA, RMI_NUMRIG); TRecord_array iva(LF_RMOVIVA, RMI_NUMRIG);
TRectype* ivafilter = new TRectype(LF_RMOVIVA); TRectype* ivafilter = new TRectype(LF_RMOVIVA);
ivafilter->put(RMI_NUMREG, numreg_ven); ivafilter->put(RMI_NUMREG, numreg_ven);
iva.read(ivafilter); iva.read(ivafilter);
s_imponibili = ZERO; s_imponibili = ZERO;
@ -373,12 +363,13 @@ void TProspetto_recset::get_sum_imponibile_imposta(const char* numreg_ven, real&
for (int i = iva.first_row(); i <= iva.rows(); ++i) for (int i = iva.first_row(); i <= iva.rows(); ++i)
{ {
TRectype& r = iva[i]; TRectype& r = iva[i];
s_imponibili += r.get_real("IMPONIBILE"); s_imponibili += r.get_real("IMPONIBILE");
s_imposte += r.get_real("IMPOSTA"); s_imposte += r.get_real("IMPOSTA");
} }
} }
TProspetto_recset::TProspetto_recset(const char* numreg_acq, const char* numreg_ven) : TSQL_recordset("") TProspetto_recset::TProspetto_recset(long numreg_acq, long numreg_ven) : TSQL_recordset("")
{ {
_numreg = new TString; _numreg = new TString;
_today = new TString; _today = new TString;
@ -408,6 +399,7 @@ TProspetto_recset::TProspetto_recset(const char* numreg_acq, const char* numreg_
precarica_tabelle(); precarica_tabelle();
TLocalisamfile anagraf(LF_ANAG), clifo(LF_CLIFO), comuni(LF_COMUNI), mov_acq(LF_MOV), mov_ven(LF_MOV), rmoviva(LF_RMOVIVA); TLocalisamfile anagraf(LF_ANAG), clifo(LF_CLIFO), comuni(LF_COMUNI), mov_acq(LF_MOV), mov_ven(LF_MOV), rmoviva(LF_RMOVIVA);
mov_acq.put(MOV_NUMREG, numreg_acq); mov_acq.put(MOV_NUMREG, numreg_acq);
mov_acq.read(); mov_acq.read();
anagraf.put(ANA_TIPOA, "G"); anagraf.put(ANA_TIPOA, "G");
@ -573,12 +565,12 @@ bool TF9Prospetto_integr::preview()
return _book.preview(); return _book.preview();
} }
bool TF9Prospetto_integr::operator()(const char* numreg_acq, const char* numreg_ven) bool TF9Prospetto_integr::operator()(long numreg_acq, long numreg_ven)
{ {
if (_rep.load(_f_report)) if (_rep.load(_f_report))
{ {
TFilename fprosp; fprosp.tempdir().slash_terminate() << make_name_rep(); TFilename fprosp; fprosp.tempdir().slash_terminate() << make_name_rep();
TProspetto_recset* _prosp_rs = new TProspetto_recset(numreg_acq, numreg_ven); TProspetto_recset * _prosp_rs = new TProspetto_recset(numreg_acq, numreg_ven);
_items = _prosp_rs->items(); _items = _prosp_rs->items();
if (_items == 0) if (_items == 0)

2
src/include/automask.h
View File

@ -1,7 +1,7 @@
#ifndef __AUTOMASK_H #ifndef __AUTOMASK_H
#define __AUTOMASK_H #define __AUTOMASK_H
#ifndef __DEFMASK_H #ifndef __DEFMASK_Hautomask
#include <defmask.h> #include <defmask.h>
#endif #endif

21
src/include/golem.cpp
View File

@ -73,6 +73,18 @@ bool print_url(const char* url)
return ok; return ok;
} }
const TString & get_golem_path(long ditta)
{
TFilename golem_path;
if (ditta < 0)
ditta = prefix().get_codditta();
golem_path = firm2dir(ditta);
golem_path.add("golem");
if (!dexist(golem_path))
make_dir(golem_path);
return get_tmp_string() = golem_path;
}
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Maschera GOLEM // Maschera GOLEM
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
@ -452,12 +464,7 @@ bool TGolem_field::autosave(TRelation& r)
const int logicnum = r.lfile().num(); const int logicnum = r.lfile().num();
dir.get(logicnum, _nolock, _nordir, _sysdirop); dir.get(logicnum, _nolock, _nordir, _sysdirop);
const long ditta = dir.is_com() ? 0 : prefix().get_codditta(); const long ditta = dir.is_com() ? 0 : prefix().get_codditta();
const TFilename golem_path = get_golem_path(ditta);
TFilename golem_path;
golem_path = firm2dir(ditta);
golem_path.add("golem");
if (!dexist(golem_path))
make_dir(golem_path);
const int old_items = _old_value.items(); const int old_items = _old_value.items();
const int new_items = new_value.items(); const int new_items = new_value.items();
@ -506,6 +513,8 @@ bool TGolem_field::autosave(TRelation& r)
} }
fcopy(new_file, old_file); fcopy(new_file, old_file);
if (old_file.starts_with(golem_path))
old_file = old_file.mid(golem_path.len());
new_row.add(old_file, 0); new_row.add(old_file, 0);
new_value.add(new_row, i); new_value.add(new_row, i);

2
src/include/golem.h
View File

@ -15,6 +15,8 @@ bool print_url(const char* url);
class TMAPI_session; class TMAPI_session;
const TString & get_golem_path(long ditta);
class TMail_message : public TString_array class TMail_message : public TString_array
{ {
TString_array _recipients, _copy_recipients, _attachments; TString_array _recipients, _copy_recipients, _attachments;

19
src/include/msksheet.cpp
View File

@ -337,9 +337,9 @@ public:
// @cmember Modifica a video la riga // @cmember Modifica a video la riga
void update(int row); void update(int row);
// @cmember Ritorna la disabilitazione della colonna <p col> // @cmember Ritorna la disabilitazione della colonna <p col>
bool column_disabled(int col) const { return _column_disabled[col]; } bool column_disabled(int col) const;
// @cmember Ritorna l' abilitazione della colonna <p col> // @cmember Ritorna l' abilitazione della colonna <p col>
bool column_enabled(int col) const { return !column_disabled(col); } bool column_enabled(int col) const;
// @cmember Ritorna il contenuto della riga <p n>-esima // @cmember Ritorna il contenuto della riga <p n>-esima
TToken_string& row(int n) { return _str.row(n); } TToken_string& row(int n) { return _str.row(n); }
@ -1065,6 +1065,21 @@ bool TSpreadsheet::destroy(
return ok; return ok;
} }
bool TSpreadsheet::column_disabled(int col) const
{
if (col >= FIRST_FIELD)
col = cid2index(col);
return _column_disabled[col];
}
bool TSpreadsheet::column_enabled(int col) const
{
if (col >= FIRST_FIELD)
col = cid2index(col);
return !column_disabled(col);
}
// @doc INTERNAL // @doc INTERNAL
// @mfunc Modifica a video la riga // @mfunc Modifica a video la riga

59
src/include/tsdb.cpp
View File

@ -7,32 +7,58 @@
* Classe per esecuzioni di query temporanee (wrapper semplice per SACommand) * * Classe per esecuzioni di query temporanee (wrapper semplice per SACommand) *
******************************************************************************/ ******************************************************************************/
const bool SSimple_query::sq_set_exec(const char* query, const bool auto_f)
{
bool ok = false;
if (sq_is_connect())
{
ok = _rec.set(query);
if (ok)
_rec.exec(auto_f);
}
return ok;
}
const TDate SSimple_query::sq_get_date(const char * field) const TDate SSimple_query::sq_get_date(const char * field)
{ {
TDate date(_rec.get_date(field)); TDate date;
if(!date.ok() || date == 19000100)
if (sq_is_connect())
{ {
TString dt_str = _rec.get(field); date = _rec.get_date(field);
if (dt_str.len() > 10)
dt_str = dt_str.left(10); if (!date.ok() || date == 19000100)
date = dt_str; {
TString dt_str = _rec.get(field);
if (dt_str.len() > 10)
dt_str = dt_str.left(10);
date = dt_str;
}
} }
return date; return date;
} }
const real SSimple_query::sq_get_real(const char * field) const real SSimple_query::sq_get_real(const char * field)
{ {
const real app(_rec.get(field)); real r;
return app;
if (sq_is_connect())
r = _rec.get(field);
return r;
} }
const TString & SSimple_query::sq_get(const char* field, const bool rtrim) const TString & SSimple_query::sq_get(const char* field, const bool rtrim)
{ {
TString & fld = get_tmp_string(1024); TString & fld = get_tmp_string(1024);
fld = _rec.get(field); if (sq_is_connect())
if (rtrim) {
fld.rtrim(); fld = _rec.get(field);
if (rtrim)
fld.rtrim();
}
return fld; return fld;
} }
@ -51,15 +77,18 @@ const TString & SSimple_query::sq_get(unsigned int column, const bool rtrim)
{ {
TString & val = get_tmp_string(1024); TString & val = get_tmp_string(1024);
val << _rec.get(column); if (sq_is_connect())
if (rtrim) {
val.rtrim(); val << _rec.get(column);
if (rtrim)
val.rtrim();
}
return val; return val;
} }
unsigned SSimple_query::sq_get_num_fields() const unsigned SSimple_query::sq_get_num_fields() const
{ {
return _rec.get_num_fields(); return sq_is_connect() ? _rec.get_num_fields() : 0;
} }
const TString & SSimple_query::sq_get_name_field(const unsigned column) const const TString & SSimple_query::sq_get_name_field(const unsigned column) const

69
src/include/tsdb.h
View File

@ -1,30 +1,3 @@
/**********************************************************************************
* ######\ *
* ## __##\ *
* ## / \__| ######\ ######\####\ ######\ ######\ *
* ## | \____##\ ## _## _##\ ## __##\ ## __##\ *
* ## | ####### |## / ## / ## |## / ## |## / ## | *
* ## | ##\ ## __## |## | ## | ## |## | ## |## | ## | *
* \###### |\####### |## | ## | ## |####### |\###### | *
* \______/ \_______|\__| \__| \__|## ____/ \______/ *
* ## | *
* ## | *
* \__| *
**********************************************************************************/
/********************************************************************************************************************************
* TSDB.H *
* Inizio sviluppo: 13.10.2016 *
* Autore: Tolla *
* Descrizione: *
* La seguente libreria ha due scopi: *
* - Implementare una serie di funzioni che emulino interamente il funzionamento attuale di campo in Visual FoxPro su MSQL *
* - Creare delle nuove API per gestire il database in MSSQL con cui verranno riscritti i programmi *
* Librerie esterne utilizzate: *
* - SQLAPI++ (Permette la gestione dei più famosi DB attualmente esistenti) *
********************************************************************************************************************************/
#ifndef __TSDB_H #ifndef __TSDB_H
#define __TSDB_H #define __TSDB_H
@ -51,12 +24,6 @@
#include "recset.h" #include "recset.h"
/********************************************************************************
* SSimpleQuery (Sirio Simple Query) *
* "Wrapper" di TXvt_recordset, implementa OGNI funzione in modo tale da *
* poterlo sostituire brutalmente in qualsiasi momento così da non aver *
* problemi come durante il passaggio da ISAM a SQL (spero). che cazzata da riscrivere *
********************************************************************************/
class SSimple_query class SSimple_query
{ {
protected: protected:
@ -108,44 +75,44 @@ public:
// Configuration // Configuration
/**< Imposta la query ricevuta come (const char *) nel recordset */ /**< Imposta la query ricevuta come (const char *) nel recordset */
const bool sq_set(const char* query) { return _rec.set(query); } const bool sq_set(const char* query) { return sq_is_connect() && _rec.set(query); }
/**< Imposta la query ricevuta come (string) nel recordset */ /**< Imposta la query ricevuta come (string) nel recordset */
const bool sq_set(const string& query) { return _rec.set(query.c_str()); } const bool sq_set(const string& query) { return sq_is_connect() && _rec.set(query.c_str()); }
/**< Imposta la query ricevuta come (TString) nel recordset */ /**< Imposta la query ricevuta come (TString) nel recordset */
const bool sq_set(TString& query) { return _rec.set(static_cast<const char *>(query)); } const bool sq_set(TString& query) { return sq_is_connect() && _rec.set(static_cast<const char *>(query)); }
/**< Esegue la query impostata nel recordset, se viene passato autoF == true esegue anche un comando sqNext() */ /**< Esegue la query impostata nel recordset, se viene passato autoF == true esegue anche un comando sqNext() */
const bool sq_exec(bool autoF = true) { return _rec.exec(autoF); } const bool sq_exec(bool autoF = true) { return sq_is_connect() && _rec.exec(autoF); }
/**< Unisce le funzioni sqSet e sqExec, riceve la query come (const char *) */ /**< Unisce le funzioni sqSet e sqExec, riceve la query come (const char *) */
const bool sq_set_exec(const char* query, const bool auto_f = true) { _rec.set(query); return _rec.exec(auto_f); } const bool sq_set_exec(const char* query, const bool auto_f = true);
/**< Unisce le funzioni sqSet e sqExec, riceve la query come (string) */ /**< Unisce le funzioni sqSet e sqExec, riceve la query come (string) */
const bool sq_set_exec(const string& query, const bool auto_f = true) { _rec.set(query.c_str()); return _rec.exec(auto_f); } const bool sq_set_exec(const string& query, const bool auto_f = true) { _rec.set(query.c_str()); return _rec.exec(auto_f); }
/**< Unisce le funzioni sqSet e sqExec, riceve la query come (TString) */ /**< Unisce le funzioni sqSet e sqExec, riceve la query come (TString) */
const bool sq_set_exec(TString& query, const bool auto_f = true) { return sq_set_exec(static_cast<const char*>(query), auto_f); } const bool sq_set_exec(TString& query, const bool auto_f = true) { return sq_set_exec(static_cast<const char*>(query), auto_f); }
/**< Si sposta avanti di un record, in caso di esito negativo valorizza _stringError e _codeError */ /**< Si sposta avanti di un record, in caso di esito negativo valorizza _stringError e _codeError */
const bool sq_next() { return _rec.next(); } const bool sq_next() { return sq_is_connect() && _rec.next(); }
/**< Si sposta indietro di un record, in caso di esito negativo valorizza _stringError e _codeError */ /**< Si sposta indietro di un record, in caso di esito negativo valorizza _stringError e _codeError */
const bool sq_prev() { return _rec.prev(); } const bool sq_prev() { return sq_is_connect() && _rec.prev(); }
/**< Si sposta al primo record, in caso di esito negativo valorizza _stringError e _codeError */ /**< Si sposta al primo record, in caso di esito negativo valorizza _stringError e _codeError */
const bool sq_first() { return _rec.first(); } const bool sq_first() { return sq_is_connect() && _rec.first(); }
/**< Si sposta all'ultimo record, in caso di esito negativo valorizza _stringError e _codeError */ /**< Si sposta all'ultimo record, in caso di esito negativo valorizza _stringError e _codeError */
const bool sq_last() { return _rec.last(); } const bool sq_last() { return sq_is_connect() && _rec.last(); }
/**< Si sposta alla posizione n, in caso di esito negativo valorizza _stringError e _codeError */ /**< Si sposta alla posizione n, in caso di esito negativo valorizza _stringError e _codeError */
const bool sq_go(const int new_pos) { return _rec.go(new_pos); } const bool sq_go(const int new_pos) { return sq_is_connect() && _rec.go(new_pos); }
/**< Ritorna il numero di righe affette dall'ultima query */ /**< Ritorna il numero di righe affette dall'ultima query */
const int sq_rows_affected() const { return _rec.rows_affected(); } const int sq_rows_affected() const { return sq_is_connect() ? _rec.rows_affected() : 0; }
// Getters // Getters
/**< Ritorna il valore nel campo (field) in formato (int) */ /**< Ritorna il valore nel campo (field) in formato (int) */
const int sq_get_int(const char* field) { return _rec.get_int(field); } const int sq_get_int(const char* field) { return sq_is_connect() ? _rec.get_int(field) : 0; }
/**< Ritorna il valore nel campo (field) in formato (short) */ /**< Ritorna il valore nel campo (field) in formato (short) */
const short sq_get_short(const char* field) { return _rec.get_short(field); } const short sq_get_short(const char* field) { return sq_is_connect() ? _rec.get_short(field) : 0; }
/**< Ritorna il valore nel campo (field) in formato (long) */ /**< Ritorna il valore nel campo (field) in formato (long) */
const long sq_get_long(const char* field) { return _rec.get_long(field); } const long sq_get_long(const char* field) { return sq_is_connect() ? _rec.get_long(field) : 0L; }
/**< Ritorna il valore nel campo (field) in formato (double) */ /**< Ritorna il valore nel campo (field) in formato (double) */
const double sq_get_double(const char* field) { return _rec.get_double(field); } const double sq_get_double(const char* field) { return sq_is_connect() ? _rec.get_double(field) : 0.0; }
/**< Ritorna il valore nel campo (field) in formato (bool) */ /**< Ritorna il valore nel campo (field) in formato (bool) */
const bool sq_get_bool(const char* field) { return _rec.get_bool(field); } const bool sq_get_bool(const char* field) { return sq_is_connect() && _rec.get_bool(field); }
/**< Ritorna il valore nel campo (field) in formato (TDate) */ /**< Ritorna il valore nel campo (field) in formato (TDate) */
const TDate sq_get_date(const char* field); const TDate sq_get_date(const char* field);
/**< Ritorna il valore nel campo (field) in formato (real) */ /**< Ritorna il valore nel campo (field) in formato (real) */
@ -161,7 +128,7 @@ public:
/**< Ritorna il valore della colonna numero (column) passato come (unsigned int) */ /**< Ritorna il valore della colonna numero (column) passato come (unsigned int) */
const TString & sq_get(unsigned int column, bool rtrim = true); const TString & sq_get(unsigned int column, bool rtrim = true);
/**< Ritorna il valore nel campo (field) in formato (char) */ /**< Ritorna il valore nel campo (field) in formato (char) */
const char sq_get_char(const char* field) { return _rec.get_char(field); } const char sq_get_char(const char* field) { return sq_is_connect() && _rec.get_char(field); }
/**< Ritorna il numero di campi dopo l'ultimo comando di esecuzione effettuato; se il risultato esiste */ /**< Ritorna il numero di campi dopo l'ultimo comando di esecuzione effettuato; se il risultato esiste */
unsigned int sq_get_num_fields() const; unsigned int sq_get_num_fields() const;
/**< Ritorna il nome del campo numero (column) in formato (TString) = */ /**< Ritorna il nome del campo numero (column) in formato (TString) = */
@ -171,7 +138,7 @@ public:
/**< Ritorna il tipo del campo numero (column) in formato (TFieldtypes) */ /**< Ritorna il tipo del campo numero (column) in formato (TFieldtypes) */
TFieldtypes sq_get_type_field(unsigned column) const; TFieldtypes sq_get_type_field(unsigned column) const;
/**< Ritorna la posizione attuale */ /**< Ritorna la posizione attuale */
const long sq_pos() const { return _rec.pos(); } const long sq_pos() const { return sq_is_connect() ? _rec.pos() : 0; }
// Error Getters // Error Getters
/**< Ritorno l'ultimo codice errore segnalato in formato /int) */ /**< Ritorno l'ultimo codice errore segnalato in formato /int) */