From 09c6369bbbb0d81c7a7cca933fb5766b543fda4b Mon Sep 17 00:00:00 2001 From: Simoe Date: Wed, 15 Mar 2023 17:56:23 +0100 Subject: [PATCH] Primo Commit: Creata la struttura del programma ed imbastito il giro per la parte di vendita, per gli abbinamenti automatici e per quelli manuali. To do next: Fixare il progressivo per archiviazione contigue finalizzare l'abbinamento manuale ed introdurre il campo MOV_KEYPAF negli archivi di campo (probabilmente nei movimenti) --- build/f90.vcxproj | 14 +- build/f90.vcxproj.filters | 37 ++- src/f1/f1lib.h | 1 + src/f9/f90.cpp | 1 + src/f9/f90.h | 1 + src/f9/f90100a.h | 1 + src/f9/f9lib.h | 29 ++- src/f9/f9lib01.cpp | 490 +++++++++++++++++++++++++++++++++++++- src/fp/fpmenu.men | 7 +- 9 files changed, 543 insertions(+), 38 deletions(-) diff --git a/build/f90.vcxproj b/build/f90.vcxproj index ac79b6b4d..b5767b4ae 100644 --- a/build/f90.vcxproj +++ b/build/f90.vcxproj @@ -209,6 +209,7 @@ + @@ -222,6 +223,9 @@ + + + @@ -232,6 +236,8 @@ + + @@ -247,14 +253,6 @@ true - - - - - - - - diff --git a/build/f90.vcxproj.filters b/build/f90.vcxproj.filters index 9270b4d88..ec26a173c 100644 --- a/build/f90.vcxproj.filters +++ b/build/f90.vcxproj.filters @@ -19,9 +19,6 @@ {28870b23-e896-4312-855b-049305092f1d} - - {95c95f84-ca93-4c2f-b1cf-e94922dfa7ef} - @@ -57,6 +54,15 @@ Headers + + Headers + + + Headers + + + Headers + @@ -80,6 +86,9 @@ Sources + + Sources + @@ -106,6 +115,12 @@ Masks + + Masks + + + Masks + @@ -118,22 +133,6 @@ SQL - - - Recdesc - - - Recdesc - - - - - Recdesc - - - Recdesc - - Menu diff --git a/src/f1/f1lib.h b/src/f1/f1lib.h index 13cb0a4ca..3bc144e85 100644 --- a/src/f1/f1lib.h +++ b/src/f1/f1lib.h @@ -85,6 +85,7 @@ public: TFppro(TToken_string& keys) : TFppro() { set_keys(keys); } }; + class TProtocollo : TObject { TString _tipoprot; diff --git a/src/f9/f90.cpp b/src/f9/f90.cpp index 4565b9822..73f88e5f5 100644 --- a/src/f9/f90.cpp +++ b/src/f9/f90.cpp @@ -14,6 +14,7 @@ int main(int argc, char** argv) case 2: rt = f90300(argc, argv); break; // Gestione documenti cartacei case 3: rt = f90400(argc, argv); break; // Test classi case 4: rt = f90500(argc, argv); break; // Ripristino archiviazioni + case 5: rt = f90600(argc, argv); break; // Archiviazione Integrazioni } return rt; } diff --git a/src/f9/f90.h b/src/f9/f90.h index dfe558ed3..069a1f6a1 100644 --- a/src/f9/f90.h +++ b/src/f9/f90.h @@ -6,5 +6,6 @@ int f90200(int argc, char* argv[]); int f90300(int argc, char* argv[]); int f90400(int argc, char* argv[]); int f90500(int argc, char* argv[]); +int f90600(int argc, char* argv[]); #endif // _F90_H_ diff --git a/src/f9/f90100a.h b/src/f9/f90100a.h index f3e42e0d5..30e334aea 100644 --- a/src/f9/f90100a.h +++ b/src/f9/f90100a.h @@ -4,6 +4,7 @@ #define B_SHOWESTR 203 #define B_SHOWESCL 204 + #define F_SEL 101 #define F_ARCH_B 102 #define F_IDESTR 103 diff --git a/src/f9/f9lib.h b/src/f9/f9lib.h index 23ca2b181..1cde4f147 100644 --- a/src/f9/f9lib.h +++ b/src/f9/f9lib.h @@ -66,6 +66,9 @@ struct statistics size_t fv_err; size_t fv_estr; size_t fv_nocatdoc; + size_t int_match; + size_t int_nomatch; + size_t int_err; }; extern statistics _stats; @@ -115,6 +118,14 @@ enum state_fppro err_read_db = 999 // Errore lettura da fppro }; +enum state_estr_int +{ + int_with_err = -1, // Movimento associato male con FPPRO + guessed_int = 100, + no_guessed_int = 0, + err_read_db_int = 999 // Errore lettura da fppro +}; + class TF9_config { // todo: controllare che siano sqlsafe @@ -326,6 +337,7 @@ class TMovimento_estr : public TObject // aggiungere metodi per TArray TString _reg_protiva; TString _descr; state_fppro _state; + state_estr_int _state_int; TString _descr_err; // Messaggio di errore visibile dal controllo estrazione. bool _estratto; err_mov _descr_estr; // Messaggio di informazioni visibile dal 'Apri Estr.' @@ -371,6 +383,7 @@ public: void set_err(const char * descr = "", err_mov descr_estr = mov_no_error); void reset_err() { set_err(); } void set_state(state_fppro state) { _state = state; } + void set_state_int(state_estr_int state) { _state_int = 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; } @@ -424,12 +437,14 @@ class TEstrazione : public TObject * \return \a not_fa se il movimento passato non è una fattura. */ static state_fppro check_fppro(int numreg); + state_estr_int checkPafw3_int(int numreg); + bool guess_the_int(const TLocalisamfile& mov); bool check_periodo_def() const; void copy_file_to_webapp_fld(TMovimento_estr& movimento) const; - 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; } - bool is_doc_xml(const TRectype& mov); - bool load_docs(TMovimento_estr& movimento) { return movimento.load_docs(); } + 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; } + bool is_doc_xml(const TRectype& mov); + bool load_docs(TMovimento_estr& movimento) { return movimento.load_docs(); } // 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. // bool stampa_documento(const TMovimento_estr& movimento, TFilename& file); bool grab_pdf_from_spotlite(const TMovimento_estr& movimento, TFilename& file) const; @@ -465,6 +480,8 @@ public: * \return D_GEST_ERR (02) se la diagnostica ha riportato degli errori. */ const char* diagnostica_mov(); + /** DIAGNOSTICA GESTIONALE SPECIALIZZATA PER TD16/TD17/TD18....*/ + const char* diagnostica_mov_integrazione(); /** Estrazione per pacchetti "normali" (non da esclusi). * Viene chiamata dall'handler estrai_handler: bottone estrai nella maschera estrazione. * @@ -479,6 +496,10 @@ public: * \return true Scrittura sul db senza errori. * \return false Errore scrittura db. */ bool estrazione_iva(bool escluso = false); + + + result_estr TEstrazione::estrai_integrazioni(); + bool estrazione_iva_int(bool escluso = false); bool exist_prov() const; /**< Controllo che esista per questo stesso periodo una estrazione provvisoria. */ /** Controllo se esiste un periodo antecedente a questa estrazione che non e' mai stato estratto definitivamente. */ bool gap_periodo() const; diff --git a/src/f9/f9lib01.cpp b/src/f9/f9lib01.cpp index 628601c4f..cc16e77d9 100644 --- a/src/f9/f9lib01.cpp +++ b/src/f9/f9lib01.cpp @@ -15,7 +15,7 @@ #define MODE_SHEETS 0xC -statistics _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +statistics _stats = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; const TString & get_numdoc_exp_fp(const int numreg) { @@ -451,6 +451,65 @@ state_fppro TEstrazione::check_fppro(int numreg) return not_fa; } +state_estr_int TEstrazione::checkPafw3_int(int numreg) +{ + TLocalisamfile mov(LF_MOV); + mov.put(MOV_NUMREG, numreg); + if (mov.read() == NOERR) + { + if (guess_the_int(mov)) + return guessed_int; + return no_guessed_int; + } + return int_with_err; +} + +bool TEstrazione::guess_the_int(const TLocalisamfile& mov) +{ + // Prendo il fornitore del mov per controllare la p.iva + long codcf = mov.get_long(MOV_CODCF); + TCli_for forn = cached_clifor('C', mov.get_long(MOV_CODCF)); + + const TString4 statopiva(forn.get(CLI_STATOPAIV)); + + const real tot = mov.get_real(MOV_TOTDOC) + mov.get_real(MOV_RITFIS) + mov.get_real(MOV_RITSOC); + TString numdoc = mov.get(MOV_NUMDOCEXT); + + if (numdoc.blank()) + numdoc = mov.get(MOV_NUMDOC); + // Controllo datadoc - numdoc - totdoc - p.iva + + TString query; + + query << "SELECT PQ_KEYPRGINVIO AS KEYPRGINVIO, PQ_KEYHEADERFATT AS KEYHEADERFATT, PQ_KEYBODYFATT AS KEYBODYFATT, P7_DATA AS DATA,\n" << + "\tP7_NUMERO AS NUMDOC, PQ_IMPTOTDOC AS IMPTOTDOC, P2_FISCIVAPAESE AS STATOPIVA, P2_FISCIVACOD AS PIVA FROM PAA2700F\n" << + "JOIN PAA0700F ON PQ_KEYPRGINVIO = P7_KEYPRGINVIO AND PQ_KEYHEADERFATT = P7_KEYHEADERFATT AND PQ_KEYBODYFATT = P7_KEYBODYFATT\n" << + "JOIN PAA0200F ON PQ_KEYPRGINVIO = P2_KEYPRGINVIO AND PQ_KEYHEADERFATT = P2_KEYHEADERFATT AND PQ_KEYBODYFATT = P2_KEYBODYFATT\n" << + "WHERE P7_DATA = '" << mov.get_date(MOV_DATADOC).date2ansi() << "' AND \n" << + "(P7_NUMERO = '" << numdoc << "' OR P7_NUMERO LIKE '%" << numdoc << "%') \n"; + if (statopiva.full()) + query << " AND \n" << "P2_FISCIVAPAESE = '" << statopiva << "'"; + query << " AND \n" << "P2_FISCIVACOD = '" << forn.get(CLI_PAIV) << "'"; + if (forn.gruppo_IVA()) + query << " AND \n" "P2_COCAZZO = '" << forn.get(CLI_COFI) << "'"; // cazzo; + if (tot < 0) + query << " AND \n" "(PQ_IMPTOTDOC = " << tot << " OR PQ_IMPTOTDOC = " << abs(tot) << ")"; + else + query << " AND \n" "PQ_IMPTOTDOC = " << tot; + + bool ok = fp_db().sq_set_exec(query); + + if (ok && (fp_db().sq_items() == 1)) + { + //CAPIRE COSA FARE QUI DENTRO + //_keys = _db->sq_get("KEYPRGINVIO"); + //_keys.add(_db->sq_get("KEYHEADERFATT")); + //_keys.add(_db->sq_get("KEYBODYFATT")); + return true; + } + return false; +} + bool TEstrazione::check_periodo_def() const { TString query; @@ -1046,9 +1105,6 @@ const char* TEstrazione::diagnostica_mov() if (mov_i.estratto()) { - if (mov_i.numreg() == 41400) { - int here = 0; - } if (mov_i.cartaceo()) { TFilename file; @@ -1083,6 +1139,171 @@ const char* TEstrazione::diagnostica_mov() return _head.stato_estr; } +const char* TEstrazione::diagnostica_mov_integrazione() +{ + bool ok = true; + const TipoIVA tipo = get_tipoiva(); + _stats.total = _movs.size(); + if (tipo == iva_vendite) + { + // Controlli per le fatture di acquisto + TProgress_monitor bar(_movs.items(), "Controllo stato movimenti di acquisto"); + + FOR_EACH_ARRAY_ITEM(_movs, r, obj) + { + if (bar.add_status()) + { + TMovimento_estr & mov_i = (TMovimento_estr &)*obj; + + // Se gia' escluso passo avanti + + if (!mov_i.estratto() && mov_i.descr_estr() == mov_escluso) + continue; + + if (mov_i.no_err() && mov_i.estratto()) + { + + const long numreg = mov_i.numreg(); + const TRectype & mov = cache().get(LF_MOV, numreg); + + mov_i.set_cartaceo(!is_doc_xml(mov)); + + const state_estr_int res = checkPafw3_int(numreg); + + switch (res) + { + case guessed_int: + ok &= true; + mov_i.set_estratto(true); + ++_stats.int_match; + break; + case no_guessed_int: + ok &= false; + mov_i.reset_err(); + mov_i.set_err("Non è stato possibile trovare il documento elettronico da abbinare", mov_notfound_elet); + ++_stats.int_nomatch; + break; + case int_with_err: + ok &= false; + mov_i.set_estratto(false); + ++_stats.int_err; + break; + default: break; + } + + if (mov_i.state() == null_state) + mov_i.set_state_int(res); + + } + } + } + } + else if (tipo == iva_acquisti) + { + // Controlli per le fatture di vendita (AGGIORNARE STATS QUI) + TProgress_monitor bar(_movs.items(), "Controllo stato movimenti di vendita"); + + FOR_EACH_ARRAY_ITEM(_movs, r, obj) + { + if (bar.add_status()) + { + TMovimento_estr & mov_i = (TMovimento_estr &)*obj; + + // Se escluso passo avanti + if (!mov_i.estratto() && mov_i.descr_estr() == mov_escluso) + continue; + + 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()) + { + mov_i.set_cartaceo(false); // ci deve essere ? + + 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 (skip) + { + ++_stats.fv_cart_skip; + mov_i.reset_err(); + mov_i.set_estratto(false); + switch (skip) + { + 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; + } + } + else + { + TClasse_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); + if (cd != nullptr) + check_annessi(mov_i); + + if (!mov_i.catdoc(categorie_doc())) + ++_stats.fv_nocatdoc; + if (mov_i.err()) + ++_stats.fv_err; + else if (mov_i.estratto()) + ++_stats.fv_estr; + } + + if (mov_i.estratto()) + { + if (mov_i.numreg() == 41400) { + int here = 0; + } + if (mov_i.cartaceo()) + { + TFilename file; + + // if (filecart.mov2doc(mov_i.numreg(), file) && file.exist() || grab_pdf_from_spotlite(mov_i, file) && file.exist()) + if (grab_pdf_from_spotlite(mov_i, file) && file.exist()) + mov_i.set_nomefiledoc(file); + else + 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); + } + + } + ok &= mov_i.no_err(); + } + } + } + + _head.stato_estr = ok ? D_GEST_OK : D_GEST_ERR; + return _head.stato_estr; +} + result_estr TEstrazione::estrai() { // Se non c'e' nessun movimento non sto nemmeno a scrivere il record di estrazione. @@ -1357,6 +1578,267 @@ bool TEstrazione::estrazione_iva(bool escluso) return stato; } +result_estr TEstrazione::estrai_integrazioni() +{ + // 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. + // Do' errore ed esco subito. + result_estr res = estr_ok; + if (_movs.empty()) + { + warning_box("Non esistono movimenti estraibili per il periodo selezionato."); + return estr_stop; + } + if (!_escluso && !_head.flag_prov) + { + // Avviso nel caso in cui si stia facendo un'estrazione definitiva di un periodo di cui non si e' mai fatta + // una prova provvisoria. + if (!exist_prov()) + { + if (!noyes_box("Attenzione, non e' mai stata fatta alcuna\nestrazione provvisoria per questo periodo.\nContinuare comunque?")) + return estr_stop; + } + } + // Non so come usare questi 18 caratteri... + // Uso dati anche se gia' noti in altri campi (I know..) + un numero incrementale. + _head.id_estr.cut(0) << 'R' << today.date2ansi() << (_head.flag_prov ? "P" : "D") << next_estr_today(_head.tipo_doc); + _head.user = user(); + // Eseguo controllo sui movimenti e segno in testata lo stato + _head.stato_estr = IN_DIAGN; // "01" che verra' quasi subito rimpiazzato dal risultato della diagnostica. + if (_escluso) + set_dates(); // Se escluso imposto data inizio e fine uguali + + // Scrivo record estrazione (in stato '01': in diagnostica). + const bool ok = insert_into_drd(); + + if (!ok) + { + TString msg; + + msg << "Errore database: impossibile scrivere nuova estrazione.\n" + << fp_db().sq_get_text_error(false); + error_box(msg); + return estr_err_db_drd; + } + + // Faccio partire la diagnostica e mi salvo il nuovo stato. + diagnostica_mov_integrazione(); + + + //ARRIVATO QUI + insert_into_f9movestr(); + + if (_head.stato_estr == D_GEST_ERR) + { + warning_box("Attenzione l'estrazione ha prodotto degli errori.\n" + "Controllare e correggere eventuali problemi\ndal Controllo Estrazione."); + // Se in errore, esporto lista errori sul db + if (!export_error_list()) + warning_box("Errore scrittura db. Controllare log errori."); + res = estr_diag_err; // Errore diagnostica gestionale + } + + // Se va tutto ben fino a qui, posso andare a scrivere nella + // tabella IVA i movimenti. F9IVA + if (res == estr_ok) + { + res = estrazione_iva_int() ? estr_ok : estr_err_db_iva; + if (res == estr_err_db_iva) + _head.stato_estr = D_GEST_ERR; + } + update_drd_stato_estr(); + return res; +} + +bool TEstrazione::estrazione_iva_int(bool escluso) +{ + TString statopaiv, idfisc, paiv, codfis; + bool stato = true; + + TProgress_monitor bar(_movs.items(), "Estrazione dati IVA"); + + FOR_EACH_ARRAY_ITEM(_movs, r, obj) + { + TMovimento_estr & mov_i = (TMovimento_estr &)*obj; + + if (bar.add_status() && mov_i.estratto()) + { + const TRectype& mov = cache().get(LF_MOV, mov_i.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 TCausale & caus = cached_causale(mov.get(MOV_CODCAUS), mov.get_date(MOV_DATAREG).year()); + const TString& name_registro = caus.reg().name();; + fill_id(cli, statopaiv, idfisc, paiv, codfis); + TDate datadoc = mov.get_date(MOV_DATADOC); + TDate datareg = mov.get_date(MOV_DATAREG); + + TIva_insert_prepared_stat iva_query; /////////QUIIIIIII/// + + iva_query.add(IVA_CODSOC, _head.cod_soc, 10); + iva_query.add(IVA_IDLAN, _head.id_estr, 18); + iva_query.add(IVA_FLAG_PD, _head.flag_prov ? 'P' : 'D'); + iva_query.add(IVA_ANNOES, mov.get_int(MOV_ANNOES)); + iva_query.add(IVA_GIVA, tipodoc); + iva_query.add(IVA_TIPOG, name_registro, 10); + + long numdoc = mov.get_long(MOV_NUMDOC); + bool has_xml = !mov_i.err(); //si può fare un controllo migliore + iva_query.add(IVA_DOCXML, has_xml ? 'S' : 'N'); + + iva_query.add(IVA_TIPOCF, mov.get_char(MOV_TIPO)); + iva_query.add(IVA_CODCF, mov.get_long(MOV_CODCF)); + iva_query.add(IVA_NUMOR, mov.get_long(MOV_NUMREG)); + + iva_query.add(IVA_RAGSOC, cli.get(CLI_RAGSOC), 60); + 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, mov_i.catdoc(categorie_doc())->catdoc(), 10); + + const TRegistro& reg = cached_registro(mov.get(MOV_REG), mov.get_int(MOV_ANNOIVA)); + + if (reg.iva() == iva_vendite) + { + + int anno = mov.get_int(MOV_DANNO); + TString tipodocsdi; + + if (anno > 0) + { + const char provv = mov.get(MOV_DPROVV)[0]; + const TString& codnum = mov.get(MOV_DCODNUM); + const long ndoc = mov.get_long(MOV_DNDOC); + + TDocumento doc(provv, anno, codnum, ndoc); + iva_query.add(IVA_CAUSSOS, tipo_doc_sdi(doc), 6); + } + else + tipodocsdi = caus.tipodocsdi(); + if (tipodocsdi.blank()) + tipodocsdi = mov_i.catdoc(categorie_doc())->caus_sost(); + + if (tipodocsdi.full()) + iva_query.add(IVA_CAUSSOS, tipodocsdi, 6); + } + else + { + TToken_string key(mov.get((MOV_KEYFPPRO)), ';'); + + if (key.full()) + { + TFppro fppro(key); + const TString& tipodoc = fppro.get_tipodoc(); + + if (tipodoc.full()) + iva_query.add(IVA_CAUSSOS, tipodoc, 6); + else + iva_query.add(IVA_CAUSSOS, mov_i.catdoc(categorie_doc())->caus_sost(), 6); + } + else + iva_query.add(IVA_CAUSSOS, mov_i.catdoc(categorie_doc())->caus_sost(), 6); + } + iva_query.add(IVA_NUMDOC, mov_i.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_NPROT, mov.get(MOV_PROTIVA), 20); + iva_query.add(IVA_DATPROT, datareg); + + + 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 DA TESTARE... + if (mov_i.allegati()) + { + TString_array & docs = mov_i.documenti_allegati(); + int i = 0; + const int size = docs.items(); + + iva_query.add(IVA_CLASAN1, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF1, docs.row(i++).get(0), 100); + // HOW DID MY LIFE COME TO THIS?... + if (size > i) + { + iva_query.add(IVA_CLASAN2, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF2, docs.row(i++).get(0), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN3, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF3, docs.row(i++).get(0), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN4, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF4, docs.row(i++).get(0), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN5, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF5, docs.row(i++).get(0), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN6, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF6, docs.row(i++).get(0), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN7, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF7, docs.row(i++).get(0), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN8, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF8, docs.row(i++), 100); + } + if (size > i) + { + iva_query.add(IVA_CLASAN9, docs.row(i).get(2), 10); + iva_query.add(IVA_NOMF9, docs.row(i++).get(0), 100); + } + } + + iva_query.add(IVA_USERELA, user(), 10); + iva_query.add_getdate(IVA_TIMEELA); + + /* DA VEDERE + if (_head.tipo_doc == 'A' && !mov_i.cartaceo()) + { + TToken_string keys(mov.get(MOV_KEYFPPRO), ';'); + fppro_db().set_keys(keys); + iva_query.add(IVA_TIPPROT, fppro_db().get_tipoprot(), 2); + iva_query.add(IVA_ANNPROT, TVariant(fppro_db().get_annoprot()).as_int()); + iva_query.add(IVA_NUMPROT, fppro_db().get_numprot(), 10); // Non controllo che sia in realta' un numero... + iva_query.add(IVA_TIMERIC, TDate(fppro_db().get_dataoraric())); + } + */ + + TString sql; + + //DA MIGLIORARE IL LOG DI ERRORE + long a = mov_i.numreg(); + + bool ok = iva_query.get(sql); + + if (ok) + ok = fp_db().sq_set_exec(sql); + if (ok) + ok = fp_db().sq_commit(); + if (!ok) + write_errorsql_log(sql); + + stato &= ok; + } + } + return stato; +} + bool TEstrazione::exist_prov() const { TString query; query << "SELECT * FROM " F9_DRD "\n" << diff --git a/src/fp/fpmenu.men b/src/fp/fpmenu.men index 06c4672d7..53a5af860 100644 --- a/src/fp/fpmenu.men +++ b/src/fp/fpmenu.men @@ -33,8 +33,9 @@ Picture = Module = f9 Flags = "" Item_01 = "Estrazioni", "f90 -0", "" -Item_02 = "Categorie documentali", "f90 -1", "" -Item_03 = "Gestione file doc. cartacei", "f90 -2", "" -Item_04 = "Ripristino estrazioni", "f90 -4", "" +Item_02 = "Archiviazione integrazioni", "f90 -5", "" +Item_03 = "Categorie documentali", "f90 -1", "" +Item_04 = "Gestione file doc. cartacei", "f90 -2", "" +Item_05 = "Ripristino estrazioni", "f90 -4", ""