From d0e06a5d6f5ecdceeab27445d61143970cfda325 Mon Sep 17 00:00:00 2001 From: Alessandro Bonazzi Date: Sun, 8 May 2022 23:22:44 +0200 Subject: [PATCH] Patch level : 12.0 nopatch Files correlati : f9 Commento: Iniziata la modifica del modulo f9 per prendere da FPPRO il tipodocsdi --- src/f9/f90100.cpp | 483 +++++++++++++++++--------------------------- src/f9/f90100.h | 35 ++-- src/f9/f9lib.h | 200 +++++++++--------- src/f9/f9lib01.cpp | 490 ++++++++++++++++++++++++++++----------------- src/f9/f9lib02.cpp | 8 +- 5 files changed, 609 insertions(+), 607 deletions(-) diff --git a/src/f9/f90100.cpp b/src/f9/f90100.cpp index 0aaa25fe7..7934f0bec 100644 --- a/src/f9/f90100.cpp +++ b/src/f9/f90100.cpp @@ -1,18 +1,18 @@ -#include +#include +#include +#include +#include +#include +#include -#include "f90.h" -#include "f90100.h" - -#include "lffiles.h" -#include "isam.h" -#include "../f1/f1lib.h" -#include "../fp/fplib.h" -#include "urldefid.h" -#include "progind.h" #include "f901tab.h" #include "f90100b.h" #include "f90100d.h" -#include "sqlset.h" + +#include "../f1/f1lib.h" +#include "../fp/fplib.h" +#include "f90.h" +#include "f90100.h" #include "f90100c.h" /** \file f90100.cpp @@ -31,20 +31,13 @@ // Utilities //////////////////////////////////////////////////////// -// Getters per semplificare i get dai TRecorset - -const TString& recset_get_string(const TRecordset& rec, const char* field, int zero_filled = -1); -int recset_get_int(const TRecordset& rec, const char* field, int zero_filled = -1); -bool recset_get_bool(const TRecordset& rec, const char* field); -real recset_get_real(const TRecordset& rec, const char* field); -TDate recset_get_date(const TRecordset& rec, const char* field); - TMask& descr_msk() { - static std::unique_ptr m = nullptr; + static TMask * m = nullptr; + if (m == nullptr) { - m = std::make_unique("Estrazione", 1, 60, 5); + m = new TMask("Estrazione", 1, 60, 5); m->add_button_tool(DLG_OK, "Conferma", TOOL_OK); m->add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, ""); m->add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40); @@ -54,10 +47,10 @@ TMask& descr_msk() TMask& esclusi_mask() { - static unique_ptr _esclusi_mask = nullptr; + static TMask * _esclusi_mask = nullptr; if (_esclusi_mask == nullptr) { - _esclusi_mask = std::make_unique("f90100c.msk"); + _esclusi_mask = new TMask("f90100c.msk"); TMask& m = *_esclusi_mask; ((TSheet_field&)m.field(S_ESCL)).set_notify(TF9_app::select_escl_notify); // Handler dello sheet per selezione singola m.set_handler(DLG_FINDREC, TF9_app::controllo_escl_handler); // Bottone per aprire maschera di controllo movimenti @@ -71,63 +64,10 @@ TMask& esclusi_mask() return *_esclusi_mask; } -const TString& recset_get_string(const TRecordset& rec, const char* field, const int zero_filled) -{ - const TString& str = rec.get(rec.find_column(field)).as_string(); - if (zero_filled == -1) - return str; - static TString c; - c.cut(0); - const int len = str.len(); - for (int i = len; i < zero_filled; i++) // Sistemo il codcaus per via del TVariant che non restituisce la stringa esattamente come l'originale - c << "0"; - c << str; - return c; -} - -int recset_get_int(const TRecordset& rec, const char* field, const int zero_filled) -{ - return rec.get(rec.find_column(field)).as_int(); -} - -bool recset_get_bool(const TRecordset& rec, const char* field) -{ - return rec.get(rec.find_column(field)).as_bool(); -} - -real recset_get_real(const TRecordset& rec, const char* field) -{ - return rec.get(rec.find_column(field)).as_real(); -} - -TDate recset_get_date(const TRecordset& rec, const char* field) -{ - return rec.get(rec.find_column(field)).as_date(); -} - - //////////////////////////////////////////////////////// // TEstrai_mask //////////////////////////////////////////////////////// -TString TEstrai_mask::get_numdoc_exp_fp(const int numreg) -{ - TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, numreg); - if (mov.read() == NOERR) - { - const TString& dprovv = mov.get(MOV_DPROVV); - const int danno = mov.get_int(MOV_DANNO); - const TString& dcodnum = mov.get(MOV_DCODNUM); - const int dndoc = mov.get_int(MOV_DNDOC); - if (!dprovv.empty() && danno != 0 && !dcodnum.empty() && dndoc != 0) - { - const TDocumento doc(dprovv[0], danno, dcodnum, dndoc); - return complete_num_fp(doc.codice_numerazione(), doc.numero()); - } - } - return ""; -} int TEstrai_mask::estrai() { @@ -135,12 +75,12 @@ int TEstrai_mask::estrai() const TDate dataend = get_dataend(); const char tipodoc = get_tipodoc(); const bool flagpro = is_provviso(); - TFilename path; - f9_app().get_spotlite_path(path); + + f9_app().get_spotlite_path(path); // Vero e proprio oggetto estrazione - _estrazione = make_unique( + _estrazione = new TEstrazione( F9CONF.get_ambiente(), // Codice ambiente flagpro, // Flag prov. tipodoc, // Tipo doc. @@ -167,49 +107,24 @@ int TEstrai_mask::estrai() const TipoIVA tipo = tipodoc == 'A' ? iva_acquisti : iva_vendite; int count = 0; // Prendo tutti i movimenti a partire da una data e li carico tutti fino alla data finale - for (bool ok = mov.move_first(); ok; ok = mov.move_next()) - { - if (!progr->add_status()) - break; - TToken_string elab_f9(recset_get_string(mov, MOV_ELABF9), ';'); // Stringa del campo elaborazione f9 nel file mov - const bool escluso = !(elab_f9.items() == 3 && elab_f9.get(2)[0] != 'X' || elab_f9.empty()); - const TCausale caus(recset_get_string(mov, MOV_CODCAUS, 3), TDate(recset_get_string(mov, MOV_DATAREG)).year()); - const bool stampato = recset_get_bool(mov, MOV_REGST); + for (bool ok = mov.move_first(); progr->add_status() && ok; ok = mov.move_next()) + { + TToken_string elab_f9(mov.get_string(MOV_ELABF9), ';'); // Stringa del campo elaborazione f9 nel file mov + const bool escluso = !(elab_f9.items() == 3 && elab_f9.get_bool(2) || elab_f9.empty()); + const TCausale & caus = cached_causale(mov.get_string(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()); + const bool stampato = mov.get_bool(MOV_REGST); const TRegistro& reg = caus.reg(); const TipoIVA& iva = reg.iva(); - TString numdoc = recset_get_string(mov, MOV_NUMDOCEXT); - if(numdoc.empty()) - numdoc = recset_get_string(mov, MOV_NUMDOC); + TString numdoc = mov.get_string(MOV_NUMDOCEXT); + + if (numdoc.empty()) + numdoc = mov.get_string(MOV_NUMDOC); // Se definitivo controllo il flag di stampato REGST if ((flagpro || stampato) && numdoc.full() && iva == tipo) { - clifo.zero(); - clifo.put(CLI_TIPOCF, tipo == iva_acquisti ? "F" : "C"); - clifo.put(CLI_CODCF, recset_get_string(mov, MOV_CODCF)); - // Creo il movimento da inserire - movimento_t t; - t.err = false; - t.numreg = recset_get_int (mov, MOV_NUMREG); - t.datareg = recset_get_date (mov, MOV_DATAREG); - t.datadoc = recset_get_date (mov, MOV_DATADOC); - t.codcaus = recset_get_string (mov, MOV_CODCAUS, 3); - t.meseliq = recset_get_int (mov, MOV_MESELIQ); - if (tipo == iva_vendite) - t.numdoc = get_numdoc_exp_fp(t.numreg); - if (t.numdoc.empty()) - t.numdoc = numdoc; - t.tot = recset_get_real (mov, MOV_TOTDOC) + recset_get_real(mov, MOV_RITFIS) + recset_get_real(mov, MOV_RITSOC); - t.codcf = recset_get_int (mov, MOV_CODCF); - t.ragsoc = clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : " "; - t.reg_protiva = TString(recset_get_string(mov, MOV_REG)) << "/" << recset_get_string(mov, MOV_PROTIVA); - t.descr = recset_get_string (mov, MOV_DESCR); - if (escluso) - { - t.estratto = false; - t.descr_estr = movimento_t::escluso; - } + movimento_t t(mov, tipo, escluso); // Effettivo inserimento del movimento _estrazione->add_mov(t); @@ -396,8 +311,11 @@ void TMonitor_mask::controllo_errori() const void TMonitor_mask::delete_estr_fld(const TString& idestr) { - const TFilename dir = TString() << F9CONF.get_addr_doc_loc() << SLASH << F9CONF.get_ambiente() << SLASH << idestr << SLASH; - experimental::filesystem::remove_all((const char*)dir); + TFilename dir(F9CONF.get_addr_doc_loc()); + + dir << SLASH << F9CONF.get_ambiente() << SLASH << idestr << SLASH << "*"; + + remove_files(dir, true); } void TMonitor_mask::delete_pack(const bool all) const @@ -558,7 +476,7 @@ void TMonitor_mask::open_apri_estr_win() if (last_fill_id != id) { - _inclusi_mask = std::make_unique(); + _inclusi_mask = new TApri_estr_msk; _inclusi_mask->set_from_row_estrazione(*row_estrazione); _inclusi_mask->fill_estr(); @@ -610,7 +528,7 @@ void TMonitor_mask::sel() const TSheet_field& sf = sfield(S_ELAB); FOR_EACH_SHEET_ROW_LOOP(sf, nr) { - if (sf.get_bool_row_cell(F_SEL, nr)) + if (sf.get_bool_row_cell(nr, F_SEL)) sf.set_row_cell(F_SEL, false, nr); } sf.force_update(); @@ -653,16 +571,11 @@ void TControllo_mask::associa() // todo: levare gli ultimi residui del vecchio if (ok) { // Tolgo il flag di in errore sul vettore in modo da rifare la fill e non venir piu' contato come da controllare - auto it = _controllo_mov.begin(); int count = -1; - while (count < _selected_mov && it != _controllo_mov.end()) - { - if (it->get(0)[0] == 'X') // Devo saltare tutti quelli che non hanno il flag e contare solo quelli che ce l'hanno + + FOR_EACH_ARRAY_ROW(_controllo_mov, r, row) + if (count < _selected_mov && row->get_bool(0)) // Devo saltare tutti quelli che non hanno il flag e contare solo quelli che ce l'hanno count++; - if (count < _selected_mov) - ++it; - } - it->add(' ', 0); TF9_dberr::del_err(_cod_soc, _id_estr, mov_sel->get_int(cid2index(F_CNUMREG))); } } @@ -674,11 +587,10 @@ void TControllo_mask::conferma_esclusi() const FOR_EACH_SHEET_ROW_LOOP(sf, row) { - const long nreg = sf.get_long_row_cell(row, F_CNUMREG); TRectype & movs = (TRectype&)cache().get(LF_MOV, nreg); - if (sf.get_bool_row_cell(F_CESCLUDI, row)) + if (sf.get_bool_row_cell(row, F_CESCLUDI)) { const TDate today(TODAY); TToken_string stato("", ';'); @@ -715,9 +627,9 @@ void TControllo_mask::conferma_esclusi() const sf.show(); } -vector& TControllo_mask::import_error_list() +TArray& TControllo_mask::import_error_list() { - _controllo_mov.clear(); + _controllo_mov.destroy(); TF9_dberr dberr; _tipo_doc_err = TF9_dberr::get_errori(_cod_soc, _id_estr, _controllo_mov); return _controllo_mov; @@ -726,24 +638,22 @@ vector& TControllo_mask::import_error_list() void TControllo_mask::fill() { TSheet_field& sf = sfield(S_CONTROLLO); - sf.hide(); - sf.destroy(); + + sf.reset(); if (!_is_escluso) import_error_list(); else _controllo_mov = f9_app()._esclusi; - for (auto it = _controllo_mov.begin(); it != _controllo_mov.end(); ++it) + FOR_EACH_ARRAY_ROW(_controllo_mov, r, row) { - TToken_string& row = sf.row(-1); - if (*it->get(0) == 'X') + TToken_string& sfrow = sf.row(-1); + if (row->get_bool(0)) { - row = *it; - row[0] = (char&)" "; + sfrow = *row; + sf.set_row_cell(101, false, r); } } sf.force_update(); - sf.show(); - // Fill fppro sheet if (!_is_escluso && _tipo_doc_err == 'A' || _is_escluso && f9_app().get_tipoiva_escl() == iva_acquisti) fill_fppro_sheet(); @@ -781,7 +691,7 @@ void TControllo_mask::fill_fppro_sheet() const for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next()) { - const int row = sf.set_row_cell(F_FTIPODOC, "TIPODOC"); + const int row = sf.set_row_cell(F_FTIPODOC, fp_db().sq_get("TIPODOC")); sf.set_row_cell(F_FDATA, fp_db().sq_get_date("DATA"), row); sf.set_row_cell(F_FNUMDOC, fp_db().sq_get("NUMDOC"), row); @@ -871,20 +781,16 @@ TToken_string* TControllo_mask::selected_fat() const void TControllo_mask::selfatt(TOperable_field& o, const long jolly) const { - const TMask& mask = *this; - TSheet_field* sf; - if (jolly == 1) // Sheet controllo - sf = &mask.sfield(S_CONTROLLO); - else - sf = &mask.sfield(S_FPPRO); - sf->hide(); - FOR_EACH_SHEET_ROW(*sf, nr, row) + + TSheet_field& sf = sfield(jolly == 1 ? S_CONTROLLO : S_FPPRO); // Sheet controllo o fppro + const int id = jolly == 1 ? F_CSEL : F_FSEL; + + FOR_EACH_SHEET_ROW_LOOP(sf, row) { - if (*row->get(0) == 'X') - row->add("", 0); + if (sf.get_bool_row_cell(row, id)) + sf.set_row_cell(id, false, row); } - sf->force_update(); - sf->show(); + sf.force_update(); } bool TControllo_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) @@ -976,11 +882,12 @@ TControllo_mask::TControllo_mask(const char* codsoc, const char* id_estr, const _controllo_mov = f9_app()._esclusi; _datada = EOTIME; _dataa = 0L; - for (auto it = _controllo_mov.begin(); it != _controllo_mov.end(); ++it) + FOR_EACH_ARRAY_ROW(_controllo_mov, r, row) { - if (*it->get(0) == 'X') + if (row->get_bool(0)) { - TDate d = it->get(3); + const TDate& d = row->get_date(3); + if (d < _datada) _datada = d; if (d > _dataa) @@ -1099,52 +1006,60 @@ void TApri_estr_msk::fill_estr() const "FROM " F9_IVA "\n" "WHERE " IVA_CODSOC " = '" << F9CONF.get_ambiente() << "' AND " IVA_IDLAN " = '" << _idestr << "'"; // REG + DATAREG + PROTIVA + DATAINC + DATA74TER + NUMREG - TString sql; + TSQL_recordset rec(""); fp_db().sq_set_exec(query, false); TSheet_field& sf = sfield(S_ESCL); - sf.hide(); - sf.destroy(); + + sf.reset(); TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione..."); + for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next()) { if (!prog.add_status()) break; - sql.cut(0) << "SELECT NUMREG, DATAREG, DATADOC, CODCAUS, TIPODOC, MESELIQ, NUMDOC, TOTDOC, CODCF, REG, PROTIVA, DESCR, ELABF9\n" + TString sql; + + sql << "SELECT NUMREG, DATAREG, DATADOC, CODCAUS, TIPODOC, MESELIQ, NUMDOC, TOTDOC, CODCF, REG, PROTIVA, DESCR, ELABF9\n" "FROM MOV\n" "WHERE REG = '" << fp_db().sq_get(IVA_SEZIVA) << "' AND DATADOC='" << TDate(fp_db().sq_get_date(IVA_DATADOC)).date2ansi() << "'" " AND PROTIVA = '" << fp_db().sq_get(IVA_NPROT) << "'"; rec.set(sql); rec.move_first(); - TToken_string& r = sf.row(-1); - r.add(" ", 0); - r.add(rec.get(0).as_string()); // Numreg - r.add(rec.get(1).as_string()); // Data reg - r.add(rec.get(2).as_string()); // Data doc - TString codcaus; codcaus << rec.get(3).as_string(); - const int len = codcaus.len(); - for (int i = 0; i < 3 - len; ++i) - codcaus.add_front("0"); - r.add(codcaus); // Cod caus - r.add(rec.get(4).as_string()); // Tipo doc - r.add(rec.get(5).as_string()); // Mese liq - r.add(rec.get(6).as_string()); // Num doc - r.add(rec.get(7).as_string()); // Tot doc - r.add(rec.get(8).as_string()); // Clifo - TLocalisamfile clifo(LF_CLIFO); - clifo.put(CLI_CODCF, rec.get(8).as_string()); - clifo.put(CLI_TIPOCF, _tipodoc == 'A' ? "F" : "C"); - clifo.read(); - r.add(clifo.get(CLI_RAGSOC)); // Rag soc - r.add(TString(rec.get(9).as_string()) << "/" << rec.get(10).as_string()); // Prot iva - r.add(rec.get(11).as_string()); // Descr - r.add(""); // Flag escludi - r.add(TToken_string(rec.get(12).as_string(), ';').get_bool(2)); // Escluso + + const int row = sf.set_row_cell(FI_NUMREG, rec.get(0).as_string()); // Numreg + + sf.set_row_cell(FI_DATAREG, rec.get(1).as_date(), row); // Data reg + sf.set_row_cell(FI_DATADOC, rec.get(2).as_string(), row); // Data doc + TString codcaus; + + codcaus << rec.get(3).as_string(); + codcaus.lpad(3, '0'); + sf.set_row_cell(FI_CODCAUS, codcaus, row); // Cod caus + sf.set_row_cell(FI_TIPOMOV, rec.get(4).as_string(), row); // Tipo doc + sf.set_row_cell(FI_MESELIQ, rec.get(5).as_string(), row); // Mese liq + sf.set_row_cell(FI_NUMDOC, rec.get(6).as_string(), row); // Num doc + sf.set_row_cell(FI_IMPTOTDOC, rec.get(7).as_string(), row); // Tot doc + sf.set_row_cell(FI_FORN, rec.get(8).as_string(), row); // Clifo + + TToken_string key(_tipodoc == 'A' ? "F" : "C"); + + key.add(rec.get(8).as_string()); + + const TRectype& clifo = cache().get(LF_CLIFO, key); + + sf.set_row_cell(FI_RAGSOC, clifo.get(CLI_RAGSOC), row); // Rag soc + + TString protiva(rec.get(9).as_string()); + + protiva << "/" << rec.get(10).as_string(); + sf.set_row_cell(FI_PROTIVA, protiva, row); // Prot iva + sf.set_row_cell(FI_DESCR, rec.get(11).as_string(), row); // Descr + sf.set_row_cell(FI_IESCLUSO, TToken_string(rec.get(12).as_string(), ';').get_bool(2), row); // Escluso } sf.force_update(); - sf.show(); } void TApri_estr_msk::fill_res() const @@ -1155,39 +1070,41 @@ void TApri_estr_msk::fill_res() const fp_db().sq_set_exec(query, false); TSheet_field& sf = sfield(S_RES); - sf.destroy(); - TProgress_monitor prog(fp_db().sq_items(), "Caricamento dati estrazione..."); - for (bool ok = fp_db().sq_next(); ok; ok = fp_db().sq_next()) + + sf.reset(); + for (bool ok = fp_db().sq_next(); prog.add_status() && ok; ok = fp_db().sq_next()) { - if (!prog.add_status()) - break; + const TRectype & mov = cache().get(LF_MOV, fp_db().sq_get(MES_NUMREG)); + const int row = sf.set_row_cell(F_RSEL, fp_db().sq_get_int(MES_ESTR) ? "X" : " "); // Estratto - TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, fp_db().sq_get(MES_NUMREG)); - mov.read(); - TToken_string& r = sf.row(-1); - r.add(fp_db().sq_get_int(MES_ESTR) ? "X" : " ", 0); // Estratto - r.add(mov.get(MOV_NUMREG)); // Numreg - r.add(mov.get_date(MOV_DATAREG)); // Data reg - r.add(mov.get_date(MOV_DATADOC)); // Data doc - r.add(mov.get(MOV_CODCAUS)); // Cod caus - r.add(mov.get(MOV_TIPODOC)); // Tipo doc - r.add(mov.get_int(MOV_MESELIQ)); // Mese liq - r.add(mov.get(MOV_NUMDOC)); // Num doc - r.add(mov.get_real(MOV_TOTDOC)); // Tot doc - r.add(mov.get_int(MOV_CODCF)); // Clifo + sf.set_row_cell(F_RNUMREG, mov.get(MOV_NUMREG), row); // Numreg + sf.set_row_cell(F_RDATAREG, mov.get_date(MOV_DATAREG), row); // Data reg + sf.set_row_cell(F_RDATADOC, mov.get_date(MOV_DATADOC), row); // Data doc + sf.set_row_cell(F_RCODCAUS, mov.get(MOV_CODCAUS), row); // Cod caus + sf.set_row_cell(F_RTIPOMOV, mov.get(MOV_TIPODOC), row); // Tipo doc + sf.set_row_cell(F_RMESELIQ, mov.get_int(MOV_MESELIQ), row); // Mese liq + sf.set_row_cell(F_RNUMDOC, mov.get(MOV_NUMDOC), row); // Num doc + sf.set_row_cell(F_RIMPTOTDOC, mov.get_real(MOV_TOTDOC), row); // Tot doc + sf.set_row_cell(F_RFORN, mov.get_int(MOV_CODCF), row); // Clifo - TLocalisamfile clifo(LF_CLIFO); - clifo.put(CLI_CODCF, mov.get(MOV_CODCF)); - clifo.put(CLI_TIPOCF, mov.get(MOV_TIPO)); - clifo.read(); + TToken_string key(mov.get(MOV_TIPO)); - r.add(clifo.get(CLI_RAGSOC)); // Rag soc - r.add(TString(mov.get(MOV_REG)) << "/" << mov.get(MOV_PROTIVA)); // Prot iva - r.add(mov.get(MOV_DESCR)); // Descr - r.add(fp_db().sq_get(MES_ERR)); // Descrizione errore + key.add(mov.get(MOV_CODCF)); + + const TRectype & clifo = cache().get(LF_CLIFO, key); + + sf.set_row_cell(F_RRAGSOC, clifo.get(CLI_RAGSOC), row); // Rag soc + + TString protiva(mov.get(MOV_REG)); + + protiva << "/" << mov.get(MOV_PROTIVA); + + sf.set_row_cell(F_RPROTIVA, protiva, row); // Prot iva + sf.set_row_cell(F_RDESCR, mov.get(MOV_DESCR), row); // Descr + sf.set_row_cell(F_RDESCRERR, fp_db().sq_get(MES_ERR), row); // Descrizione errore } + sf.force_update(); } void TApri_estr_msk::set_from_row_estrazione(TToken_string& row_estrazione) @@ -1265,7 +1182,7 @@ bool TF9_app::select_escl_notify(TSheet_field& s, int row, KEY key) FOR_EACH_SHEET_ROW_LOOP(sf, nr) { - if (sf.get_bool_row_cell(FE_SEL, nr)) + if (sf.get_bool_row_cell(nr, FE_SEL)) sf.set_row_cell(FE_SEL, false, nr); } sf.force_update(); @@ -1339,7 +1256,7 @@ void TF9_app::open_esclusi() /* Caricamento esclusi * LOADING DI QUEL MESE E ANNO */ - f9_app()._esclusi_vect.clear(); + f9_app()._esclusi_vect.destroy(); const int anno = ym_msk->get_int(501); const int mese = ym_msk->get_int(502); const int to_m = ym_msk->get_int(503); @@ -1378,7 +1295,7 @@ void TF9_app::open_esclusi() m.add(clifo.read() == NOERR ? clifo.get(CLI_RAGSOC) : ""); m.add(TString(movs.get(MOV_REG)) << "/" << movs.get(MOV_PROTIVA)); m.add(movs.get(MOV_DESCR)); - f9_app()._esclusi_vect.insert(f9_app()._esclusi_vect.end(), m); + f9_app()._esclusi_vect.add(m); } } } @@ -1397,79 +1314,62 @@ void TF9_app::open_esclusi() void TF9_app::fill_esclusi() { - vector& esclusi = f9_app()._esclusi_vect; + TArray & esclusi = f9_app()._esclusi_vect; TSheet_field& sf = esclusi_mask().sfield(S_ESCL); sf.destroy(); - for (auto it = esclusi.begin(); it != esclusi.end(); ++it) - sf.row(-1) = *it; + FOR_EACH_ARRAY_ROW(esclusi, r, row) + sf.row(-1) = *row; sf.force_update(); } -movimento_t TF9_app::escl2mov(TToken_string* row) -{ - movimento_t t; - t.err = false; - t.numreg = row->get_int(1); - t.datareg = row->get(2); - t.datadoc = row->get(3); - t.codcaus = row->get(4); - t.meseliq = row->get_int(5); - t.numdoc = row->get(6); - t.tot = row->get(7); - t.codcf = row->get_int(8); - t.ragsoc = row->get_int(9); - t.reg_protiva = row->get(10); - t.descr = row->get(11); - t.state = null_state; - t.descr_err = ""; - - // todo: controllo attributi aggiunti. - t.estratto = true; - t.descr_estr = movimento_t::no_err; - return t; -} bool TF9_app::estrai_escl_handler(TMask_field&, KEY key) { - TMask& msk = esclusi_mask(); - TF9_app& a = f9_app(); - vector& _esclusi = a._esclusi_vect; - TSheet_field& sf = msk.sfield(S_ESCL); + TMask descr_mask("Estrazione", 1, 60, 5); - descr_msk().run(); - const TString descr = descr_msk().get(DES_TEXT); - descr_msk().set(DES_TEXT, ""); + descr_mask.add_button_tool(DLG_OK, "Conferma", TOOL_OK); + descr_mask.add_button_tool(DLG_CANCEL, "Annulla", TOOL_CANCEL); + descr_mask.add_groupbox(DES_GROUP, 0, "Inserire descrizione estrazione:", 1, 0, 59, 3, ""); + descr_mask.add_string(DES_TEXT, 0, "Descrizione", 4, 1, 250, "", 40); + if (descr_mask.run() == K_ENTER) + { + TMask& msk = esclusi_mask(); + TArray & _esclusi = f9_app()._esclusi_vect; + TSheet_field& sf = msk.sfield(S_ESCL); + const TString descr = descr_mask.get(DES_TEXT); + TFilename path; - TFilename path; - f9_app().get_spotlite_path(path); - a._estr_escluso = - new TEstrazione(F9CONF.get_ambiente(), a._flagprov_escl, a._tipodoc_escl, descr, F9CONF.get_addr_doc(), true, path); + f9_app().get_spotlite_path(path); + f9_app()._estr_escluso =new TEstrazione(F9CONF.get_ambiente(), f9_app()._flagprov_escl, + f9_app()._tipodoc_escl, descr, + F9CONF.get_addr_doc(), true, path); - // Prendo la riga selezionata (e controllo che sia selezionato qualcosa) - bool flag = false; - FOR_EACH_SHEET_ROW(sf, nr, row) - { - if (row->get(0)[0] == 'X') - { - const movimento_t mov = escl2mov(row); - a._estr_escluso->add_mov(mov); - _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; - const int stato = a._estr_escluso->estrai(); - if (stato == 1) - { - _esclusi.erase(_esclusi.begin() + nr); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov - a.segna_estratti(true, mov.numreg); - } - flag = true; - break; - } - } - if (!flag) - message_box("Selezionare il movimento da estrarre"); - else - a.print_log(); - fill_esclusi(); + // Prendo la riga selezionata (e controllo che sia selezionato qualcosa) + bool flag = false; + FOR_EACH_SHEET_ROW_LOOP(sf, row) + { + if (sf.get_bool_row_cell(row, FE_SEL)) + { + const movimento_t mov = f9_app().escl2mov(sf, row); + f9_app()._estr_escluso->add_mov(mov); + _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + const int stato = f9_app()._estr_escluso->estrai(); + if (stato == 1) + { + _esclusi.destroy(row); // Tolto il movimento estratto dal vettore e setto come estratto su elabf9 di mov + f9_app().segna_estratti(true, mov.numreg()); + } + flag = true; + break; + } + } + if (!flag) + message_box("Selezionare il movimento da estrarre"); + else + f9_app().print_log(); + fill_esclusi(); + } return true; } @@ -1505,35 +1405,26 @@ void TF9_app::print_log() bool TF9_app::is_autofattura(const TLocalisamfile& mov) { - return TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).tipo_doc() == "AF"; + return cached_causale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).tipo_doc() == "AF"; } bool TF9_app::segna_estratti(const bool escluso, const int numreg) { bool ok = true; + TArray escl; // - vector escl; if (escluso) - { - TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, numreg); - mov.read(); - TLocalisamfile clifo(LF_CLIFO); clifo.put(CLI_TIPOCF, mov.get(MOV_TIPO)); clifo.read(); - const movimento_t m{ false, numreg, mov.get_date(MOV_DATAREG), mov.get_date(MOV_DATADOC), mov.get(MOV_CODCAUS), mov.get_int(MOV_MESELIQ), !mov.get(MOV_NUMDOCEXT).empty() ? mov.get(MOV_NUMDOCEXT) : mov.get(MOV_NUMDOC), - mov.get_real(MOV_TOTDOC), mov.get_int(MOV_CODCF), clifo.get(CLI_RAGSOC), mov.get(MOV_REG), mov.get(MOV_DESCR) }; - escl.insert(escl.begin(), m); // todo: datareg? - } - vector& movs_v = escluso ? escl : _movs; + escl.add(movimento_t(numreg)); // todo: datareg? - TLocalisamfile mov(LF_MOV); - TToken_string elab("", ';'); - elab.add("X", 0); elab.add(today.date2ansi()); elab.add(" "); // "[flag estratto];[data estrazione];[flag escluso]" - for (auto it = movs_v.begin(); it != movs_v.end(); ++it) + TArray& movs_v = escluso ? escl : _movs; + TToken_string elab("X", ';'); // "[flag estratto]; + + elab.add(today.date2ansi()); elab.add(" "); // "[flag estratto];[data estrazione];[flag escluso]" + FOR_EACH_ARRAY_ITEM(movs_v, r, obj) { - TString8 num_reg; num_reg << it->numreg; - mov.zero(); - mov.put(MOV_NUMREG, num_reg); - mov.read(); + const movimento_t & t = (movimento_t &) *obj; + TRectype& mov = (TRectype&) cache().get(LF_MOV, t.numreg()); + mov.put(MOV_ELABF9, elab); ok &= mov.rewrite() == NOERR; } diff --git a/src/f9/f90100.h b/src/f9/f90100.h index 1724901bb..d48ff3a71 100644 --- a/src/f9/f90100.h +++ b/src/f9/f90100.h @@ -14,7 +14,7 @@ */ class TEstrai_mask : public TMask { - unique_ptr _estrazione; // Oggetto estrazione in corso di elaborazione + TEstrazione * _estrazione; // Oggetto estrazione in corso di elaborazione void enable_fields(bool en = true); @@ -39,8 +39,8 @@ class TEstrai_mask : public TMask static bool dataend_handler(TMask_field& f, KEY key); public: - static TString get_numdoc_exp_fp(int numreg); TEstrai_mask(); + ~TEstrai_mask() { safe_delete(_estrazione); }; }; @@ -56,17 +56,16 @@ class TF9_app : public TSkeleton_application friend class TEstrazione; - TEstrai_mask * _estr_msk; + TEstrai_mask * _estr_msk; TMonitor_mask * _msk; - vector _movs; - vector _esclusi; // Vettore con i movimenti esclusi - vector _esclusi_vect; - TToken_string _mov_escl; - char _tipodoc_escl; - char _flagprov_escl; - TString _log; - - TEstrazione* _estr_escluso; + TArray _movs; // movimento_t + TArray _esclusi; // Vettore con i movimenti esclusi + TArray _esclusi_vect; + TToken_string _mov_escl; + char _tipodoc_escl; + char _flagprov_escl; + TString _log; + TEstrazione* _estr_escluso; char get_tipodoc_escl() const { return _tipodoc_escl; } @@ -91,7 +90,7 @@ public: void open_esclusi(); static void fill_esclusi(); - static movimento_t escl2mov(TToken_string* row); + movimento_t TF9_app::escl2mov(TSheet_field & sf, int row) { return movimento_t(sf, row); } static bool mov_handler_escl(TMask_field&, KEY key); @@ -121,6 +120,7 @@ public: void main_loop() override; TF9_app(); + ~TF9_app() { safe_delete(_estr_msk); safe_delete(_msk); } }; inline TF9_app& f9_app() @@ -138,7 +138,7 @@ class TMonitor_mask : public TAutomask { friend class TF9_app; vector _fppro; - std::unique_ptr _inclusi_mask; + TApri_estr_msk * _inclusi_mask; // Configurazione mask static bool save_conf_handler(TMask_field& f, KEY key); @@ -161,12 +161,13 @@ class TMonitor_mask : public TAutomask void sel() const; public: - TMonitor_mask(); + TMonitor_mask(); + ~TMonitor_mask() { safe_delete(_inclusi_mask); } }; class TControllo_mask : public TAutomask { - vector _controllo_mov; // Usare import_error_list(). + TArray _controllo_mov; // Usare import_error_list(). char _ordin; char _verso; int _selected_mov; @@ -181,7 +182,7 @@ class TControllo_mask : public TAutomask void associa(); void conferma_esclusi() const; - vector& import_error_list(); + TArray& import_error_list(); void fill(); void fill_fppro_sheet() const; TMask& get_win_order(); diff --git a/src/f9/f9lib.h b/src/f9/f9lib.h index c153252ad..13baf246f 100644 --- a/src/f9/f9lib.h +++ b/src/f9/f9lib.h @@ -21,6 +21,7 @@ // Controlla eventuali apostrofi e li raddoppia const char* check_str(const TString& str); +const TString & get_numdoc_exp_fp(int numreg); struct annesso_t { @@ -150,15 +151,15 @@ public: bool obblig{ false }; // Definisce se deve essere per forza presente l'annesso. }; private: - std::vector> _rows; + std::vector _rows; std::vector>> _sheets_annessi; std::shared_ptr _sheet_catdocs; std::shared_ptr> _name_catdocs; int _mode_sheet; - std::shared_ptr find_causcont(const TString& caus) const ; // OK - std::shared_ptr find_tipodoc(const TString& tipodoc) const ; // OK - std::shared_ptr find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const ; // OK + TCategorie_doc::classe_doc * find_causcont(const TString& caus) const ; // OK + TCategorie_doc::classe_doc * find_tipodoc(const TString& tipodoc) const ; // OK + TCategorie_doc::classe_doc * find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const ; // OK std::vector>>::iterator find_sheet_annessi(const TString& catdoc); // OK @@ -189,12 +190,12 @@ public: bool get_ann(const TString & catdoc, const TString& catann, _Out_ annesso& _Annesso_out); TString_array get_array_ann(const TString& catdoc); TString_array get_array_rows(bool traduci = false); - std::shared_ptr get_classe_doc(const TString& catdoc); + classe_doc* get_classe_doc(const TString& catdoc); std::set& get_name_catdocs() { get_sheet_catdocs(); return *_name_catdocs; } std::shared_ptr get_sheet_catdocs(); std::shared_ptr get_sheet_ann(const TString& catdoc); - std::shared_ptr mov2cat(int numreg); - const char * tipo2caus_cont(const TString & tipodoc, const char * tipocaus) { std::shared_ptr c = find_tipodocsdi(tipodoc, tipocaus); if (c != nullptr) return c->causcont; else return ""; } + classe_doc * mov2cat(const long numreg); + const TString & tipo2caus_cont(const TString & tipodoc, const char * tipocaus) { TCategorie_doc::classe_doc * c = find_tipodocsdi(tipodoc, tipocaus); if (c != nullptr) return c->causcont; else return EMPTY_STRING; } void reload(); static void remove_all(); static void remove_all_ann(); @@ -227,111 +228,93 @@ public: TRecord_categorie(type table = catdocs); }; -struct movimento_t +enum err_mov { - enum err_mov - { - no_err, // Estratto normalmente. - escluso, // Movimento con flag escluso. - no_catdoc, // Nessuna cat. doc. riconosciuta per questo movimento, o non e' una fattura. - no_doc, // Il mov. di vendita non ha un documento generatore. - notfound_elet, // Non trovata fatt. elettronica mov vendita. - no_fa, // Movimento di acquisto non e' una fattura. - no_fv, // Movimento di vendita non e' una fattura. - no_cartaceo, // Movimento cartaceo che non ha bisogno di essere estratto. - pura_iva, // Movimento di sola IVA (integrazione Rev. Charge) - no_filecart, // Il documento cartaceo non ha associato un file, o questo non e' stato trovato. - annesso_nexist // Un annesso obbligatorio e' mancante. - }; + mov_no_error, // Estratto normalmente. + mov_escluso, // Movimento con flag escluso. + mov_no_catdoc, // Nessuna cat. doc. riconosciuta per questo movimento, o non e' una fattura. + mov_no_doc, // Il mov. di vendita non ha un documento generatore. + mov_notfound_elet, // Non trovata fatt. elettronica mov vendita. + mov_no_fa, // Movimento di acquisto non e' una fattura. + mov_no_fv, // Movimento di vendita non e' una fattura. + mov_no_cartaceo, // Movimento cartaceo che non ha bisogno di essere estratto. + mov_pura_iva, // Movimento di sola IVA (integrazione Rev. Charge) + mov_no_filecart, // Il documento cartaceo non ha associato un file, o questo non e' stato trovato. + mov_annesso_nexist // Un annesso obbligatorio e' mancante. +}; - bool err{ false }; - int numreg; - TDate datareg; - TDate datadoc; - TString codcaus; - int meseliq; - TString numdoc; - real tot; - int codcf; - TString ragsoc; - TString reg_protiva; - TString descr; - state_fppro state{ null_state }; - TString descr_err{}; // Messaggio di errore visibile dal controllo estrazione. - bool estratto{ true }; - err_mov descr_estr{ no_err }; // Messaggio di informazioni visibile dal 'Apri Estr.' - std::shared_ptr catdoc{ nullptr }; - bool cartaceo{ false }; - TFilename nomefilecart{}; - vector annessi{}; +class movimento_t : public TObject // aggiungere metodi per TArray +{ - static const char* err_mov2name(const err_mov descr_estr) - { - switch (descr_estr) - { - case no_err: - return "OK"; - case escluso: - return "Il movimento e' segnato come escluso. Saltato."; - case no_catdoc: - return "Nessuna categoria documentale riconosciuta per questo movimento, o non e' una fattura."; - case no_doc: - return "Il mov. di vendita non ha un documento generatore"; - case notfound_elet: - return "Non trovata fatt. elettronica mov vendita"; - case no_fa: - return "Questo movimento di acquisto non e' una fattura"; - case no_fv: - return "Movimento di vendita non e' una fattura."; - case no_cartaceo: - return "Movimento cartaceo che non ha bisogno di essere estratto"; - case pura_iva: - return "Movimento di sola IVA. (Le integrazioni Rev. Charge sono gestite come annessi alle vendite)"; - case annesso_nexist: - return "Un annesso obbligatorio e' mancante."; - default: return ""; - } - } - const char* get_descr_estr() const - { - return err_mov2name(descr_estr); - } + bool _err; + long _numreg; + TDate _datareg; + TDate _datadoc; + TString _codcaus; + int _meseliq; + TString _numdoc; + real _tot; + long _codcf; + TString _ragsoc; + TString _reg_protiva; + TString _descr; + state_fppro _state; + TString _descr_err; // Messaggio di errore visibile dal controllo estrazione. + bool _estratto; + err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.' + TCategorie_doc::classe_doc* _catdoc; + bool _cartaceo; + TFilename _nomefilecart; + vector _annessi; - TString get(const int i) const - { - TString a; - switch (i) - { - case 0: return err; - case 1: return a << numreg; - case 2: return (const char*)datareg; - case 3: return (const char*)datadoc; - case 4: return codcaus; - case 5: return a << meseliq; - case 6: return numdoc; - case 7: - a << tot; - if (a == "0") - a << ".0"; - return a; - case 8: return a << codcf; - case 9: return ragsoc; - case 10: return reg_protiva; - case 11: return descr; - case 14: return descr_err; - default: return ""; - } - } +public: + static const char* err_mov2name(const err_mov descr_estr); + const char* get_descr_estr() const { return err_mov2name(_descr_estr); } + bool err() const { return _err; } + bool no_err() const { return !err(); } + long numreg() const { return _numreg; } + const TDate & datareg() const { return _datareg; } + const TDate & datadoc() const { return _datadoc; } + const TString & codcaus() const { return _codcaus; } + int meseliq() const { return _meseliq; } + const TString & numdoc() const { return _numdoc; } + real totale() const { return _tot; } + long codcf() const { return _codcf; } + const TString & ragsoc() const { return _ragsoc; } + const TString & protiva() const { return _reg_protiva; } + const TString & descr() const { return _descr; } + state_fppro state() const { return _state; } + const TString & descr_err() const { return _descr_err; } + bool estratto() const { return _estratto; } + err_mov descr_estr() const { return _descr_estr; } + TCategorie_doc::classe_doc* catdoc() const { return _catdoc; } + vector annessi() const { return _annessi; } + bool cartaceo() const { return _cartaceo; } // todo + const TFilename & nomefilecart() const { return _nomefilecart; } - bool is_cartaceo() const { return false; } // todo +// void set_err(bool err) { _err = err; } + void set_err(const char * descr = "", err_mov descr_estr = mov_no_error); + void reset_err() { set_err(); } + void set_cartaceo(bool cartaceo) { _cartaceo = cartaceo; } + void set_state(state_fppro state) { _state = state; } + void set_descr_estr(err_mov descr_estr) { _descr_estr = descr_estr; } + void set_numdoc(const char * numdoc) { _numdoc = numdoc; } + void set_estratto(bool estratto) { _estratto = estratto; } + void set_catdoc(TCategorie_doc::classe_doc* catdoc) { _catdoc = catdoc; } + void set_nomefilecart(const char * nomefilecart) { _nomefilecart = nomefilecart; } + + movimento_t(TSheet_field& sf, int row); + movimento_t(const long numreg); + movimento_t(TISAM_recordset & mov, TipoIVA tipo, bool escl); + ~movimento_t() { safe_delete(_catdoc); } }; class TEstrazione : public TObject { drd _head; vector _movs; - unique_ptr _error_sql; + ofstream * _error_sql; bool _escluso; const TString _descr; bool _has_cartacei; @@ -360,9 +343,9 @@ class TEstrazione : public TObject static state_fppro check_fppro(int numreg); bool check_periodo_def() const; void copy_file_to_webapp_fld(const movimento_t& movimento) const; - static void fill_id(TLocalisamfile& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis); + static void fill_id(const TRectype& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis); TipoIVA get_tipoiva() const { return _head.tipo_doc == 'A' ? iva_acquisti : iva_vendite; } - static bool is_doc_xml(const TLocalisamfile& mov); + static bool is_doc_xml(const TRectype& mov); static bool find_movcoll(int numreg, _Out_ TString& numreg_rev_vend); static bool load_annessi(movimento_t& movimento); // Se il movimento e' di vendita e ha i riferimenti al documento generatore provo a stamparlo con ve, e lo inserisco tra i cartacei F9. @@ -384,7 +367,7 @@ private: * genera il progressivo seguente. Chiamata da \a estrai() e \a estrai_single(). * \return Nuovo id estrazione. */ TString next_estr_today(char tipo) const; - static bool pura_iva(const TLocalisamfile& mov); + static bool pura_iva(const TRectype& mov); void write_errorsql_log(const TString& query) const; static TCategorie_doc& categorie_doc(bool reload = false); @@ -437,6 +420,7 @@ public: TEstrazione(const TString& ambiente, bool flag_prov, char tipodoc, const TString& descr, const TString& addrcart, bool escluso, TFilename& spotlite_path, const TDate* dal = nullptr, const TDate* al = nullptr, bool has_cartacei = false); + ~TEstrazione() { safe_delete(_error_sql); } }; @@ -457,7 +441,7 @@ public: void add() { add_str("NULL"); } bool send(); static bool del_err(const TString& codsoc, const TString& id_estr, int numreg); - static char get_errori(const TString& codsoc, const TString& id_estr, vector& controllo_mov); + static char get_errori(const TString& codsoc, const TString& id_estr, TArray& controllo_mov); TF9_dberr(); }; @@ -489,10 +473,10 @@ class TF9_doccart public: static bool add_cart(const TFilename& file, const TString& numreg, bool is_annesso = false, const TString& catannpadre = "", const TString& catdocann = "", bool suppress_errors = true); - bool doc_already_exists(const TFilename& file, _Out_ TString& numreg, _Out_ bool& annesso); - bool mov2doc(const TString& numreg, _Out_ TFilename& doc); - bool mov2listann(const TString& numreg, _Out_ TString_array& list_annessi); - bool mov2listann_vect(const TString& numreg, _Out_ vector& list_annessi); + bool doc_already_exists(const TFilename& file, TString& numreg, bool& annesso); + bool mov2doc(const TString& numreg, TFilename& doc); + bool mov2listann(const TString& numreg, TString_array& list_annessi); + bool mov2listann_vect(const TString& numreg, vector& list_annessi); static TString get_full_path_file_cartaceo(const TString& filename) { diff --git a/src/f9/f9lib01.cpp b/src/f9/f9lib01.cpp index e6248def7..fd270071f 100644 --- a/src/f9/f9lib01.cpp +++ b/src/f9/f9lib01.cpp @@ -1,7 +1,8 @@ -//#include - #include "f9lib.h" +#include +#include + #include "../f1/f1lib.h" #include "f901tab.h" #include "progind.h" @@ -10,13 +11,147 @@ #include "mov.h" #include "../fp/fplib.h" #include "annessif9.h" -#include "dongle.h" -#include "execp.h" +#include "f90100c.h" #define MODE_SHEETS 0xC statistics _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +const TString & get_numdoc_exp_fp(const int numreg) +{ + TRectype & mov = (TRectype&)cache().get(LF_MOV, numreg); + TString & numdoc = get_tmp_string(); + + if (mov.full()) + { + const TString& dprovv = mov.get(MOV_DPROVV); + const int danno = mov.get_int(MOV_DANNO); + const TString& dcodnum = mov.get(MOV_DCODNUM); + const int dndoc = mov.get_int(MOV_DNDOC); + if (!dprovv.empty() && danno != 0 && !dcodnum.empty() && dndoc != 0) + { + const TDocumento doc(dprovv[0], danno, dcodnum, dndoc); + numdoc = complete_num_fp(doc.codice_numerazione(), doc.numero()); + } + } + return numdoc; +} + +/////////////////////////////////////////////////////////////////////////////// +// movimento_t +/////////////////////////////////////////////////////////////////////////////// + +const char* movimento_t::err_mov2name(const err_mov descr_estr) +{ + switch (descr_estr) + { + case mov_no_error: + return "OK"; + case mov_escluso: + return "Il movimento e' segnato come escluso. Saltato."; + case mov_no_catdoc: + return "Nessuna categoria documentale riconosciuta per questo movimento, o non e' una fattura."; + case mov_no_doc: + return "Il mov. di vendita non ha un documento generatore"; + case mov_notfound_elet: + return "Non trovata fatt. elettronica mov vendita"; + case mov_no_fa: + return "Questo movimento di acquisto non e' una fattura"; + case mov_no_fv: + return "Movimento di vendita non e' una fattura."; + case mov_no_cartaceo: + return "Movimento cartaceo che non ha bisogno di essere estratto"; + case mov_pura_iva: + return "Movimento di sola IVA. (Le integrazioni Rev. Charge sono gestite come annessi alle vendite)"; + case mov_annesso_nexist: + return "Un annesso obbligatorio e' mancante."; + default: return ""; + } +} + +movimento_t::movimento_t(TSheet_field& sf, int row) : _err(false), _state(null_state), _estratto(true), + _descr_estr(mov_no_error), _catdoc(nullptr), _cartaceo(false) +{ + _numreg = sf.get_long_row_cell(row, FE_NUMREG); + _datareg = sf.get_date_row_cell(row, FE_DATAREG); + _datadoc = sf.get_date_row_cell(row, FE_DATADOC); + _codcaus = sf.get_str_row_cell(row, FE_CODCAUS); + _meseliq = sf.get_int_row_cell(row, FE_MESELIQ); + _numdoc = sf.get_str_row_cell(row, FE_NUMDOC); + _tot = sf.get_real_row_cell(row, FE_IMPTOTDOC); + _codcf = sf.get_long_row_cell(row, FE_FORN); + _ragsoc = sf.get_long_row_cell(row, FE_RAGSOC); + _reg_protiva = sf.get_str_row_cell(row, FE_PROTIVA); + _descr = sf.get_long_row_cell(row, FE_DESCR); +} + +void movimento_t::set_err(const char * descr, err_mov descr_estr) +{ + bool error = descr && *descr; + + _err = error ; + _estratto = !error || (descr_estr != mov_no_fa && descr_estr != mov_no_cartaceo); + _descr_err = descr; + if (descr_estr != mov_no_error) + _descr_estr = descr_estr; + else + _descr_estr = error ? mov_annesso_nexist : mov_no_error; +} + +movimento_t::movimento_t(const long numreg) : _err(false), _state(null_state), _estratto(true), _descr_estr(mov_no_error), + _catdoc(nullptr), _cartaceo(false) +{ + const TRectype & mov = cache().get(LF_MOV, numreg); + TToken_string key(mov.get(MOV_TIPO)); + + key.add(mov.get(MOV_CODCF)); + + const TRectype & clifo = cache().get(LF_CLIFO, key); + + _numreg = numreg; + _datareg = mov.get_date(MOV_DATAREG); + _datadoc = mov.get_date(MOV_DATADOC); + _codcaus = mov.get(MOV_CODCAUS); + _meseliq = mov.get_int(MOV_MESELIQ); + _numdoc = mov.get(MOV_NUMDOCEXT).full() ? mov.get(MOV_NUMDOCEXT) : mov.get(MOV_NUMDOC); + _tot = mov.get_real(MOV_TOTDOC); // perchè no ? +mov.get_real(MOV_RITFIS) + mov.get_real(MOV_RITSOC); + _codcf = mov.get_long(MOV_CODCF); + _ragsoc = clifo.get(CLI_RAGSOC); + _reg_protiva = mov.get(MOV_REG); + _reg_protiva << "/" << mov.get(MOV_PROTIVA); // perchè c'era solo mov_reg ? + _descr = mov.get(MOV_DESCR); +} + +movimento_t::movimento_t(TISAM_recordset & mov, TipoIVA tipo, bool escl) : _err(false), _state(null_state), + _estratto(true), _descr_estr(mov_no_error), + _catdoc(nullptr), _cartaceo(false) +{ + _numreg = mov.get_long(MOV_NUMREG); + _datareg = mov.get_date(MOV_DATAREG); + _datadoc = mov.get_date(MOV_DATADOC); + _codcaus = mov.get_string(MOV_CODCAUS).left(3); // perchè 3 caratteri ? + _meseliq = mov.get_int(MOV_MESELIQ); + if (tipo == iva_vendite) + _numdoc = get_numdoc_exp_fp(_numreg); + if (_numdoc.empty()) + _numdoc = mov.get_string(MOV_NUMDOCEXT); + _tot = mov.get_real(MOV_TOTDOC) + mov.get_real(MOV_RITFIS) + mov.get_real(MOV_RITSOC); + _codcf = mov.get_long(MOV_CODCF); + + TToken_string key(tipo == iva_acquisti ? "F" : "C"); + + key.add(_codcf); + _ragsoc = cache().get(LF_CLIFO, key, CLI_RAGSOC); + _reg_protiva = mov.get_string(MOV_REG); + _reg_protiva << "/" << mov.get_string(MOV_PROTIVA); + _descr = mov.get_string(MOV_DESCR); + if (escl) + { + _estratto = false; + _descr_estr = mov_escluso; + } +} + /////////////////////////////////////////////////////////////////////////////// // TEstrazione /////////////////////////////////////////////////////////////////////////////// @@ -41,15 +176,14 @@ const char* TEstrazione::caus_sos(const TLocalisamfile& mov, const TipoIVA iva) void TEstrazione::check_annessi(movimento_t& mov_i, const int numreg) { TToken_string ann_nexist; - if (!check_annessi_oblig(mov_i.catdoc->catdoc, numreg, ann_nexist)) + + if (!check_annessi_oblig(mov_i.catdoc()->catdoc, numreg, ann_nexist)) { TString msg_annessi_mancanti("Annessi obligatori mancanti: "); for (int i = 0; i < ann_nexist.items(); ++i) msg_annessi_mancanti << ann_nexist.get() << " "; - mov_i.err = true; - mov_i.estratto = false; - mov_i.descr_err = msg_annessi_mancanti; - mov_i.descr_estr = movimento_t::annesso_nexist; + + mov_i.set_err(msg_annessi_mancanti); } else { @@ -102,7 +236,7 @@ bool TEstrazione::check_cartaceo_acq(const movimento_t& movimento) { TF9_doccart filecart; TFilename file; - TString reg; reg << movimento.numreg; + TString reg; reg << movimento.numreg(); return filecart.mov2doc(reg, file) && file.exist(); } @@ -178,14 +312,14 @@ void TEstrazione::copy_file_to_webapp_fld(const movimento_t& movimento) const TToken_string categorie; TToken_string files; - if(movimento.cartaceo && movimento.catdoc != nullptr) + if(movimento.cartaceo() && movimento.catdoc() != nullptr) { - categorie.add(movimento.catdoc->catdoc, 0); - files.add(movimento.nomefilecart, 0); + categorie.add(movimento.catdoc()->catdoc, 0); + files.add(movimento.nomefilecart(), 0); } - if(!movimento.annessi.empty()) + if(!movimento.annessi().empty()) { - for (auto it = movimento.annessi.begin(); it != movimento.annessi.end(); ++it) + for (auto it = movimento.annessi().begin(); it != movimento.annessi().end(); ++it) { categorie.add(it->catdocann); files.add(TF9_doccart::get_full_path_file_cartaceo(it->filename)); @@ -207,7 +341,7 @@ void TEstrazione::copy_file_to_webapp_fld(const movimento_t& movimento) const } } -void TEstrazione::fill_id(TLocalisamfile& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis) +void TEstrazione::fill_id(const TRectype& clifo, TString& statopaiv, TString& idfisc, TString& paiv, TString& codfis) { idfisc.cut(0); statopaiv = clifo.get(CLI_STATOPAIV); @@ -252,16 +386,16 @@ void TEstrazione::fill_id(TLocalisamfile& clifo, TString& statopaiv, TString& id } } -bool TEstrazione::is_doc_xml(const TLocalisamfile& mov) +bool TEstrazione::is_doc_xml(const TRectype& mov) { - const TString& tipocf = mov.get(MOV_TIPO); - const TString& codcf = mov.get(MOV_CODCF); - TLocalisamfile clifo(LF_CLIFO); - clifo.put(CLI_TIPOCF, tipocf); - clifo.put(CLI_CODCF, codcf); - clifo.read(); + TToken_string key(mov.get(MOV_TIPO)); + + key.add(mov.get(MOV_CODCF)); + + const TRectype & clifo= cache().get(LF_CLIFO, key); const TString& statopaiv = clifo.get(CLI_STATOPAIV); - return (IS_ITALIANO(statopaiv)) && clifo.get(CLI_COMCF) != "B513"; // Campione d'Italia + + return (IS_ITALIANO(statopaiv)) && clifo.get(CLI_COMCF) != "B513"; // Campione d'Italia } bool TEstrazione::find_movcoll(const int numreg, _Out_ TString& numreg_rev_vend) @@ -298,8 +432,9 @@ bool TEstrazione::find_movcoll(const int numreg, _Out_ TString& numreg_rev_vend) bool TEstrazione::load_annessi(movimento_t& movimento) { TF9_doccart doccart; - TString numreg; numreg << movimento.numreg; - return doccart.mov2listann_vect(numreg, movimento.annessi); + TString numreg; numreg << movimento.numreg(); + + return doccart.mov2listann_vect(numreg, movimento.annessi()); } bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file) @@ -307,7 +442,7 @@ bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file bool ok = false; // Se il movimento e' di vendita e ha i riferimenti al documento generatore provo a stamparlo con ve, e lo inserisco tra i cartacei F9. TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, movimento.numreg); + mov.put(MOV_NUMREG, movimento.numreg()); if (mov.read() == NOERR && !mov.get(MOV_DPROVV).empty() && !mov.get(MOV_DANNO).empty() && !mov.get(MOV_DCODNUM).empty() && !mov.get(MOV_DNDOC).empty()) { @@ -327,7 +462,7 @@ bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file { file.cut(0) << pdf; - TString numreg; numreg << movimento.numreg; + TString numreg; numreg << movimento.numreg(); // Controllo anche se false perche' potrebbe esistere gia'. if(!TF9_doccart::add_cart(file, numreg)) { @@ -347,7 +482,8 @@ bool TEstrazione::stampa_documento(const movimento_t& movimento, TFilename& file bool TEstrazione::grab_pdf_from_spotlite(const movimento_t& movimento, TFilename& file) const { TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, movimento.numreg); + + mov.put(MOV_NUMREG, movimento.numreg()); if (mov.read() == NOERR && !mov.get(MOV_DPROVV).empty() && !mov.get(MOV_DANNO).empty() && !mov.get(MOV_DCODNUM).empty() && !mov.get(MOV_DNDOC).empty()) { @@ -475,8 +611,8 @@ bool TEstrazione::insert_into_f9movestr() const break; query.cut(0) << "INSERT INTO " F9_MOVESTR " (" MES_CODSOC ", IDESTR, NUMREG, DATAREG, ESTRATTO, DESCR_ERR)\nVALUES " << - " ('" << _head.cod_soc << "', '" << _head.id_estr << "', '" << it->numreg << "', '" << it->datareg.date2ansi() << "', " << - (it->estratto ? "1" : "0") << ", '" << check_str(it->get_descr_estr()) << "')"; + " ('" << _head.cod_soc << "', '" << _head.id_estr << "', '" << it->numreg() << "', '" << it->datareg().date2ansi() << "', " << + (it->estratto() ? "1" : "0") << ", '" << check_str(it->get_descr_estr()) << "')"; ok &= fp_db().sq_set_exec(query) && fp_db().sq_commit(); if (!ok) { @@ -499,24 +635,22 @@ bool TEstrazione::export_error_list() const if (!pg.add_status()) break; - if (it->err) + if (it->err()) { dberr.add(_head.cod_soc); dberr.add(_head.id_estr); - for (int i = 1; i < 15; i++) - { - TString string(it->get(i)); - - if (i == 2 || i == 3) // Sono obbligato a far cosi' per aggiungere le date - dberr.add(TDate(it->get(i))); - else if (string.full()) - { - string.replace("'", "''"); - dberr.add(string); - } - else - dberr.add(); // Se vuoto metto NULL - } + dberr.add(it->numreg()); + dberr.add(it->datareg()); + dberr.add(it->datadoc()); + dberr.add(it->codcaus()); + dberr.add(it->meseliq()); + dberr.add(it->numdoc()); + dberr.add(it->totale().stringa()); + dberr.add(it->codcf()); + dberr.add(it->ragsoc()); + dberr.add(it->protiva()); + dberr.add(it->descr()); + dberr.add(it->descr_err()); if (!(ok &= dberr.send())) break; ++count; @@ -554,7 +688,7 @@ TString TEstrazione::next_estr_today(char tipo) const return TString(estr); } -bool TEstrazione::pura_iva(const TLocalisamfile& mov) +bool TEstrazione::pura_iva(const TRectype& mov) { if (TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).soloiva()) return true; @@ -631,16 +765,16 @@ const char* TEstrazione::diagnostica_mov() movimento_t& mov_i = *it; // Se gia' escluso passo avanti - if (!mov_i.estratto && mov_i.descr_estr == movimento_t::escluso) + if (!mov_i.estratto() && mov_i.descr_estr() == mov_escluso) continue; - if (!mov_i.err && mov_i.estratto) + if (mov_i.no_err() && mov_i.estratto()) { - const int numreg = mov_i.numreg; - TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, numreg); - mov.read(); - mov_i.cartaceo = !is_doc_xml(mov); + const long numreg = mov_i.numreg(); + const TRectype & mov =cache().get(LF_MOV, numreg); + + mov_i.set_cartaceo(!is_doc_xml(mov)); + const state_fppro res = check_fppro(numreg); switch (res) { @@ -649,32 +783,27 @@ const char* TEstrazione::diagnostica_mov() ok &= fppro_db().associa_mov(numreg); case correct: ok &= true; - mov_i.err = false; - mov_i.numdoc = fppro_db().get_numdoc(); + mov_i.reset_err(); + mov_i.set_numdoc(fppro_db().get_numdoc()); break; // ERRORS // Errore non bloccante (skip) case not_fa: ok &= true; - mov_i.err = false; - mov_i.estratto = false; - mov_i.descr_estr = movimento_t::no_fa; + mov_i.set_err("", mov_no_fa); + mov_i.set_estratto(false); ++_stats.fa_skip; break; // ERRORI BLOCCANTI case reg_with_err: ok &= false; - mov_i.err = true; - mov_i.estratto = false; - mov_i.descr_err = "Errore controllo movimento: associazione movimento con fattura elettronica passiva sbagliato."; + mov_i.set_err("Errore controllo movimento: associazione movimento con fattura elettronica passiva sbagliato."); break; case err_read_db: ok &= false; - mov_i.err = true; - mov_i.estratto = false; - mov_i.descr_err = "Errore controllo movimento: errore lettura db."; + mov_i.set_err("Errore controllo movimento: errore lettura db."); break; case no_guessed: // Controllo se esiste il cartaceo es. forfettari => la considero cartacea. @@ -682,73 +811,67 @@ const char* TEstrazione::diagnostica_mov() if(check_cartaceo_acq(mov_i)) { ok &= true; - mov_i.err = false; - mov_i.cartaceo = true; - mov_i.estratto = true; - mov_i.descr_err = ""; - mov_i.state = correct; + mov_i.set_err(""); + mov_i.set_cartaceo(true); + mov_i.set_state(correct); } else { ok &= false; - mov_i.err = true; - mov_i.estratto = false; - mov_i.descr_err = "Non associato a fattura elettr. abbinamento automatico non riuscito. Abbinare manualmente, o escludere"; + mov_i.set_err("Non associato a fattura elettr. abbinamento automatico non riuscito. Abbinare manualmente, o escludere"); } default: break; } - if(mov_i.state == null_state) - mov_i.state = res; + if(mov_i.state() == null_state) + mov_i.set_state(res); - if (mov_i.err) ++_stats.fa_err; + if (mov_i.err()) + ++_stats.fa_err; /* Per quelli che hanno passato il primo controllo errori controllo che debba essere estratto * secondo le categorie documentali. */ - if (mov_i.estratto) + if (mov_i.estratto()) { - if (!mov_i.err) + if (mov_i.no_err()) { // Cerco la categoria documentale - std::shared_ptr cd = categorie_doc().mov2cat(mov_i.numreg); - mov_i.estratto = cd.get(); - mov_i.descr_estr = cd ? movimento_t::no_err : movimento_t::no_catdoc; - mov_i.catdoc = cd; + TCategorie_doc::classe_doc * cd = categorie_doc().mov2cat(mov_i.numreg()); + const bool found = cd != nullptr; - if (mov_i.catdoc) + mov_i.set_estratto(found); + mov_i.set_descr_estr(cd ? mov_no_error : mov_no_catdoc); + mov_i.set_catdoc(cd); + + if (found) check_annessi(mov_i, numreg); } // Se cartaceo preparo il file. if (F9CONF.get_has_cartexp()) // Se e' abilitata l'esportazione dei cartacei, altrimenti skip... { - if (mov_i.cartaceo) + if (mov_i.cartaceo()) { TF9_doccart filecart; TFilename file; - TString reg; reg << it->numreg; + TString reg; reg << it->numreg(); + if (filecart.mov2doc(reg, file) && file.exist()) - mov_i.nomefilecart << file; + mov_i.set_nomefilecart(file); else - { - mov_i.err = true; - mov_i.estratto = false; - mov_i.descr_err = "Non e' stato possibile reperire il file del documento cartaceo per questo movimento."; - mov_i.descr_estr = movimento_t::no_filecart; - } + mov_i.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart); } else { ok &= true; - mov_i.err = false; - mov_i.estratto = false; - mov_i.descr_estr = movimento_t::no_cartaceo; // Cartaceo che non ha bisogno di essere estratto. + mov_i.set_err("", mov_no_cartaceo); + mov_i.set_estratto(false); ++_stats.fa_skip; } } copy_file_to_webapp_fld(mov_i); } } - ok &= !mov_i.err; + ok &= mov_i.no_err(); } } else if (tipo == iva_vendite) @@ -763,34 +886,35 @@ const char* TEstrazione::diagnostica_mov() movimento_t& mov_i = *it; // Se escluso passo avanti - if (!mov_i.estratto && mov_i.descr_estr == movimento_t::escluso) + if (!mov_i.estratto() && mov_i.descr_estr() == mov_escluso) continue; - TString numreg; numreg << mov_i.numreg; - TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, numreg); - mov.read(); + const long numreg = mov_i.numreg(); + const TRectype & mov = cache().get(LF_MOV, numreg); /* Controlli per vendite cambiati: * Elettroniche solo quelle agli italiani, tutti gli altri sono cartacei */ - if (!mov_i.err && mov_i.estratto) + if (!mov_i.err() && mov_i.estratto()) { - mov_i.cartaceo = !is_doc_xml(mov); + mov_i.set_cartaceo(!is_doc_xml(mov)); + unsigned short skip = 0; - if (!_has_cartacei && mov_i.cartaceo) skip |= 0x1; - else if (pura_iva(mov)) skip |= 0x2; - else if (mov_i.datadoc.empty() || mov_i.numdoc.empty()) skip |= 0x4; + + if (!_has_cartacei && mov_i.cartaceo()) skip |= 0x1; + else + if (pura_iva(mov)) skip |= 0x2; + else if (mov_i.datadoc().empty() || mov_i.numdoc().empty()) skip |= 0x4; if(skip) { ++_stats.fv_cart_skip; - mov_i.err = false; - mov_i.estratto = false; + mov_i.reset_err(); + mov_i.set_estratto(false); switch(skip) { - case 0x1: mov_i.descr_estr = movimento_t::no_cartaceo; break; - case 0x2: mov_i.descr_estr = movimento_t::pura_iva; break; - case 0x4: mov_i.descr_estr = movimento_t::no_fv; + case 0x1: mov_i.set_descr_estr(mov_no_cartaceo); break; + case 0x2: mov_i.set_descr_estr(mov_pura_iva); break; + case 0x4: mov_i.set_descr_estr(mov_no_fv); break; default: break; } } @@ -805,46 +929,42 @@ const char* TEstrazione::diagnostica_mov() }*/ else { - std::shared_ptr cd = categorie_doc().mov2cat(mov_i.numreg); - mov_i.err = false; - mov_i.estratto = cd.get(); - mov_i.descr_estr = cd ? movimento_t::no_err : movimento_t::no_catdoc; - mov_i.catdoc = cd; + TCategorie_doc::classe_doc* cd = categorie_doc().mov2cat(mov_i.numreg()); + const bool found = cd != nullptr; + + if (found) + mov_i.reset_err(); + else + mov_i.set_err("Categoria assente", mov_no_catdoc); + mov_i.set_catdoc(cd); + if (mov_i.catdoc()) + check_annessi(mov_i, mov_i.numreg()); - if (mov_i.catdoc) - check_annessi(mov_i, mov_i.numreg); - - if (!mov_i.catdoc) + if (!mov_i.catdoc()) ++_stats.fv_nocatdoc; - if (mov_i.err) + if (mov_i.err()) ++_stats.fv_err; - else if (mov_i.estratto) + else if (mov_i.estratto()) ++_stats.fv_estr; } - if (mov_i.estratto) + if (mov_i.estratto()) { - if (mov_i.cartaceo) + if (mov_i.cartaceo()) { TF9_doccart filecart; TFilename file; - TString reg; reg << it->numreg; + TString reg; reg << it->numreg(); + if (filecart.mov2doc(reg, file) && file.exist() || grab_pdf_from_spotlite(mov_i, file) && file.exist()) - { - mov_i.nomefilecart << file; - } - else - { - mov_i.err = true; - mov_i.estratto = false; - mov_i.descr_err = "Non e' stato possibile reperire il file del documento cartaceo per questo movimento."; - mov_i.descr_estr = movimento_t::no_filecart; - } + mov_i.set_nomefilecart(file); + else + mov_i.set_err("Non e' stato possibile reperire il file del documento cartaceo per questo movimento.", mov_no_filecart); } copy_file_to_webapp_fld(mov_i); } } - ok &= !mov_i.err; + ok &= mov_i.no_err(); } } _head.stato_estr = ok ? D_GEST_OK : D_GEST_ERR; @@ -938,17 +1058,15 @@ bool TEstrazione::estrazione_iva(bool escluso) if (!bar.add_status()) break; - if (!it->estratto) + if (!it->estratto()) continue; - TLocalisamfile mov(LF_MOV); - TLocalisamfile cli(LF_CLIFO); - mov.put(MOV_NUMREG, it->numreg); - mov.read(); - cli.put(CLI_TIPOCF, mov.get(MOV_TIPO)); - cli.put(CLI_CODCF, mov.get(MOV_CODCF)); - cli.read(); + const TRectype& mov = cache().get(LF_MOV, it->numreg()); + TToken_string key = mov.get(MOV_TIPO); + key.add(mov.get(MOV_CODCF)); + + const TRectype& cli = cache().get(LF_CLIFO, key); const char tipodoc = _head.tipo_doc; const TString& name_registro = TRegistro(TCausale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()).reg()).name(); fill_id(cli, statopaiv, idfisc, paiv, codfis); @@ -963,7 +1081,7 @@ bool TEstrazione::estrazione_iva(bool escluso) iva_query.add(IVA_ANNOES, mov.get_int(MOV_ANNOES)); iva_query.add(IVA_GIVA, tipodoc); iva_query.add(IVA_TIPOG, name_registro, 10); - iva_query.add(IVA_DOCXML, it->cartaceo ? 'N' : 'S'); + iva_query.add(IVA_DOCXML, it->cartaceo() ? 'N' : 'S'); iva_query.add(IVA_TIPOCF, mov.get_char(MOV_TIPO)); iva_query.add(IVA_CODCF, mov.get_long(MOV_CODCF)); @@ -971,13 +1089,13 @@ bool TEstrazione::estrazione_iva(bool escluso) iva_query.add(IVA_IDFISC, idfisc, 30); iva_query.add(IVA_PIVA, paiv, 28); iva_query.add(IVA_CODFIS, codfis, 16); - iva_query.add(IVA_CATDOC, it->catdoc->catdoc, 10); - iva_query.add(IVA_CAUSSOS, it->catdoc->caus_sost, 6); + iva_query.add(IVA_CATDOC, it->catdoc()->catdoc, 10); + iva_query.add(IVA_CAUSSOS, it->catdoc()->caus_sost, 6); - iva_query.add(IVA_NUMDOC, it->numdoc, 20); + iva_query.add(IVA_NUMDOC, it->numdoc(), 20); iva_query.add(IVA_DATADOC, datadoc); iva_query.add(IVA_SEZIVA, mov.get(MOV_REG), 10); - iva_query.add(IVA_TIPOREG, "", 6); + iva_query.add(IVA_TIPOREG, "", 6); iva_query.add(IVA_NPROT, mov.get(MOV_PROTIVA), 20); iva_query.add(IVA_DATPROT, datareg); @@ -989,15 +1107,16 @@ bool TEstrazione::estrazione_iva(bool escluso) iva_query.add(IVA_DATAOR, TDate(20010101)); }*/ - iva_query.add(IVA_CLASDOC, it->catdoc->class_sost, 10); - iva_query.add(IVA_NOMFD, it->nomefilecart.name(), 100); + iva_query.add(IVA_CLASDOC, it->catdoc()->class_sost, 10); + iva_query.add(IVA_NOMFD, it->nomefilecart().name(), 100); // Load annessi... - if(!it->annessi.empty()) + if(!it->annessi().empty()) { - vector& ann = it->annessi; + vector& ann = it->annessi(); size_t i = 0; const size_t size = ann.size(); + iva_query.add(IVA_CLASAN1, ann[i].catdocann, 10); iva_query.add(IVA_NOMF1, ann[i++].filename, 100); // HOW DID MY LIFE COME TO THIS?... @@ -1051,7 +1170,7 @@ bool TEstrazione::estrazione_iva(bool escluso) iva_query.add(IVA_USERELA, user(), 10); iva_query.add_getdate(IVA_TIMEELA); - if (_head.tipo_doc == 'A' && !it->cartaceo) + if (_head.tipo_doc == 'A' && !it->cartaceo()) { TToken_string keys(mov.get(MOV_KEYFPPRO), ';'); fppro_db().set_keys(keys); @@ -1100,8 +1219,8 @@ void TEstrazione::set_dates() { if (_escluso) { - set_dataini(_movs[0].datareg); - set_dataend(_movs[0].datareg); + set_dataini(_movs[0].datareg()); + set_dataend(_movs[0].datareg()); } } @@ -1121,13 +1240,12 @@ TEstrazione::TEstrazione(const TString& ambiente, const bool flag_prov, const ch _head.addr_cart = addrcart; _escluso = escluso; - _error_sql = make_unique(); - _error_sql->open("f9_TEstrazione_error_sql.txt"); + _error_sql = new ofstream("f9_TEstrazione_error_sql.txt"); // Svuoto log. - FILE* f = fopen("TF9Prospetto_integr_error.txt", "w"); - fwrite("\n", sizeof(char), 1, f); - fclose(f); + ofstream f("TF9Prospetto_integr_error.txt"); + + f << "\n"; } @@ -1159,8 +1277,12 @@ void TF9_dberr::write_sqlerrlog(const TString& query) const void TF9_dberr::add(const TString& string) { - TString str; - add_str(str << "'" << string << "'"); + TString str = string; + + str.replace("'", "''"); + str.insert("'"); + str << "'"; + add_str(str); } void TF9_dberr::add(const TDate& date) @@ -1212,7 +1334,7 @@ bool TF9_dberr::del_err(const TString& codsoc, const TString& id_estr, const int return fp_db().sq_set_exec(query) && fp_db().sq_commit(); } -char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, vector& controllo_mov) +char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, TArray& controllo_mov) { TString query; query << "SELECT * FROM " F9_ERR @@ -1231,7 +1353,7 @@ char TF9_dberr::get_errori(const TString& codsoc, const TString& id_estr, vector row.add(fp_db().sq_get(i)); } - controllo_mov.insert(controllo_mov.end(), row); + controllo_mov.add(row); } query.cut(0) << "SELECT " DRD_TIPODOC " FROM " F9_DRD "\n" << "WHERE " DRD_CODSOC " = '" << codsoc << "' AND " DRD_ID_EST " = '" << id_estr << "'"; @@ -1269,7 +1391,7 @@ TF9_dberr::TF9_dberr() // TCategorie_doc /////////////////////////////////////////////////////////////////////////////////////////// -std::shared_ptr TCategorie_doc::find_causcont(const TString& caus) const +TCategorie_doc::classe_doc * TCategorie_doc::find_causcont(const TString& caus) const { for (auto it = _rows.begin(); it != _rows.end(); ++it) { @@ -1279,18 +1401,18 @@ std::shared_ptr TCategorie_doc::find_causcont(const return nullptr; } -std::shared_ptr TCategorie_doc::find_tipodoc(const TString& tipodoc) const +TCategorie_doc::classe_doc * TCategorie_doc::find_tipodoc(const TString& tipodoc) const { for (auto it = _rows.begin(); it != _rows.end(); ++it) { - const std::shared_ptr& classe = *it; + const classe_doc* classe = *it; // qui if (classe->causcont.blank() && classe->tipocaus == tipodoc) return *it; } return nullptr; } -std::shared_ptr TCategorie_doc::find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const +TCategorie_doc::classe_doc * TCategorie_doc::find_tipodocsdi(const TString& tipodocsdi, const char * tipocaus) const { for (auto it = _rows.begin(); it != _rows.end(); ++it) { @@ -1310,7 +1432,7 @@ std::vector>>::iterator TCategorie_d return _sheets_annessi.end(); } -std::shared_ptr TCategorie_doc::get_classe_doc(const TString& catdoc) +TCategorie_doc::classe_doc* TCategorie_doc::get_classe_doc(const TString& catdoc) { for(auto it = _rows.begin(); it != _rows.end(); ++it) { @@ -1328,12 +1450,14 @@ void TCategorie_doc::load_all() while (true) { const TString& appo = ini_get_string(CONFIG_DITTA, INI_PAR_MOD, INI_CATDOC, "", idx++); + if (appo == "STOP" || appo.blank()) /* STOP: Riga terminatrice */ break; - TToken_string row(appo); - classe_doc cd = { row.get(1), row.get(), row.get(), row.get(), row.get(), row.get() }; - _rows.emplace_back(std::make_shared(cd)); + TToken_string row(appo); + classe_doc * cd = new classe_doc{ row.get(1), row.get(), row.get(), row.get(), row.get(), row.get() }; + + _rows.emplace_back(cd); } idx = 0; @@ -1482,8 +1606,10 @@ void TCategorie_doc::add_categoria(const TString& catdoc, const TString& descr, { if(!(catdoc && *catdoc && class_sost && *class_sost && caus_sost && *caus_sost)) fatal_box("add_categoria failed: some parameters are NULL or keys are empty"); - classe_doc cd = { catdoc, descr, class_sost, caus_sost, causcont, tipocaus }; - _rows.emplace_back(std::make_shared(cd)); + + classe_doc * cd = new classe_doc{ catdoc, descr, class_sost, caus_sost, causcont, tipocaus }; + + _rows.emplace_back(cd); save_cat(); } @@ -1532,8 +1658,9 @@ TString_array TCategorie_doc::get_array_rows(const bool traduci) TString_array sa(_rows.size()); for(auto it = _rows.begin(); it != _rows.end(); ++it) { - const shared_ptr& row = *it; + classe_doc *row = *it; // qui TToken_string ts; + ts.add(row->catdoc); ts.add(row->descr); ts.add(!traduci ? row->class_sost : traduci_class_sost(row->class_sost)); @@ -1607,20 +1734,17 @@ std::shared_ptr TCategorie_doc::get_sheet_ann(const TString& catdo return it->second; } -std::shared_ptr TCategorie_doc::mov2cat(const int numreg) +TCategorie_doc::classe_doc * TCategorie_doc::mov2cat(const long numreg) { // Leggo la causale e cerco la corrispondente nelle categorie documentali, se c'e'. // Guardo le colonne causale cont., tipodoc, class. cat. (opcee) - TLocalisamfile mov(LF_MOV); - mov.put(MOV_NUMREG, numreg); - mov.read(); - + const TRectype & mov = cache().get(LF_MOV, numreg); const TString& caus = mov.get(MOV_CODCAUS); - const TCausale c(caus, mov.get_date(MOV_DATAREG).year()); + const TCausale & c = cached_causale(caus, mov.get_date(MOV_DATAREG).year()); const TString& tipodoc = c.tipo_doc(); // Cerco se ho un record che abbia specificata quella caus. contabile - std::shared_ptr cat = find_causcont(caus); + classe_doc * cat = find_causcont(caus); if (cat != nullptr) return cat; // Altrimenti cerco per tipo documento diff --git a/src/f9/f9lib02.cpp b/src/f9/f9lib02.cpp index 0914762af..8357f6b0d 100644 --- a/src/f9/f9lib02.cpp +++ b/src/f9/f9lib02.cpp @@ -162,11 +162,11 @@ bool TF9_doccart::add_cart(const TFilename& file, const TString& numreg, const b return true; } -bool TF9_doccart::doc_already_exists(const TFilename& file, _Out_ TString& numreg, _Out_ bool& annesso) +bool TF9_doccart::doc_already_exists(const TFilename& file, TString& numreg, bool& annesso) { numreg = ""; annesso = false; - _tdocs.zero(); + _tdocs.zero(); _tdocs.setkey(2); _tdocs.put(F9C_FILENAME, file.name()); bool ok = _tdocs.read() == NOERR; @@ -593,7 +593,9 @@ bool TF9Prospetto_integr::operator()(const char* numreg_acq, const char* numreg_ _items = _prosp_rs->items(); if (_items == 0) { - FILE* log = fopen("TF9Prospetto_integr_error.txt", "a"); + FILE* log; + + fopen_s(&log, "TF9Prospetto_integr_error.txt", "a"); if (!_prosp_rs->last_exec()) { if (log != nullptr)