TransactionServerUtils.java

  1. /*
  2.  * GovWay - A customizable API Gateway
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.core.transazioni.utils;

  23. import java.security.SecureRandom;
  24. import java.sql.Connection;
  25. import java.sql.PreparedStatement;
  26. import java.sql.ResultSet;
  27. import java.sql.Timestamp;
  28. import java.util.ArrayList;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.openspcoop2.core.commons.CoreException;
  33. import org.openspcoop2.core.commons.DBUtils;
  34. import org.openspcoop2.core.commons.IDAOFactory;
  35. import org.openspcoop2.core.constants.CostantiDB;
  36. import org.openspcoop2.core.transazioni.IdTransazioneApplicativoServer;
  37. import org.openspcoop2.core.transazioni.Transazione;
  38. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  39. import org.openspcoop2.core.transazioni.dao.ITransazioneApplicativoServerService;
  40. import org.openspcoop2.core.transazioni.dao.jdbc.JDBCTransazioneApplicativoServerService;
  41. import org.openspcoop2.core.transazioni.dao.jdbc.JDBCTransazioneService;
  42. import org.openspcoop2.core.transazioni.dao.jdbc.converter.TransazioneFieldConverter;
  43. import org.openspcoop2.generic_project.beans.UpdateField;
  44. import org.openspcoop2.generic_project.exception.MultipleResultException;
  45. import org.openspcoop2.generic_project.exception.NotFoundException;
  46. import org.openspcoop2.generic_project.exception.NotImplementedException;
  47. import org.openspcoop2.generic_project.exception.ServiceException;
  48. import org.openspcoop2.generic_project.expression.IPaginatedExpression;
  49. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  50. import org.openspcoop2.utils.Utilities;
  51. import org.openspcoop2.utils.date.DateManager;
  52. import org.openspcoop2.utils.date.DateUtils;
  53. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  54. import org.openspcoop2.utils.sql.Case;
  55. import org.openspcoop2.utils.sql.CastColumnType;
  56. import org.openspcoop2.utils.sql.ISQLQueryObject;
  57. import org.openspcoop2.utils.sql.SQLObjectFactory;
  58. import org.slf4j.Logger;

  60. /**     
  61.  * TransactionServerUtils
  62.  *
  63.  * @author Poli Andrea (poli@link.it)
  64.  * @author $Author$
  65.  * @version $Rev$, $Date$
  66.  */
  67. public class TransactionServerUtils {

  69.     private TransactionServerUtils() {}
  70.     
  71.     // *** SAVE ***
  72.     
  73.     public static boolean recover(ITransazioneApplicativoServerService transazioneService, TransazioneApplicativoServer serverInfoParam) throws CoreException, ServiceException, NotImplementedException, NotFoundException, MultipleResultException  {
  74.         
  75.         String idTransazione = serverInfoParam.getIdTransazione();
  76.         if(idTransazione==null) {
  77.             throw new CoreException("IdTransazione non esistente nel contesto");
  78.         }
  79.         
  80.         String servizioApplicativoErogatore = serverInfoParam.getServizioApplicativoErogatore();
  81.         if(servizioApplicativoErogatore==null) {
  82.             throw new CoreException("Id servizioApplicativoErogatore non esistente nel contesto");
  83.         }
  84.         
  85.         boolean firstEntry = serverInfoParam.getDataUscitaRichiesta()==null && serverInfoParam.getDataPrelievoIm()==null && serverInfoParam.getDataEliminazioneIm()==null;
  86.         
  87.         if(firstEntry) {
  88.             return save(transazioneService, serverInfoParam, false, false, true, false, null);      
  89.         }
  90.         else {
  91.             IdTransazioneApplicativoServer idTransazioneApplicativoServer = new IdTransazioneApplicativoServer();
  92.             idTransazioneApplicativoServer.setIdTransazione(idTransazione);
  93.             idTransazioneApplicativoServer.setServizioApplicativoErogatore(servizioApplicativoErogatore);
  94.             if(transazioneService.exists(idTransazioneApplicativoServer)) {
  95.                 
  96.                 TransazioneApplicativoServer transazioneApplicativoServer = transazioneService.get(idTransazioneApplicativoServer);
  97.                 if(!transazioneApplicativoServer.isConsegnaTerminata() && transazioneApplicativoServer.getDataEliminazioneIm()==null && transazioneApplicativoServer.getDataMessaggioScaduto()==null) {
  98.                     boolean useSelectForUpdate = true;
  99.                     /*
  100.                      * Grazie alla select for update riesco a mettere il lock solamente sulla riga interessata
  101.                      */
  102.                     return save(transazioneService, serverInfoParam, true, false, true, useSelectForUpdate, null);
  103.                 }
  104.                 // else ho già registrato l'ultima informazione, è inutile fare update delle informazioni parziali.
  105.                 else {
  106.                     return false;
  107.                 }
  108.             }
  109.             else {
  110.                 throw new CoreException("In attesa della registrazione dell'informazione capostipite");
  111.             }
  112.         }
  113.         
  114.     }
  115.     
  116.     public static boolean save(ITransazioneApplicativoServerService transazioneService, TransazioneApplicativoServer serverInfoParam, boolean update, boolean throwNotFoundIfNotExists, boolean recover,
  117.             boolean useSelectForUpdate, List<String> timeDetails) throws CoreException, ServiceException, NotImplementedException, NotFoundException, MultipleResultException {
  118.         
  119.         if(recover) {
  120.             // nop
  121.         }
  122.         
  123.         String idTransazione = serverInfoParam.getIdTransazione();
  124.         if(idTransazione==null) {
  125.             throw new CoreException("IdTransazione non esistente nel contesto");
  126.         }
  127.         
  128.         String servizioApplicativoErogatore = serverInfoParam.getServizioApplicativoErogatore();
  129.         if(servizioApplicativoErogatore==null) {
  130.             throw new CoreException("Id servizioApplicativoErogatore non esistente nel contesto");
  131.         }
  132.         
  133.         /**System.out.println("SAVE id["+idTransazione+"] ["+servizioApplicativoErogatore+"] update:"+update+" ....");*/
  134.         
  135.         String protocol = serverInfoParam.getProtocollo();
  136.         if(protocol==null) {
  137.             throw new CoreException("Protocollo non esistente nel contesto");
  138.         }
  139.         
  140.         IdTransazioneApplicativoServer idTransazioneApplicativoServer = new IdTransazioneApplicativoServer();
  141.         idTransazioneApplicativoServer.setIdTransazione(idTransazione);
  142.         idTransazioneApplicativoServer.setServizioApplicativoErogatore(servizioApplicativoErogatore);
  143.         
  144.         
  145.         
  146.         if(update) {
  147.             
  148.             long timeStart = -1;
  149.             if(timeDetails!=null) {
  150.                 timeStart = DateManager.getTimeMillis();
  151.             }
  152.             
  153.             // prima era inefficiente: faceva 2 query
  154.             // adesso e' stata trasformata in efficiente e fa una unica query con limit 1
  155.             TransazioneApplicativoServer transazioneApplicativoServerReadFromDB = null;
  156.             IdTransazioneApplicativoServer idTransazioneApplicativoServerReadFromDB = null;
  157.             if(useSelectForUpdate) {
  158.                 JDBCTransazioneApplicativoServerService transazioneServiceSearch = (JDBCTransazioneApplicativoServerService) transazioneService;
  159.                 try {
  160.                     transazioneServiceSearch.enableSelectForUpdate();
  161.                     transazioneApplicativoServerReadFromDB = transazioneService.get(idTransazioneApplicativoServer);
  162.                 }finally {
  163.                     transazioneServiceSearch.disableSelectForUpdate();
  164.                 }
  165.                 // con la select for update devo poi usare lo stesso comando di WHERE poichè ho messo un lock sulla riga
  166.                 // uso quindi idTransazioneApplicativoServer che non possiede l'id long settato
  167.                 idTransazioneApplicativoServerReadFromDB = idTransazioneApplicativoServer; 
  168.             }
  169.             else{
  170.                 transazioneApplicativoServerReadFromDB = transazioneService.get(idTransazioneApplicativoServer);
  171.                 idTransazioneApplicativoServerReadFromDB = new IdTransazioneApplicativoServer();
  172.                 idTransazioneApplicativoServerReadFromDB.setId(transazioneApplicativoServerReadFromDB.getId());
  173.             }
  174.             
  175.             if(timeDetails!=null) {
  176.                 long timeEnd =  DateManager.getTimeMillis();
  177.                 long timeProcess = timeEnd-timeStart;
  178.                 timeDetails.add("readFromDB:"+timeProcess);
  179.                 
  180.                 timeStart = DateManager.getTimeMillis();
  181.             }
  182.             
  183.             if(throwNotFoundIfNotExists) {
  184.                 // non più usato
  185.             }
  186.             /**
  187.              * Leggermente inefficiente per via del limit 2 con cui viene implementata la find
  188.             org.openspcoop2.generic_project.expression.IExpression expression = transazioneService.newExpression();
  189.             expression.equals(TransazioneApplicativoServer.model().ID_TRANSAZIONE, idTransazione);
  190.             expression.and();
  191.             expression.equals(TransazioneApplicativoServer.model().SERVIZIO_APPLICATIVO_EROGATORE, servizioApplicativoErogatore);
  192.             TransazioneApplicativoServer transazioneApplicativoServerReadFromDB = null;
  193.             try {
  194.                 transazioneApplicativoServerReadFromDB = transazioneService.find(expression);
  195.             }catch(NotFoundException notfound) {
  196.                 if(throwNotFoundIfNotExists) {
  197.                     throw notfound;
  198.                 }
  199.                 else {
  200.                     return false;
  201.                 }
  202.             }*/
  203.             
  204.             // aggiorno data registrazione per controllo effettuato durante l'aggiornamento della transazione (metodo sotto: aggiornaInformazioneConsegnaTerminata)
  205.             serverInfoParam.setDataRegistrazione(transazioneApplicativoServerReadFromDB.getDataRegistrazione());
  206.             
  207.                         
  208.             if(serverInfoParam.getDataMessaggioScaduto()!=null) {
  209.                 
  210.                 if( transazioneApplicativoServerReadFromDB.getDataMessaggioScaduto()!=null ) {
  211.                     return false; // l'informazione salvata sul database indica già un messaggio scaduto.
  212.                 }
  213.                 
  214.                 // date
  215.                 transazioneApplicativoServerReadFromDB.setDataMessaggioScaduto(serverInfoParam.getDataMessaggioScaduto());
  216.                 
  217.             }
  218.             else if(serverInfoParam.getDataEliminazioneIm()!=null) {
  219.                 
  220.                 if( transazioneApplicativoServerReadFromDB.getDataEliminazioneIm()!=null ) {
  221.                     return false; // l'informazione salvata sul database indica già un messaggio eliminato via I.M..
  222.                 }
  223.                 
  224.                 // date
  225.                 transazioneApplicativoServerReadFromDB.setDataEliminazioneIm(serverInfoParam.getDataEliminazioneIm());
  226.                 
  227.                 // cluster id
  228.                 transazioneApplicativoServerReadFromDB.setClusterIdEliminazioneIm(serverInfoParam.getClusterIdEliminazioneIm());
  229.                 
  230.                 // segno come completata
  231.                 transazioneApplicativoServerReadFromDB.setConsegnaTerminata(true);
  232.                 
  233.             }
  234.             else if(serverInfoParam.getDataPrelievoIm()!=null) {
  235.                 
  236.                 if( transazioneApplicativoServerReadFromDB.getDataEliminazioneIm()!=null ) {
  237.                     return false; // l'informazione salvata sul database indica già un messaggio eliminato via I.M..
  238.                 }
  239.                 
  240.                 // date
  241.                 transazioneApplicativoServerReadFromDB.setDataPrelievoIm(serverInfoParam.getDataPrelievoIm());
  242.                 
  243.                 // data primo tentativo
  244.                 if(transazioneApplicativoServerReadFromDB.getDataPrimoPrelievoIm()==null &&
  245.                     serverInfoParam.getDataPrelievoIm()!=null) {
  246.                     transazioneApplicativoServerReadFromDB.setDataPrimoPrelievoIm(serverInfoParam.getDataPrelievoIm()); // primo tentativo di prelievo
  247.                 }
  248.                 
  249.                 // numero tentativi
  250.                 transazioneApplicativoServerReadFromDB.setNumeroPrelieviIm(transazioneApplicativoServerReadFromDB.getNumeroPrelieviIm()+1); 
  251.     
  252.                 // cluster id
  253.                 transazioneApplicativoServerReadFromDB.setClusterIdPrelievoIm(serverInfoParam.getClusterIdPrelievoIm());
  254.                 
  255.             }
  256.             else {
  257.             
  258.                 if( transazioneApplicativoServerReadFromDB.isConsegnaTerminata() ) {
  259.                     return false; // l'informazione salvata sul database indica già un messaggio completato.
  260.                 }
  261.                 
  262.                 // ** successivi invii **
  263.                 
  264.                 // id transazione, servizio applicativo erogatore e data registrazione non sono da aggiornare
  265.                                             
  266.                 // esito
  267.                 transazioneApplicativoServerReadFromDB.setConsegnaTerminata(serverInfoParam.isConsegnaTerminata());
  268.                 transazioneApplicativoServerReadFromDB.setDettaglioEsito(serverInfoParam.getDettaglioEsito());
  269.                 
  270.                 // date
  271.                 transazioneApplicativoServerReadFromDB.setDataAccettazioneRichiesta(serverInfoParam.getDataAccettazioneRichiesta());
  272.                 transazioneApplicativoServerReadFromDB.setDataUscitaRichiesta(serverInfoParam.getDataUscitaRichiesta());
  273.                 transazioneApplicativoServerReadFromDB.setDataUscitaRichiestaStream(serverInfoParam.getDataUscitaRichiestaStream());
  274.                 transazioneApplicativoServerReadFromDB.setDataAccettazioneRisposta(serverInfoParam.getDataAccettazioneRisposta());
  275.                 transazioneApplicativoServerReadFromDB.setDataIngressoRisposta(serverInfoParam.getDataIngressoRisposta());
  276.                 transazioneApplicativoServerReadFromDB.setDataIngressoRispostaStream(serverInfoParam.getDataIngressoRispostaStream());
  277.                 
  278.                 // dimensioni
  279.                 transazioneApplicativoServerReadFromDB.setRichiestaUscitaBytes(serverInfoParam.getRichiestaUscitaBytes());
  280.                 transazioneApplicativoServerReadFromDB.setRispostaIngressoBytes(serverInfoParam.getRispostaIngressoBytes());
  281.             
  282.                 // location e codice risposta
  283.                 transazioneApplicativoServerReadFromDB.setLocationConnettore(serverInfoParam.getLocationConnettore());
  284.                 transazioneApplicativoServerReadFromDB.setCodiceRisposta(serverInfoParam.getCodiceRisposta());
  285.                 
  286.                 // fault
  287.                 transazioneApplicativoServerReadFromDB.setFault(serverInfoParam.getFault());
  288.                 transazioneApplicativoServerReadFromDB.setFormatoFault(serverInfoParam.getFormatoFault());
  289.                 
  290.                 // data primo tentativo
  291.                 if(transazioneApplicativoServerReadFromDB.getDataPrimoTentativo()==null &&
  292.                     serverInfoParam.getDataUscitaRichiesta()!=null) {
  293.                     transazioneApplicativoServerReadFromDB.setDataPrimoTentativo(serverInfoParam.getDataUscitaRichiesta()); // primo tentativo di consegna
  294.                 }
  295.                 
  296.                 // numero tentativi
  297.                 transazioneApplicativoServerReadFromDB.setNumeroTentativi(transazioneApplicativoServerReadFromDB.getNumeroTentativi()+1);   
  298.     
  299.                 // cluster id
  300.                 transazioneApplicativoServerReadFromDB.setClusterIdConsegna(serverInfoParam.getClusterIdConsegna());
  301.                 
  302.                 
  303.                 // aggiorno errore e fault se ho uno stato non ok
  304.                 
  305.                 if(!serverInfoParam.isConsegnaTerminata()) {
  306.                     
  307.                     if(serverInfoParam.getDataUscitaRichiesta()!=null) {
  308.                         transazioneApplicativoServerReadFromDB.setDataUltimoErrore(serverInfoParam.getDataUscitaRichiesta());
  309.                     }
  310.                     else {
  311.                         transazioneApplicativoServerReadFromDB.setDataUltimoErrore(serverInfoParam.getDataAccettazioneRichiesta());
  312.                     }
  313.                     
  314.                     transazioneApplicativoServerReadFromDB.setDettaglioEsitoUltimoErrore(serverInfoParam.getDettaglioEsito());
  315.                     
  316.                     transazioneApplicativoServerReadFromDB.setCodiceRispostaUltimoErrore(serverInfoParam.getCodiceRisposta());
  317.                     
  318.                     transazioneApplicativoServerReadFromDB.setUltimoErrore(serverInfoParam.getUltimoErrore());
  319.                     
  320.                     transazioneApplicativoServerReadFromDB.setLocationUltimoErrore(serverInfoParam.getLocationConnettore());
  321.                     
  322.                     transazioneApplicativoServerReadFromDB.setClusterIdUltimoErrore(serverInfoParam.getClusterIdConsegna());
  323.                                     
  324.                     transazioneApplicativoServerReadFromDB.setFaultUltimoErrore(serverInfoParam.getFault());
  325.                     transazioneApplicativoServerReadFromDB.setFormatoFaultUltimoErrore(serverInfoParam.getFormatoFault());
  326.                 }
  327.                 
  328.             }
  329.             
  330.             if(timeDetails!=null) {
  331.                 long timeEnd =  DateManager.getTimeMillis();
  332.                 long timeProcess = timeEnd-timeStart;
  333.                 timeDetails.add("prepareUpdate:"+timeProcess);
  334.                 
  335.                 timeStart = DateManager.getTimeMillis();
  336.             }
  337.             
  338.             transazioneService.update(idTransazioneApplicativoServerReadFromDB, transazioneApplicativoServerReadFromDB);
  339.             
  340.             if(timeDetails!=null) {
  341.                 long timeEnd =  DateManager.getTimeMillis();
  342.                 long timeProcess = timeEnd-timeStart;
  343.                 timeDetails.add("update:"+timeProcess);
  344.             }
  345.             
  346.             return true;
  347.         }
  348.         else {
  349.             
  350.             long timeStart = -1;
  351.             if(timeDetails!=null) {
  352.                 timeStart = DateManager.getTimeMillis();
  353.             }
  354.             
  355.             // ** primo invio **
  356.             
  357.             TransazioneApplicativoServer transazioneApplicativoServer = serverInfoParam;
  358.             
  359.             // protocollo
  360.             transazioneApplicativoServer.setProtocollo(protocol);
  361.             
  362.             // data registrazione
  363.             if(transazioneApplicativoServer.getDataRegistrazione()==null) {
  364.                 transazioneApplicativoServer.setDataRegistrazione(DateManager.getDate());
  365.             }
  366.             
  367.             // data primo tentativo
  368.             if(transazioneApplicativoServer.getDataUscitaRichiesta()!=null) {
  369.                 transazioneApplicativoServer.setDataPrimoTentativo(transazioneApplicativoServer.getDataUscitaRichiesta()); // primo tentativo di consegna
  370.             }
  371.             if(transazioneApplicativoServer.getDataPrelievoIm()!=null) {
  372.                 transazioneApplicativoServer.setDataPrimoPrelievoIm(transazioneApplicativoServer.getDataPrelievoIm());
  373.             }
  374.             
  375.             // numero tentativi
  376.             transazioneApplicativoServer.setNumeroTentativi(0);
  377.             transazioneApplicativoServer.setNumeroPrelieviIm(0);
  378.             
  379.             // cluster id
  380.             transazioneApplicativoServer.setClusterIdPresaInCarico(serverInfoParam.getClusterIdPresaInCarico());
  381.             
  382.             if(timeDetails!=null) {
  383.                 long timeEnd =  DateManager.getTimeMillis();
  384.                 long timeProcess = timeEnd-timeStart;
  385.                 timeDetails.add("prepareInsert:"+timeProcess);
  386.                 
  387.                 timeStart = DateManager.getTimeMillis();
  388.             }
  389.             
  390.             // CREO
  391.             transazioneService.create(transazioneApplicativoServer);

  393.             if(timeDetails!=null) {
  394.                 long timeEnd =  DateManager.getTimeMillis();
  395.                 long timeProcess = timeEnd-timeStart;
  396.                 timeDetails.add("insert:"+timeProcess);
  397.                 
  398.                 timeStart = DateManager.getTimeMillis();
  399.             }
  400.             
  401.             return true;
  402.         }

  404.     }
  405.     
  406.     public static boolean safeAggiornaInformazioneConsegnaTerminata(TransazioneApplicativoServer transazioneApplicativoServer, Connection con, 
  407.             String tipoDatabase, Logger logCore,
  408.             IDAOFactory daoFactory, Logger logFactory, ServiceManagerProperties smpFactory,
  409.             boolean debug,
  410.             int esitoConsegnaMultipla, int esitoConsegnaMultiplaInCorso, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, int ok,
  411.             int esitoIntegrationManagerSingolo, boolean possibileTerminazioneSingleIntegrationManagerMessage, boolean consegnaInErrore,
  412.             long gestioneSerializableDBAttesaAttiva, int gestioneSerializableDBCheckInterval,
  413.             List<String> timeDetails) {
  414.         
  415.         // aggiorno esito transazione
  416.         try{
  417.             return TransactionServerUtils.aggiornaInformazioneConsegnaTerminata(transazioneApplicativoServer, con, 
  418.                     tipoDatabase, logCore,
  419.                     daoFactory, logFactory, smpFactory,
  420.                     debug,
  421.                     esitoConsegnaMultipla, esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  422.                     esitoIntegrationManagerSingolo, possibileTerminazioneSingleIntegrationManagerMessage, consegnaInErrore,
  423.                     gestioneSerializableDBAttesaAttiva, gestioneSerializableDBCheckInterval,
  424.                     timeDetails);
  425.         }catch(Throwable e){
  426.             /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] ERRORE AGGIORNAMENTO: "+e.getMessage());
  427.             e.printStackTrace(System.out);*/
  428.             String msg = "Errore durante l'aggiornamento delle transazione relativamente all'informazione del server: " + e.getLocalizedMessage();
  429.             logCore.error("[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] "+msg,e);
  430.             return false;
  431.         }
  432.     }
  433.     
  434.     private static boolean aggiornaInformazioneConsegnaTerminata(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  435.             String tipoDatabase, Logger logCore,
  436.             IDAOFactory daoFactory, Logger logFactory, ServiceManagerProperties smpFactory,
  437.             boolean debug,
  438.             int esitoConsegnaMultipla, int esitoConsegnaMultiplaInCorso, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, int ok,
  439.             int esitoIntegrationManagerSingolo, boolean possibileTerminazioneSingleIntegrationManagerMessage, boolean consegnaInErrore,
  440.             long gestioneSerializableDBAttesaAttiva, int gestioneSerializableDBCheckInterval,
  441.             List<String> timeDetails) throws CoreException {
  442.         
  443.         boolean consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda = false;
  444.         
  445.         if(possibileTerminazioneSingleIntegrationManagerMessage || consegnaInErrore) {
  446.             // possibileTerminazioneSingleIntegrationManagerMessage
  447.             // Devo comprendere se l'eliminazione del messaggio, effettuata via I.M o tramite scadenza, riguarda la configurazione su connettori multipli o configurazione standard con unico connettore.
  448.             // Se e' su configurazione standard con unico connettore non devo aggiornare le informazioni sulla consegna terminata
  449.             
  450.             // possibilePrimaConsegnaNonAndataABuonFine
  451.             // Devo comprendere se si tratta di una prima consegna, non completata. Serve per aggiornare lo stato della transazione da "In coda" a "In corso"
  452.             
  453.             int i = 0;
  454.             if(transazioneApplicativoServer.getDataRegistrazione()==null) {
  455.                 i=2;
  456.             }
  457. /**         else {
  458.                 System.out.println("DATA REGISTRAZIONE '"+org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(transazioneApplicativoServer.getDataRegistrazione())+"'");
  459.             }*/
  460.             int esitoTransazione = -1;
  461.             for (; i < 3; i++) {
  462.                 
  463.                 long timeStart = -1;
  464.                 if(timeDetails!=null) {
  465.                     timeStart = DateManager.getTimeMillis();
  466.                 }
  467.                 
  468.                 // primo test: finestra di 5 minuti
  469.                 // secondo test: finestra di 1 ora
  470.                 // terzo test: senza finestra temporale
  471.                 
  472.                 /**System.out.println("INTERVALLO '"+i+"'");*/
  473.                 
  474.                 Timestamp leftValue = null;
  475.                 Timestamp rightValue = null;
  476.                 if(i==0) {
  477.                     leftValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() - (1000*60*5));
  478.                     rightValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() + (1000*60*5));
  479.                 }
  480.                 else if(i==1) {
  481.                     leftValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() - (1000*60*60));
  482.                     rightValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() + (1000*60*60));
  483.                 }
  484.             
  485.                 esitoTransazione = getEsitoTransazione(transazioneApplicativoServer, connectionDB,
  486.                         tipoDatabase, logCore,
  487.                         leftValue, rightValue);
  488.                 
  489.                 if(timeDetails!=null) {
  490.                     long timeEnd =  DateManager.getTimeMillis();
  491.                     long timeProcess = timeEnd-timeStart;
  492.                     timeDetails.add("getEsitoIM-"+i+":"+timeProcess);
  493.                 }
  494.                 
  495.                 if(esitoTransazione>=0) {
  496.                     // transazione trovata
  497.                     if(possibileTerminazioneSingleIntegrationManagerMessage &&
  498.                         esitoIntegrationManagerSingolo == esitoTransazione) {
  499.                         /**System.out.println("TROVATA IM; termino aggiornamento");*/
  500.                         return true; // non devo gestire l'update previsto nei connettori multipli gestito dopo
  501.                     }
  502.                     if(consegnaInErrore) {
  503.                         if(esitoConsegnaMultipla == esitoTransazione) {
  504.                             consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda = true;
  505.                         }
  506.                         else {
  507.                             /**System.out.println("TROVATA TRANSAZIONE CON ESITO "+esitoTransazione+" non "in coda"; termino aggiornamento");*/
  508.                             return true; // non devo gestire l'update previsto nei connettori multipli gestito dopo
  509.                         }
  510.                     }
  511.                     /**else {
  512.                         System.out.println("ESCO e procedo con update normale ["+i+"]");
  513.                     }*/
  514.                     break;
  515.                 }
  516.                 /**else {
  517.                     System.out.println("NON TROVATA TRANSAZIONE a QUESTO GIRO ["+i+"]");
  518.                 }*/
  519.                 
  520.             }
  521.             if(esitoTransazione<0) {
  522.                 // registro ultimo errore avvenuto durante il ciclo in entrambi i log
  523.                 String msgError = "[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] 'getEsitoTransazione' non riuscta. Tutti gli intervalli non hanno consentito di inviduare la transazione";
  524.                 logFactory.error(msgError);
  525.                 logCore.error(msgError);
  526.             }
  527.             
  528.         }
  529.         
  530.         return aggiornaInformazioneConsegnaTerminataEngine(transazioneApplicativoServer, connectionDB,
  531.                 tipoDatabase, logCore,
  532.                 daoFactory, logFactory, smpFactory,
  533.                 debug,
  534.                 esitoConsegnaMultipla, esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  535.                 consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  536.                 gestioneSerializableDBAttesaAttiva, gestioneSerializableDBCheckInterval,
  537.                 timeDetails);
  538.     }
  539.     private static boolean aggiornaInformazioneConsegnaTerminataEngine(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  540.             String tipoDatabase, Logger logCore,
  541.             IDAOFactory daoFactory, Logger logFactory, ServiceManagerProperties smpFactory,
  542.             boolean debug,
  543.             int esitoConsegnaMultipla, int esitoConsegnaMultiplaInCorso, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, int ok,
  544.             boolean consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  545.             long gestioneSerializableDBAttesaAttiva, int gestioneSerializableDBCheckInterval,
  546.             List<String> timeDetails) throws CoreException {
  547.         
  548.         boolean useSerializableMode = false;
  549.         if(useSerializableMode) {
  550.             serializableModeAggiornaInformazioneConsegnaTerminataEngine(transazioneApplicativoServer, connectionDB,
  551.                     tipoDatabase, logCore,
  552.                     daoFactory, logFactory, smpFactory,
  553.                     debug,
  554.                     esitoConsegnaMultipla, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  555.                     consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  556.                     gestioneSerializableDBAttesaAttiva, gestioneSerializableDBCheckInterval);
  557.             return true; // non gestisco l'informazione ritornata essendo il metodo deprecato
  558.         }
  559.         else {
  560.             
  561.             boolean transazioneGiaModificata = false;
  562.             
  563.             int i = 0;
  564.             if(transazioneApplicativoServer.getDataRegistrazione()==null) {
  565.                 i=2;
  566.             }
  567. /**         else {
  568.                 System.out.println("DATA REGISTRAZIONE '"+org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(transazioneApplicativoServer.getDataRegistrazione())+"'");
  569.             }*/
  570.             int row = -1;
  571.             for (; i < 3; i++) {
  572.                 
  573.                 long timeStart = -1;
  574.                 if(timeDetails!=null) {
  575.                     timeStart = DateManager.getTimeMillis();
  576.                 }
  577.                 
  578.                 // primo test: finestra di 5 minuti
  579.                 // secondo test: finestra di 1 ora
  580.                 // terzo test: senza finestra temporale
  581.                 
  582.                 /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] INTERVALLO '"+i+"'");*/
  583.                 
  584.                 Timestamp leftValue = null;
  585.                 Timestamp rightValue = null;
  586.                 if(i==0) {
  587.                     leftValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() - (1000*60*5));
  588.                     rightValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() + (1000*60*5));
  589.                 }
  590.                 else if(i==1) {
  591.                     leftValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() - (1000*60*60));
  592.                     rightValue = new Timestamp(transazioneApplicativoServer.getDataRegistrazione().getTime() + (1000*60*60));
  593.                 }
  594.             
  595.                 boolean useSERIALIZABLE = true;
  596.                 StringBuilder sbConflict = new StringBuilder();
  597.                 row = aggiornaInformazioneConsegnaTerminataEngine(transazioneApplicativoServer, connectionDB,
  598.                         tipoDatabase, logCore,
  599.                         logFactory, 
  600.                         esitoConsegnaMultipla, esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  601.                         consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  602.                         leftValue, rightValue,
  603.                         useSERIALIZABLE,
  604.                         gestioneSerializableDBAttesaAttiva, gestioneSerializableDBCheckInterval,
  605.                         sbConflict);
  606.                 
  607.                 if(timeDetails!=null) {
  608.                     long timeEnd =  DateManager.getTimeMillis();
  609.                     long timeProcess = timeEnd-timeStart;
  610.                     String c = "";
  611.                     if(useSERIALIZABLE &&
  612.                         sbConflict.length()>0) {
  613.                         c="/c"+sbConflict.toString();
  614.                     }
  615.                     timeDetails.add("updateInfo-"+i+":"+timeProcess+c);
  616.                 }
  617.                 
  618.                 if(row>0) {
  619.                     break;
  620.                 }
  621.                 else if(consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda) {
  622.                     /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] existsTransazioneIniziataGestioneConsegnaAsincrona ...");*/
  623.                     // in questo caso si sta cercando di aggiornare l'esito:
  624.                     //   UPDATE transazioni SET esito = 48 WHERE ( .... ) ( esito=38 )
  625.                     // ma se una transazione in parallelo l'ha già modificato si ottiene un row=0 che faceva ritornare false questo metodo, faceva scaturire la registrazione su file e poi l'aggiornamenti di avvenuta consegna che non era corretta.
  626.                     transazioneGiaModificata = existsTransazioneIniziataGestioneConsegnaAsincrona(transazioneApplicativoServer, connectionDB,
  627.                             tipoDatabase, logCore,
  628.                             esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, 
  629.                             leftValue, rightValue);
  630.                     if(transazioneGiaModificata) {
  631.                         /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] existsTransazioneIniziataGestioneConsegnaAsincrona FIX");*/
  632.                         break;
  633.                     }
  634.                     /**else {
  635.                         System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] existsTransazioneIniziataGestioneConsegnaAsincrona NO");
  636.                     }*/
  637.                 }
  638.                 
  639.             }
  640.             if(row<=0 && !transazioneGiaModificata) {
  641.                 // registro ultimo errore avvenuto durante il ciclo in entrambi i log
  642.                 String msgError = "[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] 'aggiornaInformazioneConsegnaTerminata' non riuscta. Tutti gli intervalli di update non hanno comportato un aggiornamento della transazione";
  643.                 logFactory.error(msgError);
  644.                 logCore.error(msgError);
  645.                 /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] INTERVALLO '"+i+"' FINITO OK FALSE ========================================");*/
  646.                 return false;
  647.             }
  648.             else {
  649.                 /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] INTERVALLO '"+i+"' FINITO TRUE");*/
  650.                 return true;
  651.             }
  652.         }
  653.         
  654.     }
  655.     
  656.     private static java.util.Random rndInstance = null;
  657.     private static synchronized void initRandom() {
  658.         if(rndInstance==null) {
  659.             rndInstance = new SecureRandom();
  660.         }
  661.     }
  662.     protected static java.util.Random getRandom() {
  663.         if(rndInstance==null) {
  664.             initRandom();
  665.         }
  666.         return rndInstance;
  667.     }
  668.     
  669.     private static int aggiornaInformazioneConsegnaTerminataEngine(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  670.             String tipoDatabase, Logger logCore,
  671.             Logger logFactory, 
  672.             int esitoConsegnaMultipla, int esitoConsegnaMultiplaInCorso, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, int ok,
  673.             boolean consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  674.             Timestamp leftValue, Timestamp rightValue,
  675.             boolean serializable,
  676.             long gestioneSerializableDBAttesaAttiva, int gestioneSerializableDBCheckInterval,
  677.             StringBuilder sbConflict) throws CoreException {
  678.         
  679.         /**System.out.println("SERIALIZABLE ("+transazioneApplicativoServer.getConnettoreNome()+"): "+serializable);*/
  680.         if(serializable) {
  681.             
  682.             /*
  683.               Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  684.               che esecuzioni parallele non leggano dati inconsistenti.
  685.               Con il livello SERIALIZABLE, se ritorna una eccezione, deve essere riprovato
  686.               La sincronizzazione e' necessaria per via del possibile accesso simultaneo del servizio Gop
  687.               e del servizio che si occupa di eliminare destinatari di messaggi
  688.              */
  689.             // setAutoCommit e livello Isolamento
  690.             int oldTransactionIsolation = -1;
  691.             try{
  692.                 oldTransactionIsolation = connectionDB.getTransactionIsolation();
  693.                 /** già effettuato fuori dal metodo connectionDB.setAutoCommit(false);*/
  694.                 JDBCUtilities.setTransactionIsolationSerializable(tipoDatabase, connectionDB);
  695.             } catch(Exception er) {
  696.                 throw new CoreException("(setIsolation) "+er.getMessage(),er);
  697.             }

  699.             boolean updateEffettuato = false;
  700.             
  701.             long scadenzaWhile = DateManager.getTimeMillis() + gestioneSerializableDBAttesaAttiva;
  702.             
  703.             int row = -1;
  704.             Throwable lastT = null;
  705.             int conflitti = 0;
  706.             while(!updateEffettuato && DateManager.getTimeMillis() < scadenzaWhile){

  708.                 try{
  709.                     row = aggiornaInformazioneConsegnaTerminataEngine(transazioneApplicativoServer, connectionDB,
  710.                             tipoDatabase, logCore,
  711.                             esitoConsegnaMultipla, esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  712.                             consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  713.                             leftValue, rightValue);

  715.                     updateEffettuato = true;
  716.                     /**System.out.println("["+transazioneApplicativoServer.getConnettoreNome()+"] ["+transazioneApplicativoServer.getIdTransazione()+"] OK row:"+row);*/

  718.                 } catch(Throwable e) {
  719.                     lastT = e;
  720.                     /**System.out.println("Serializable error ("+transazioneApplicativoServer.getConnettoreNome()+")  ["+transazioneApplicativoServer.getIdTransazione()+"] (row:"+row+" updateEffettuato:"+updateEffettuato+"):"+e.getMessage());*/
  721.                 }

  723.                 if(!updateEffettuato){
  724.                     // Per aiutare ad evitare conflitti
  725.                     try{
  726.                         Utilities.sleep(getRandom().nextInt(gestioneSerializableDBCheckInterval)); // random da 0ms a checkIntervalms
  727.                     }catch(Exception eRandom){
  728.                         // random
  729.                     }
  730.                     conflitti++;
  731.                 }
  732.             }
  733.             sbConflict.append(conflitti+"/updated:"+updateEffettuato);
  734.             // Ripristino Transazione
  735.             try{
  736.                 connectionDB.setTransactionIsolation(oldTransactionIsolation);
  737.                 /** già effettuato fuori dal metodo connectionDB.setAutoCommit(true);*/
  738.             } catch(Exception er) {
  739.                 throw new CoreException("(ripristinoIsolation) "+er.getMessage(),er);
  740.             }
  741.             if(lastT!=null && !updateEffettuato) {
  742.                 // registro ultimo errore avvenuto durante il ciclo in entrambi i log
  743.                 String date = "";
  744.                 if(leftValue!=null || rightValue!=null) {
  745.                     StringBuilder sb = new StringBuilder(" [");
  746.                     if(leftValue!=null) {
  747.                         sb.append(DateUtils.getSimpleDateFormatMs().format(leftValue));
  748.                         if(rightValue!=null) {
  749.                             sb.append(" - ");
  750.                         }
  751.                     }
  752.                     if(rightValue!=null) {
  753.                         sb.append(DateUtils.getSimpleDateFormatMs().format(rightValue));
  754.                     }
  755.                     sb.append("]");
  756.                     date = sb.toString();
  757.                 }
  758.                 String msgError = "[id:"+transazioneApplicativoServer.getIdTransazione()+"][sa:"+transazioneApplicativoServer.getServizioApplicativoErogatore()+"]["+transazioneApplicativoServer.getConnettoreNome()+"] 'aggiornaInformazioneConsegnaTerminata'"+date+" failed: "+lastT.getMessage();
  759.                 logFactory.error(msgError,lastT);
  760.                 logCore.error(msgError,lastT);
  761.             }
  762.             
  763.             return row;

  765.         }
  766.         else {
  767.             
  768.             return aggiornaInformazioneConsegnaTerminataEngine(transazioneApplicativoServer, connectionDB,
  769.                     tipoDatabase, logCore,
  770.                     esitoConsegnaMultipla, esitoConsegnaMultiplaInCorso, esitoConsegnaMultiplaFallita, esitoConsegnaMultiplaCompletata, ok,
  771.                     consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  772.                     leftValue, rightValue);
  773.             
  774.         }
  775.     }
  776.     
  777.     private static int aggiornaInformazioneConsegnaTerminataEngine(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  778.             String tipoDatabase, Logger logCore,
  779.             int esitoConsegnaMultipla, int esitoConsegnaMultiplaInCorso, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, int ok,
  780.             boolean consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  781.             Timestamp leftValue, Timestamp rightValue) throws CoreException {
  782.     
  783.         PreparedStatement pstmt = null;
  784.         try {
  785.         
  786.             TransazioneFieldConverter transazioneFieldConverter = new TransazioneFieldConverter(tipoDatabase);
  787.             String dataIngressoRichiestaColumn = transazioneFieldConverter.toColumn(Transazione.model().DATA_INGRESSO_RICHIESTA, false);
  788.             String idTransazioneColumn = transazioneFieldConverter.toColumn(Transazione.model().ID_TRANSAZIONE, false);
  789.             String esitoColumn = transazioneFieldConverter.toColumn(Transazione.model().ESITO, false);
  790.             String consegneMultipleInCorsoColumn = transazioneFieldConverter.toColumn(Transazione.model().CONSEGNE_MULTIPLE_IN_CORSO, false);
  791.             
  792.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  793.             
  794.             sqlQueryObject.addUpdateTable(CostantiDB.TRANSAZIONI);
  795.             
  796.             if(consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda) {
  797.                 /* UPDATE transazioni 
  798.                  *      SET esito=esitoConsegnaMultiplaInCorso  
  799.                  * WHERE (ESITO=esitoConsegnaMultipla)
  800.                  */
  801.                 sqlQueryObject.addUpdateField(esitoColumn,"?");   
  802.             }
  803.             else {
  804.             
  805.                 sqlQueryObject.addUpdateField(consegneMultipleInCorsoColumn, consegneMultipleInCorsoColumn+"-1");
  806.                 
  807.                 if(ok != transazioneApplicativoServer.getDettaglioEsito() || transazioneApplicativoServer.getDataMessaggioScaduto()!=null) {
  808.                     /* UPDATE transazioni 
  809.                      *      SET consegne_multiple=consegne_multiple-1, 
  810.                      *          esito=esitoConsegnaMultiplaFallita  
  811.                      * WHERE (ESITO=esitoConsegnaMultipla OR ESITO=esitoConsegnaMultiplaInCorso OR ESITO=esitoConsegnaMultiplaFallita)
  812.                      */
  813.                     sqlQueryObject.addUpdateField(esitoColumn,"?");   
  814.                 }
  815.                 else {
  816.                      /* UPDATE transazioni 
  817.                      *      SET consegne_multiple=consegne_multiple-1, 
  818.                      *          esito = ( CASE
  819.                      *                    WHEN (consegne_multiple<=1 AND (esito=esitoConsegnaMultipla OR esito=esitoConsegnaMultiplaInCorso)) THEN esitoConsegnaMultiplaCompletata 
  820.                      *                    WHEN (consegne_multiple>1 AND esito=esitoConsegnaMultipla) THEN esitoConsegnaMultiplaInCorso 
  821.                      *                    ELSE  (ESITO)
  822.                      *                  END )
  823.                      * WHERE (ESITO=esitoConsegnaMultipla OR ESITO=esitoConsegnaMultiplaInCorso OR ESITO=esitoConsegnaMultiplaFallita)
  824.                      */
  825.                     Case caseValue = new Case(CastColumnType.INT, esitoColumn); 
  826.                     caseValue.addCase(consegneMultipleInCorsoColumn+"<=? AND ("+esitoColumn+"=? OR "+esitoColumn+"=?)", "?");
  827.                     caseValue.addCase(consegneMultipleInCorsoColumn+">? AND "+esitoColumn+"=?", "?");
  828.                     sqlQueryObject.addUpdateField(esitoColumn, caseValue);
  829.                 }
  830.                 
  831.             }
  832.             
  833.             sqlQueryObject.setANDLogicOperator(true);
  834.             
  835.             if(leftValue!=null && rightValue!=null) {
  836.                 sqlQueryObject.addWhereBetweenCondition(dataIngressoRichiestaColumn, false, "?", "?");
  837.             }
  838.             
  839.             sqlQueryObject.addWhereCondition(idTransazioneColumn+"=?");
  840.             
  841.             if(consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda) {
  842.                 sqlQueryObject.addWhereCondition(esitoColumn+"=?");
  843.             }
  844.             else {
  845.                 sqlQueryObject.addWhereCondition(false, 
  846.                         esitoColumn+"=?",
  847.                         esitoColumn+"=?",
  848.                         esitoColumn+"=?");
  849.             }
  850.             
  851.             String updateCommand = sqlQueryObject.createSQLUpdate();
  852.             /**System.out.println("QUERY '"+updateCommand+"'");*/
  853.             
  854.             pstmt = connectionDB.prepareStatement(updateCommand);
  855.             int index = 1;
  856.             List<Object> params = new ArrayList<>();
  857.             
  858.             if(consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda) {
  859.                 pstmt.setInt(index++, esitoConsegnaMultiplaInCorso);
  860.                 params.add(esitoConsegnaMultiplaInCorso);
  861.             }
  862.             else {
  863.                 if(ok != transazioneApplicativoServer.getDettaglioEsito() || transazioneApplicativoServer.getDataMessaggioScaduto()!=null) {
  864.                     pstmt.setInt(index++, esitoConsegnaMultiplaFallita);
  865.                     params.add(esitoConsegnaMultiplaFallita);
  866.                 }
  867.                 else {
  868.                     // primo case
  869.                     pstmt.setInt(index++, 1); // il decremento nell'unico comando di update funziona transazionalmente; quindi quando lo porto a 0, il valore nella condizione è 1(lascio il <= per stare tranquillo)
  870.                     params.add(1);
  871.                     pstmt.setInt(index++, esitoConsegnaMultipla);
  872.                     params.add(esitoConsegnaMultipla);
  873.                     pstmt.setInt(index++, esitoConsegnaMultiplaInCorso);
  874.                     params.add(esitoConsegnaMultiplaInCorso);
  875.                     pstmt.setInt(index++, esitoConsegnaMultiplaCompletata);
  876.                     params.add(esitoConsegnaMultiplaCompletata);
  877.                     // secondo case
  878.                     pstmt.setInt(index++, 1);
  879.                     params.add(1);
  880.                     pstmt.setInt(index++, esitoConsegnaMultipla);
  881.                     params.add(esitoConsegnaMultipla);
  882.                     pstmt.setInt(index++, esitoConsegnaMultiplaInCorso);
  883.                     params.add(esitoConsegnaMultiplaInCorso);
  884.                 }
  885.             }
  886.             
  887.             if(leftValue!=null && rightValue!=null) {
  888.                 pstmt.setTimestamp(index++, leftValue);
  889.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(leftValue));
  890.                 pstmt.setTimestamp(index++, rightValue);
  891.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(rightValue));
  892.             }
  893.             
  894.             pstmt.setString(index++, transazioneApplicativoServer.getIdTransazione());
  895.             params.add(transazioneApplicativoServer.getIdTransazione());
  896.             
  897.             if(consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda) {
  898.                 pstmt.setInt(index++, esitoConsegnaMultipla);
  899.                 params.add(esitoConsegnaMultipla);
  900.             }
  901.             else {
  902.                 pstmt.setInt(index++, esitoConsegnaMultipla);
  903.                 params.add(esitoConsegnaMultipla);
  904.                 pstmt.setInt(index++, esitoConsegnaMultiplaInCorso);
  905.                 params.add(esitoConsegnaMultiplaInCorso);
  906.                 pstmt.setInt(index++, esitoConsegnaMultiplaFallita);
  907.                 params.add(esitoConsegnaMultiplaFallita);
  908.             }
  909.             
  910.             int row = pstmt.executeUpdate();
  911.             if(row!=1 &&
  912.                 logCore!=null) {
  913.                 String comandoSql = DBUtils.formatSQLString(updateCommand, params.toArray());
  914.                 String prefix = "Trovata transazione con id '"+transazioneApplicativoServer.getIdTransazione()+"' ";
  915.                 if(row<1) {
  916.                     String msg = prefix+"per cui il comando di aggiornamento della transazione non ha comportato effetti: "+comandoSql;
  917.                     logCore.debug(msg);
  918.                 }
  919.                 else {
  920.                     throw new CoreException(prefix+"??");
  921.                 }
  922.             }
  923.             
  924.             /**String comandoSql = DBUtils.formatSQLString(updateCommand, params.toArray());
  925.             System.out.println("ROW: "+row+" (app:"+transazioneApplicativoServer.getConnettoreNome()+" id:"+transazioneApplicativoServer.getIdTransazione()+") sql:"+comandoSql);*/
  926.             
  927.             pstmt.close();
  928.             pstmt = null;
  929.             
  930.             // Chiusura Transazione
  931.             connectionDB.commit();
  932.             
  933.             return row;
  934.             
  935.         }catch(Throwable e) {
  936.             
  937.             try{
  938.                 if(pstmt != null) {
  939.                     pstmt.close();
  940.                     pstmt = null;
  941.                 }
  942.             } catch(Exception er) {
  943.                 // ignore
  944.             }
  945.             try{
  946.                 connectionDB.rollback();
  947.             } catch(Exception er) {
  948.                 // ignore
  949.             }
  950.             
  951.             throw new CoreException(e.getMessage(),e);
  952.         }finally{
  953.             try {
  954.                 if(pstmt!=null) {
  955.                     pstmt.close();
  956.                 }
  957.             }catch(Throwable t) {
  958.                 // ignore
  959.             }
  960.         }
  961.         
  962.     }
  963.     private static boolean existsTransazioneIniziataGestioneConsegnaAsincrona(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  964.             String tipoDatabase, Logger logCore,
  965.             int esitoConsegnaMultiplaInCorso, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, 
  966.             Timestamp leftValue, Timestamp rightValue) throws CoreException {
  967.     
  968.         ResultSet rs = null;
  969.         PreparedStatement pstmt = null;
  970.         try {
  971.         
  972.             TransazioneFieldConverter transazioneFieldConverter = new TransazioneFieldConverter(tipoDatabase);
  973.             String dataIngressoRichiestaColumn = transazioneFieldConverter.toColumn(Transazione.model().DATA_INGRESSO_RICHIESTA, false);
  974.             String idTransazioneColumn = transazioneFieldConverter.toColumn(Transazione.model().ID_TRANSAZIONE, false);
  975.             String esitoColumn = transazioneFieldConverter.toColumn(Transazione.model().ESITO, false);
  976.             
  977.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  978.             
  979.             String countAlias = "conteggio";
  980.             sqlQueryObject.addSelectCountField(idTransazioneColumn, countAlias);
  981.             
  982.             sqlQueryObject.addFromTable(CostantiDB.TRANSAZIONI);
  983.                         
  984.             sqlQueryObject.setANDLogicOperator(true);
  985.             
  986.             if(leftValue!=null && rightValue!=null) {
  987.                 sqlQueryObject.addWhereBetweenCondition(dataIngressoRichiestaColumn, false, "?", "?");
  988.             }
  989.             
  990.             sqlQueryObject.addWhereCondition(idTransazioneColumn+"=?");
  991.             
  992.             sqlQueryObject.addWhereCondition(false, 
  993.                         esitoColumn+"=?",
  994.                         esitoColumn+"=?",
  995.                         esitoColumn+"=?");
  996.             
  997.             String queryCommand = sqlQueryObject.createSQLQuery();
  998.             /**System.out.println("QUERY '"+queryCommand+"'");*/
  999.             
  1000.             pstmt = connectionDB.prepareStatement(queryCommand);
  1001.             int index = 1;
  1002.             List<Object> params = new ArrayList<>();
  1003.                         
  1004.             if(leftValue!=null && rightValue!=null) {
  1005.                 pstmt.setTimestamp(index++, leftValue);
  1006.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(leftValue));
  1007.                 pstmt.setTimestamp(index++, rightValue);
  1008.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(rightValue));
  1009.             }
  1010.             
  1011.             pstmt.setString(index++, transazioneApplicativoServer.getIdTransazione());
  1012.             params.add(transazioneApplicativoServer.getIdTransazione());
  1013.             
  1014.             pstmt.setInt(index++, esitoConsegnaMultiplaInCorso);
  1015.             params.add(esitoConsegnaMultiplaInCorso);
  1016.             pstmt.setInt(index++, esitoConsegnaMultiplaFallita);
  1017.             params.add(esitoConsegnaMultiplaFallita);
  1018.             pstmt.setInt(index++, esitoConsegnaMultiplaCompletata);
  1019.             params.add(esitoConsegnaMultiplaCompletata);
  1020.                         
  1021.             int count = 0;
  1022.             rs = pstmt.executeQuery();
  1023.             if(rs.next()) {
  1024.                 count = rs.getInt(countAlias);
  1025.             }
  1026.             else if(logCore!=null) {
  1027.                 String comandoSql = DBUtils.formatSQLString(queryCommand, params.toArray());
  1028.                 if(count<1) {
  1029.                     String msg = "Non trovata transazione con id '"+transazioneApplicativoServer.getIdTransazione()+"' già in gestione: "+comandoSql;
  1030.                     logCore.debug(msg);
  1031.                 }
  1032.                 else {
  1033.                     throw new CoreException("Trovata più di una transazione con id '"+transazioneApplicativoServer.getIdTransazione()+"' ??");
  1034.                 }
  1035.             }
  1036.             
  1037.             /**String comandoSql = DBUtils.formatSQLString(queryCommand, params.toArray());
  1038.             System.out.println("existsTransazioneIniziataGestioneConsegnaAsincrona Count: "+count+" (app:"+transazioneApplicativoServer.getConnettoreNome()+" id:"+transazioneApplicativoServer.getIdTransazione()+") sql:"+comandoSql);*/
  1039.             
  1040.             rs.close();
  1041.             rs = null;
  1042.             pstmt.close();
  1043.             pstmt = null;
  1044.             
  1045.             return count>0;
  1046.             
  1047.         }catch(Throwable e) {
  1048.             
  1049.             try{
  1050.                 if(rs != null) {
  1051.                     rs.close();
  1052.                     rs = null;
  1053.                 }
  1054.             } catch(Exception er) {
  1055.                 // ignore
  1056.             }
  1057.             try{
  1058.                 if(pstmt != null) {
  1059.                     pstmt.close();
  1060.                     pstmt = null;
  1061.                 }
  1062.             } catch(Exception er) {
  1063.                 // ignore
  1064.             }
  1065.             try{
  1066.                 connectionDB.rollback();
  1067.             } catch(Exception er) {
  1068.                 // ignore
  1069.             }
  1070.             
  1071.             throw new CoreException(e.getMessage(),e);
  1072.         }finally{
  1073.             try{
  1074.                 if(rs != null) {
  1075.                     rs.close();
  1076.                 }
  1077.             } catch(Exception er) {
  1078.                 // ignore
  1079.             }
  1080.             try {
  1081.                 if(pstmt!=null) {
  1082.                     pstmt.close();
  1083.                 }
  1084.             }catch(Throwable t) {
  1085.                 // ignore
  1086.             }
  1087.         }
  1088.         
  1089.     }
  1090.     
  1091.     private static int getEsitoTransazione(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  1092.             String tipoDatabase, Logger logCore,
  1093.             Timestamp leftValue, Timestamp rightValue) throws CoreException {
  1094.     
  1095.         PreparedStatement pstmt = null;
  1096.         ResultSet rs = null;
  1097.         try {
  1098.         
  1099.             TransazioneFieldConverter transazioneFieldConverter = new TransazioneFieldConverter(tipoDatabase);
  1100.             String dataIngressoRichiestaColumn = transazioneFieldConverter.toColumn(Transazione.model().DATA_INGRESSO_RICHIESTA, false);
  1101.             String idTransazioneColumn = transazioneFieldConverter.toColumn(Transazione.model().ID_TRANSAZIONE, false);
  1102.             String esitoColumn = transazioneFieldConverter.toColumn(Transazione.model().ESITO, false);
  1103.             
  1104.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  1105.             
  1106.             sqlQueryObject.addFromTable(CostantiDB.TRANSAZIONI);
  1107.             
  1108.             sqlQueryObject.addSelectField(esitoColumn);
  1109.             
  1110.             sqlQueryObject.setANDLogicOperator(true);
  1111.             
  1112.             if(leftValue!=null && rightValue!=null) {
  1113.                 sqlQueryObject.addWhereBetweenCondition(dataIngressoRichiestaColumn, false, "?", "?");
  1114.             }
  1115.             
  1116.             sqlQueryObject.addWhereCondition(idTransazioneColumn+"=?");
  1117.                         
  1118.             String select = sqlQueryObject.createSQLQuery();
  1119.             /**System.out.println("QUERY '"+select+"'");*/
  1120.             
  1121.             pstmt = connectionDB.prepareStatement(select);
  1122.             int index = 1;
  1123.             List<Object> params = new ArrayList<>();
  1124.             
  1125.             if(leftValue!=null && rightValue!=null) {
  1126.                 pstmt.setTimestamp(index++, leftValue);
  1127.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(leftValue));
  1128.                 pstmt.setTimestamp(index++, rightValue);
  1129.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(rightValue));
  1130.             }
  1131.             
  1132.             pstmt.setString(index++, transazioneApplicativoServer.getIdTransazione());
  1133.             params.add(transazioneApplicativoServer.getIdTransazione());
  1134.                         
  1135.             rs = pstmt.executeQuery();
  1136.             int esitoReturn = -1;
  1137.             while(rs.next()) {
  1138.                 
  1139.                 int found = rs.getInt(esitoColumn);
  1140.                 
  1141.                 if(logCore!=null) {
  1142.                     String comandoSql = DBUtils.formatSQLString(select, params.toArray());
  1143.                     if(esitoReturn<0) {
  1144.                         esitoReturn = found;
  1145.                     }
  1146.                     else {
  1147.                         rs.close();
  1148.                         pstmt.close();
  1149.                         throw new CoreException("Trovata più di una transazione con id '"+transazioneApplicativoServer.getIdTransazione()+"' ?? (query: "+comandoSql+")");
  1150.                     }
  1151.                 }
  1152.             }
  1153.             
  1154.             /**String comandoSql = formatSQLString(updateCommand, params.toArray());
  1155.             System.out.println("ROW: "+row+" (app:"+transazioneApplicativoServer.getConnettoreNome()+" id:"+transazioneApplicativoServer.getIdTransazione()+") sql:"+comandoSql);*/
  1156.             
  1157.             rs.close();
  1158.             pstmt.close();
  1159.             pstmt = null;
  1160.                         
  1161.             connectionDB.commit(); // anche se si tratta di una read, serve per non far rimanere aperta la transazione
  1162.             
  1163.             return esitoReturn;
  1164.             
  1165.         }catch(Throwable e) {
  1166.             
  1167.             try{
  1168.                 if(rs != null) {
  1169.                     rs.close();
  1170.                     rs = null;
  1171.                 }
  1172.             } catch(Exception er) {
  1173.                 // ignore
  1174.             }
  1175.             try{
  1176.                 if(pstmt != null) {
  1177.                     pstmt.close();
  1178.                     pstmt = null;
  1179.                 }
  1180.             } catch(Exception er) {
  1181.                 // ignore
  1182.             }
  1183.             try{
  1184.                 connectionDB.rollback();
  1185.             } catch(Exception er) {
  1186.                 // ignore
  1187.             }
  1188.             
  1189.             throw new CoreException(e.getMessage(),e);
  1190.         }finally{
  1191.             try{
  1192.                 if(rs != null) {
  1193.                     rs.close();
  1194.                     rs = null;
  1195.                 }
  1196.             } catch(Exception er) {
  1197.                 // ignore
  1198.             }
  1199.             try {
  1200.                 if(pstmt!=null) {
  1201.                     pstmt.close();
  1202.                 }
  1203.             }catch(Throwable t) {
  1204.                 // ignore
  1205.             }
  1206.         }
  1207.         
  1208.     }
  1209.     
  1210.     public static boolean existsTransaction(String idTransaction, Connection connectionDB,
  1211.             String tipoDatabase, Logger logCore, boolean connectionDBCommit) throws CoreException {
  1212.     
  1213.         PreparedStatement pstmt = null;
  1214.         ResultSet rs = null;
  1215.         try {
  1216.         
  1217.             if(logCore!=null) {
  1218.                 // nop
  1219.             }
  1220.             
  1221.             TransazioneFieldConverter transazioneFieldConverter = new TransazioneFieldConverter(tipoDatabase);
  1222.             String idTransazioneColumn = transazioneFieldConverter.toColumn(Transazione.model().ID_TRANSAZIONE, false);
  1223.             
  1224.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  1225.             
  1226.             sqlQueryObject.addFromTable(CostantiDB.TRANSAZIONI);
  1227.             
  1228.             sqlQueryObject.addSelectField(idTransazioneColumn);
  1229.             
  1230.             sqlQueryObject.setANDLogicOperator(true);
  1231.             
  1232.             sqlQueryObject.addWhereCondition(idTransazioneColumn+"=?");
  1233.                         
  1234.             String select = sqlQueryObject.createSQLQuery();
  1235.             /**System.out.println("QUERY '"+select+"'");*/
  1236.             
  1237.             pstmt = connectionDB.prepareStatement(select);
  1238.             int index = 1;
  1239.             List<Object> params = new ArrayList<>();
  1240.             
  1241.             pstmt.setString(index++, idTransaction);
  1242.             params.add(idTransaction);
  1243.                         
  1244.             rs = pstmt.executeQuery();
  1245.             boolean esitoReturn = rs.next();

  1247.             /**String comandoSql = formatSQLString(updateCommand, params.toArray());
  1248.             System.out.println("Esists: "+esitoReturn+" (app:"+transazioneApplicativoServer.getConnettoreNome()+" id:"+transazioneApplicativoServer.getIdTransazione()+") sql:"+comandoSql);*/
  1249.             
  1250.             rs.close();
  1251.             pstmt.close();
  1252.             pstmt = null;
  1253.                         
  1254.             if(connectionDBCommit) {
  1255.                 connectionDB.commit(); // anche se si tratta di una read, serve per non far rimanere aperta la transazione
  1256.             }
  1257.             
  1258.             return esitoReturn;
  1259.             
  1260.         }catch(Throwable e) {
  1261.             
  1262.             try{
  1263.                 if(rs != null) {
  1264.                     rs.close();
  1265.                     rs = null;
  1266.                 }
  1267.             } catch(Exception er) {
  1268.                 // ignore
  1269.             }
  1270.             try{
  1271.                 if(pstmt != null) {
  1272.                     pstmt.close();
  1273.                     pstmt = null;
  1274.                 }
  1275.             } catch(Exception er) {
  1276.                 // ignore
  1277.             }
  1278.             try{
  1279.                 connectionDB.rollback();
  1280.             } catch(Exception er) {
  1281.                 // ignore
  1282.             }
  1283.             
  1284.             throw new CoreException(e.getMessage(),e);
  1285.         }finally{
  1286.             try{
  1287.                 if(rs != null) {
  1288.                     rs.close();
  1289.                     rs = null;
  1290.                 }
  1291.             } catch(Exception er) {
  1292.                 // ignore
  1293.             }
  1294.             try {
  1295.                 if(pstmt!=null) {
  1296.                     pstmt.close();
  1297.                 }
  1298.             }catch(Throwable t) {
  1299.                 // ignore
  1300.             }
  1301.         }
  1302.         
  1303.     }
  1304.     
  1305.     @Deprecated
  1306.     private static void serializableModeAggiornaInformazioneConsegnaTerminataEngine(TransazioneApplicativoServer transazioneApplicativoServer, Connection connectionDB,
  1307.             String tipoDatabase, Logger logCore,
  1308.             IDAOFactory daoFactory, Logger logFactory, ServiceManagerProperties smpFactory,
  1309.             boolean debug,
  1310.             int esitoConsegnaMultipla, int esitoConsegnaMultiplaFallita, int esitoConsegnaMultiplaCompletata, int ok,
  1311.             boolean consegnaInErroreRilevatoEsitoTransazioneConsegnaInCoda,
  1312.             long gestioneSerializableDBAttesaAttiva, int gestioneSerializableDBCheckInterval) throws CoreException {
  1313.         
  1314.         /*
  1315.           Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  1316.           che esecuzioni parallele non leggano dati inconsistenti.
  1317.           Con il livello SERIALIZABLE, se ritorna una eccezione, deve essere riprovato
  1318.           La sincronizzazione e' necessaria per via del possibile accesso simultaneo del servizio Gop
  1319.           e del servizio che si occupa di eliminare destinatari di messaggi
  1320.          */
  1321.         // setAutoCommit e livello Isolamento
  1322.         int oldTransactionIsolation = -1;
  1323.         try{
  1324.             oldTransactionIsolation = connectionDB.getTransactionIsolation();
  1325.             /** già effettuato fuori dal metodo connectionDB.setAutoCommit(false);*/
  1326.             JDBCUtilities.setTransactionIsolationSerializable(tipoDatabase, connectionDB);
  1327.         } catch(Exception er) {
  1328.             throw new CoreException("(setIsolation) "+er.getMessage(),er);
  1329.         }

  1331.         PreparedStatement pstmt = null;
  1332.         ResultSet rs = null;
  1333.         boolean updateEffettuato = false;
  1334.         
  1335.         long scadenzaWhile = DateManager.getTimeMillis() + gestioneSerializableDBAttesaAttiva;
  1336.         
  1337.         CoreException coreException = null;
  1338.         while(!updateEffettuato && DateManager.getTimeMillis() < scadenzaWhile){

  1340.             try{    
  1341.                 IDAOFactory daoF = daoFactory;
  1342.                 Logger log = logFactory;
  1343.                 ServiceManagerProperties smp = smpFactory;
  1344.                 
  1345.                 org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager jdbcServiceManager =
  1346.                         (org.openspcoop2.core.transazioni.dao.jdbc.JDBCServiceManager) daoF.getServiceManager(org.openspcoop2.core.transazioni.utils.ProjectInfo.getInstance(), 
  1347.                                 connectionDB, false,
  1348.                                 smp, log);
  1349.                 jdbcServiceManager.getJdbcProperties().setShowSql(debug);
  1350.                 JDBCTransazioneService transazioneService = (JDBCTransazioneService) jdbcServiceManager.getTransazioneService();
  1351.                 
  1352.                 transazioneService.enableSelectForUpdate();
  1353.                 
  1354.                 IPaginatedExpression pagExpression = transazioneService.newPaginatedExpression();
  1355.                 pagExpression.equals(Transazione.model().ID_TRANSAZIONE, transazioneApplicativoServer.getIdTransazione());
  1356.                 List<Map<String, Object>> l = null;
  1357.                 try {
  1358.                     l = transazioneService.select(pagExpression, Transazione.model().ESITO, Transazione.model().CONSEGNE_MULTIPLE_IN_CORSO);
  1359.                 }catch (NotFoundException notfound) {}
  1360.                 if(l!=null && !l.isEmpty()) {
  1361.                     if(l.size()>1) {
  1362.                         coreException = new CoreException("Trovata più di una transazione con id '"+transazioneApplicativoServer.getIdTransazione()+"'");
  1363.                     }
  1364.                     else {
  1365.                                                 
  1366.                         Object oEsito = l.get(0).get(Transazione.model().ESITO.getFieldName());
  1367.                         int esito = -1;
  1368.                         if(oEsito instanceof Integer) {
  1369.                             esito = (Integer) oEsito;
  1370.                         }
  1371.                         
  1372.                         Object oConsegneMultiple = l.get(0).get(Transazione.model().CONSEGNE_MULTIPLE_IN_CORSO.getFieldName());
  1373.                         int consegneMultiple = -1;
  1374.                         if(oConsegneMultiple instanceof Integer) {
  1375.                             consegneMultiple = (Integer) oConsegneMultiple;
  1376.                         }
  1377.                                                 
  1378.                         String prefix = "Trovata transazione con id '"+transazioneApplicativoServer.getIdTransazione()+"'";
  1379.                         if(esitoConsegnaMultipla == esito || esitoConsegnaMultiplaFallita == esito) {
  1380.                             int decrement = consegneMultiple-1;
  1381.                             UpdateField uFieldConsegneMultipleInCorso = new UpdateField(Transazione.model().CONSEGNE_MULTIPLE_IN_CORSO, decrement);
  1382.                             UpdateField uFieldEsito = null;
  1383.                             if(esitoConsegnaMultipla == esito) {
  1384.                                 // non appena c'è un errore, marca la transazione come fallita
  1385.                                 if(ok != transazioneApplicativoServer.getDettaglioEsito() || transazioneApplicativoServer.getDataMessaggioScaduto()!=null) {
  1386.                                     uFieldEsito = new UpdateField(Transazione.model().ESITO, esitoConsegnaMultiplaFallita);
  1387.                                 }
  1388.                                 else if(decrement<=0) {
  1389.                                     uFieldEsito = new UpdateField(Transazione.model().ESITO, esitoConsegnaMultiplaCompletata);
  1390.                                 }
  1391.                             }
  1392.                             if(uFieldEsito!=null) {
  1393.                                 transazioneService.updateFields(transazioneApplicativoServer.getIdTransazione(), uFieldConsegneMultipleInCorso, uFieldEsito);
  1394.                             }
  1395.                             else {
  1396.                                 transazioneService.updateFields(transazioneApplicativoServer.getIdTransazione(), uFieldConsegneMultipleInCorso);
  1397.                             }
  1398.                         }
  1399.                         else if(esitoConsegnaMultiplaCompletata == esito) {
  1400.                             if(logCore!=null) {
  1401.                                 String msg = prefix+", con un esito '"+esito+"' (ConsegnaMultiplaCompletata) già gestita da un altro nodo";
  1402.                                 logCore.debug(msg);
  1403.                             }
  1404.                         }
  1405.                         else {
  1406.                             coreException = new CoreException(prefix+", con un esito '"+esito+"' non atteso");
  1407.                         }

  1409.                         
  1410.                     }
  1411.                 }

  1413.                 transazioneService.disableSelectForUpdate();
  1414.                 
  1415.                 // Chiusura Transazione
  1416.                 connectionDB.commit();

  1418.                 // ID Costruito
  1419.                 updateEffettuato = true;

  1421.             } catch(Throwable e) {
  1422.                 try{
  1423.                     if(rs != null)
  1424.                         rs.close();
  1425.                 } catch(Exception er) {
  1426.                     // ignore
  1427.                 }
  1428.                 try{
  1429.                     if(pstmt != null)
  1430.                         pstmt.close();
  1431.                 } catch(Exception er) {
  1432.                     // ignore
  1433.                 }
  1434.                 try{
  1435.                     connectionDB.rollback();
  1436.                 } catch(Exception er) {
  1437.                     // ignore
  1438.                 }
  1439.             }

  1441.             if(!updateEffettuato){
  1442.                 // Per aiutare ad evitare conflitti
  1443.                 try{
  1444.                     Utilities.sleep(getRandom().nextInt(gestioneSerializableDBCheckInterval)); // random da 0ms a checkIntervalms
  1445.                 }catch(Exception eRandom){
  1446.                     // ignore
  1447.                 }
  1448.             }
  1449.         }
  1450.         // Ripristino Transazione
  1451.         try{
  1452.             connectionDB.setTransactionIsolation(oldTransactionIsolation);
  1453.             /** già effettuato fuori dal metodo connectionDB.setAutoCommit(true);*/
  1454.         } catch(Exception er) {
  1455.             throw new CoreException("(ripristinoIsolation) "+er.getMessage(),er);
  1456.         }

  1458.         if(coreException!=null) {
  1459.             throw coreException;
  1460.         }
  1461.     }
  1462. }
Created with JaCoCo 0.8.8.202204050719