GestoreMessaggi.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.  */



  23. package org.openspcoop2.pdd.core;

  25. import java.io.ByteArrayOutputStream;
  26. import java.security.SecureRandom;
  27. import java.sql.Connection;
  28. import java.sql.PreparedStatement;
  29. import java.sql.ResultSet;
  30. import java.sql.SQLException;
  31. import java.sql.Timestamp;
  32. import java.util.ArrayList;
  33. import java.util.Date;
  34. import java.util.HashMap;
  35. import java.util.List;
  36. import java.util.Map;
  37. import java.util.concurrent.ConcurrentHashMap;
  38. import java.util.concurrent.TimeUnit;

  40. import org.openspcoop2.core.commons.DBUtils;
  41. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  42. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  43. import org.openspcoop2.core.constants.CostantiDB;
  44. import org.openspcoop2.core.id.IDSoggetto;
  45. import org.openspcoop2.message.OpenSPCoop2Message;
  46. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  47. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  48. import org.openspcoop2.message.constants.MessageRole;
  49. import org.openspcoop2.message.constants.MessageType;
  50. import org.openspcoop2.message.utils.MessageUtilities;
  51. import org.openspcoop2.pdd.config.ClassNameProperties;
  52. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  53. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  54. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  55. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  56. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  57. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  58. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  59. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  60. import org.openspcoop2.pdd.mdb.Imbustamento;
  61. import org.openspcoop2.pdd.mdb.ImbustamentoRisposte;
  62. import org.openspcoop2.pdd.mdb.InoltroBuste;
  63. import org.openspcoop2.pdd.mdb.InoltroRisposte;
  64. import org.openspcoop2.pdd.mdb.Sbustamento;
  65. import org.openspcoop2.pdd.mdb.SbustamentoRisposte;
  66. import org.openspcoop2.pdd.services.core.RicezioneBuste;
  67. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  68. import org.openspcoop2.pdd.services.skeleton.IdentificativoIM;
  69. import org.openspcoop2.pdd.services.skeleton.MessaggioIM;
  70. import org.openspcoop2.pdd.timers.TimerConsegnaContenutiApplicativiThread;
  71. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  72. import org.openspcoop2.pdd.timers.TimerLock;
  73. import org.openspcoop2.pdd.timers.TimerLockNotAvailableException;
  74. import org.openspcoop2.pdd.timers.TipoLock;
  75. import org.openspcoop2.protocol.engine.Configurazione;
  76. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  77. import org.openspcoop2.protocol.engine.constants.Costanti;
  78. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  79. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  80. import org.openspcoop2.protocol.engine.driver.Riscontri;
  81. import org.openspcoop2.protocol.engine.driver.RollbackRepositoryBuste;
  82. import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
  83. import org.openspcoop2.protocol.sdk.Busta;
  84. import org.openspcoop2.protocol.sdk.Context;
  85. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  86. import org.openspcoop2.protocol.sdk.ProtocolException;
  87. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  88. import org.openspcoop2.protocol.sdk.state.StateMessage;
  89. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  90. import org.openspcoop2.utils.LoggerWrapperFactory;
  91. import org.openspcoop2.utils.MapKey;
  92. import org.openspcoop2.utils.SortedMap;
  93. import org.openspcoop2.utils.TipiDatabase;
  94. import org.openspcoop2.utils.Utilities;
  95. import org.openspcoop2.utils.UtilsException;
  96. import org.openspcoop2.utils.cache.Cache;
  97. import org.openspcoop2.utils.cache.CacheAlgorithm;
  98. import org.openspcoop2.utils.cache.CacheType;
  99. import org.openspcoop2.utils.date.DateManager;
  100. import org.openspcoop2.utils.date.DateUtils;
  101. import org.openspcoop2.utils.date.DaylightSavingUtils;
  102. import org.openspcoop2.utils.date.TimeTransitionType;
  103. import org.openspcoop2.utils.id.serial.InfoStatistics;
  104. import org.openspcoop2.utils.io.Base64Utilities;
  105. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  106. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  107. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  108. import org.openspcoop2.utils.resources.Loader;
  109. import org.openspcoop2.utils.semaphore.Semaphore;
  110. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  111. import org.openspcoop2.utils.semaphore.SemaphoreLogEventGenerator;
  112. import org.openspcoop2.utils.semaphore.SemaphoreMapping;
  113. import org.openspcoop2.utils.sql.ISQLQueryObject;
  114. import org.openspcoop2.utils.sql.SQLObjectFactory;
  115. import org.openspcoop2.utils.threads.RunnableLogger;
  116. import org.openspcoop2.utils.transport.TransportRequestContext;
  117. import org.slf4j.Logger;


  120. /**
  121.  * Classe utilizzata per la gestione dei messaggi in OpenSPCoop
  122.  *
  123.  * @author Poli Andrea (apoli@link.it)
  124.  * @author Tronci Fabio (tronci@link.it)
  125.  * @author $Author$
  126.  * @version $Rev$, $Date$
  127.  */


  130. public class GestoreMessaggi  {

  132.     /** Logger utilizzato per debug. */
  133.     private Logger log = null;

  135.     private IOpenSPCoopState openspcoopstate=null;
  136.     public IOpenSPCoopState getOpenspcoopstate() {
  137.         return this.openspcoopstate;
  138.     }
  139.     private boolean isRichiesta=false;
  140.     private boolean readyForDrop = false; // usato solo nello stateless, indica se il messaggio puo' essere cancellato dal db
  141.     private boolean portaDiTipoStateless = false;
  142.     /** Indicazione se siamo in modalita di routing stateless */
  143.     private boolean routingStateless;
  144.     private boolean oneWayVersione11 = false;




  149.     /* ********  F I E L D S    S T A T I C    P U B L I C  ******** */
  150.     /** Tabella che mantiene i messaggi da consegnare ai servizi applicativi*/
  151.     public static final String MESSAGGI  = "MESSAGGI";
  152.     /* Colonne dei Messaggi */
  153.     public static final String MESSAGGI_COLUMN_ID_MESSAGGIO  = "ID_MESSAGGIO";
  154.     public static final String MESSAGGI_COLUMN_TIPO_MESSAGGIO  = "TIPO";
  155.     public static final String MESSAGGI_COLUMN_RIFERIMENTO_MSG  = "RIFERIMENTO_MSG";
  156.     public static final String MESSAGGI_COLUMN_ORA_REGISTRAZIONE  = "ORA_REGISTRAZIONE";
  157.     public static final String MESSAGGI_COLUMN_PROPRIETARIO  = "PROPRIETARIO";
  158.     public static final String MESSAGGI_COLUMN_PROTOCOLLO  = "PROTOCOLLO";
  159.     public static final String MESSAGGI_COLUMN_ID_TRANSAZIONE  = "id_transazione";
  160.     public static final String MESSAGGI_COLUMN_CORRELAZIONE_APPLICATIVA_RICHIESTA  = "CORRELAZIONE_APPLICATIVA";
  161.     public static final String MESSAGGI_COLUMN_CORRELAZIONE_APPLICATIVA_RISPOSTA  = "CORRELAZIONE_RISPOSTA";

  163.     /** Tabella che mantiene i servizi applicativi che devono ancora ricevere un dato messaggio */
  164.     public static final String MSG_SERVIZI_APPLICATIVI  = "MSG_SERVIZI_APPLICATIVI";
  165.     /* Colonne dei Messaggi Servizi Applicativi */
  166.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_ID_MESSAGGIO  = "ID_MESSAGGIO";
  167.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_TIPO  = "TIPO";
  168.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_SERVIZIO_APPLICATIVO  = "SERVIZIO_APPLICATIVO";
  169.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_ORA_REGISTRAZIONE  = "ORA_REGISTRAZIONE";
  170.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_INTEGRATION_MANAGER  = "INTEGRATION_MANAGER";
  171.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_LOCK_CONSEGNA  = "LOCK_CONSEGNA";
  172.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_ATTESA_ESITO  = "ATTESA_ESITO";
  173.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_ERRORE_PROCESSAMENTO_COMPACT  = "ERRORE_PROCESSAMENTO_COMPACT";
  174.     public static final String MSG_SERVIZI_APPLICATIVI_COLUMN_TIPO_CONSEGNA  = "TIPO_CONSEGNA";

  176.     /** Tabella che definisce il contenuto di un messaggio */
  177.     public static final String DEFINIZIONE_MESSAGGI = "DEFINIZIONE_MESSAGGI";
  178.     /* Colonne della tabella contenente i bytes dei messaggi */
  179.     public static final String DEFINIZIONE_MESSAGGI_COLUMN_ID_MESSAGGIO = "ID_MESSAGGIO";
  180.     public static final String DEFINIZIONE_MESSAGGI_COLUMN_TIPO_MESSAGGIO = "TIPO";
  181.     public static final String DEFINIZIONE_MESSAGGI_COLUMN_ORA_REGISTRAZIONE  = "ORA_REGISTRAZIONE";

  183.     /** Tipo di consegna verso un servizio applicativo: tramite Connettore*/
  184.     public static final String CONSEGNA_TRAMITE_CONNETTORE  = "Connettore";
  185.     /** Tipo di consegna verso un servizio applicativo: tramite ConnectionReply*/
  186.     public static final String CONSEGNA_TRAMITE_CONNECTION_REPLY  = "ConnectionReply";
  187.     /** Tipo di consegna verso un servizio applicativo: solo tramite IntegrationManager*/
  188.     public static final String CONSEGNA_TRAMITE_INTEGRATION_MANAGER  = "IntegrationManager";

  190.     
  191.     private static java.util.Random _rnd = null;
  192.     private static synchronized void initRandom() {
  193.         if(_rnd==null) {
  194.             _rnd = new SecureRandom();
  195.         }
  196.     }
  197.     public static java.util.Random getRandom() {
  198.         if(_rnd==null) {
  199.             initRandom();
  200.         }
  201.         return _rnd;
  202.     }
  203.     
  204.     

  206.     /** MessaggioDiagnostico */
  207.     private MsgDiagnostico msgDiag;
  208.     /** Identificativo del Messaggio */
  209.     private String idBusta;




  214.     /** Indica la directory dove effettuare salvataggi */
  215.     private String workDir;
  216.     /** Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX */
  217.     private String tipo;
  218.     /** Properties reader */
  219.     private OpenSPCoop2Properties propertiesReader;


  222.     /** Chiave della cache per i Gestore Messaggi  */
  223.     private static final String GESTORE_MESSAGGI_CACHE_NAME = "gestoreMessaggi";
  224.     /** GestoreMessaggi Cache */
  225.     private static Cache cacheMappingGestoreMessaggi = null;

  227.     private static String cluster_id = null;

  229.     private PdDContext pddContext = null;
  230. //  public PdDContext getPddContext() { Non scommentare, c'è piu' in basso il metodo che legge dallo stato
  231. //      return this.pddContext;
  232. //  }
  233.     private IProtocolFactory<?> protocolFactory = null;
  234.     public IProtocolFactory<?> getProtocolFactory() {
  235.         return this.protocolFactory;
  236.     }
  237.     
  238.     /** ID Transazione */
  239.     private String idTransazione;

  241.     /* --------------- Cache --------------------*/
  242.     public static void resetCache() throws GestoreMessaggiException{
  243.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  244.             try{
  245.                 GestoreMessaggi.cacheMappingGestoreMessaggi.clear();
  246.             }catch(Exception e){
  247.                 throw new GestoreMessaggiException(e.getMessage(),e);
  248.             }
  249.         }
  250.     }
  251.     public static String printStatsCache(String separator) throws GestoreMessaggiException{
  252.         try{
  253.             if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  254.                 return GestoreMessaggi.cacheMappingGestoreMessaggi.printStats(separator);
  255.             }
  256.             else{
  257.                 throw new Exception("Cache non abilitata");
  258.             }
  259.         }catch(Exception e){
  260.             throw new GestoreMessaggiException("Visualizzazione Statistiche riguardante la cache dei messaggi gestiti non riuscita: "+e.getMessage(),e);
  261.         }
  262.     }
  263.     public static void abilitaCache() throws GestoreMessaggiException{
  264.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null)
  265.             throw new GestoreMessaggiException("Cache gia' abilitata");
  266.         else{
  267.             _abilitaCache();
  268.         }
  269.     }
  270.     private static synchronized void _abilitaCache() throws GestoreMessaggiException{
  271.         if(GestoreMessaggi.cacheMappingGestoreMessaggi==null) {
  272.             try{
  273.                 GestoreMessaggi.cacheMappingGestoreMessaggi = new Cache(CacheType.JCS, GestoreMessaggi.GESTORE_MESSAGGI_CACHE_NAME); // lascio JCS come default abilitato via jmx
  274.                 GestoreMessaggi.cacheMappingGestoreMessaggi.build();
  275.             }catch(Exception e){
  276.                 throw new GestoreMessaggiException(e.getMessage(),e);
  277.             }
  278.         }
  279.     }
  280.     public static void abilitaCache(long dimensioneCache,boolean algoritmoCacheLRU,long itemIdleTime,long itemLifeSecond) throws GestoreMessaggiException{
  281.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null)
  282.             throw new GestoreMessaggiException("Cache gia' abilitata");
  283.         else{
  284.             try{
  285.                 String algoritmoCache = null;
  286.                 if(algoritmoCacheLRU)
  287.                     algoritmoCache = CostantiConfigurazione.CACHE_LRU.toString() ;
  288.                 else
  289.                     algoritmoCache = CostantiConfigurazione.CACHE_MRU.toString();
  290.                 GestoreMessaggi.initCacheGestoreMessaggi(CacheType.JCS, (int)dimensioneCache,algoritmoCache,itemIdleTime,itemLifeSecond,null,null); // lascio JCS come default abilitato via jmx
  291.             }catch(Exception e){
  292.                 throw new GestoreMessaggiException(e.getMessage(),e);
  293.             }
  294.         }
  295.     }
  296.     public static void disabilitaCache() throws GestoreMessaggiException{
  297.         if(GestoreMessaggi.cacheMappingGestoreMessaggi==null)
  298.             throw new GestoreMessaggiException("Cache gia' disabilitata");
  299.         else{
  300.             _disabilitaCache();
  301.         }
  302.     }
  303.     private static synchronized void _disabilitaCache() throws GestoreMessaggiException{
  304.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null) {
  305.             try{
  306.                 GestoreMessaggi.cacheMappingGestoreMessaggi.clear();
  307.                 GestoreMessaggi.cacheMappingGestoreMessaggi = null;
  308.             }catch(Exception e){
  309.                 throw new GestoreMessaggiException(e.getMessage(),e);
  310.             }
  311.         }
  312.     }
  313.     public static boolean isCacheAbilitata(){
  314.         return GestoreMessaggi.cacheMappingGestoreMessaggi != null;
  315.     }
  316.     public static String listKeysCache(String separator) throws GestoreMessaggiException{
  317.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  318.             try{
  319.                 return GestoreMessaggi.cacheMappingGestoreMessaggi.printKeys(separator);
  320.             }catch(Exception e){
  321.                 throw new GestoreMessaggiException(e.getMessage(),e);
  322.             }
  323.         }else{
  324.             throw new GestoreMessaggiException("Cache non abilitata");
  325.         }
  326.     }
  327.     public static String getObjectCache(String key) throws GestoreMessaggiException{
  328.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  329.             try{
  330.                 Object o = GestoreMessaggi.cacheMappingGestoreMessaggi.get(key);
  331.                 if(o!=null){
  332.                     return o.toString();
  333.                 }else{
  334.                     return "oggetto con chiave ["+key+"] non presente";
  335.                 }
  336.             }catch(Exception e){
  337.                 throw new GestoreMessaggiException(e.getMessage(),e);
  338.             }
  339.         }else{
  340.             throw new GestoreMessaggiException("Cache non abilitata");
  341.         }
  342.     }
  343.     public static void removeObjectCache(String key) throws GestoreMessaggiException{
  344.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  345.             try{
  346.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  347.             }catch(Exception e){
  348.                 throw new GestoreMessaggiException(e.getMessage(),e);
  349.             }
  350.         }else{
  351.             throw new GestoreMessaggiException("Cache non abilitata");
  352.         }
  353.     }



  357.     /** Inizializzazione della Cache, se abilitata */
  358.     public static void initialize() throws Exception{
  359.         OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  360.         if(properties.isAbilitataCacheGestoreMessaggi()){
  361.             Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  362.             Logger logConsole = OpenSPCoop2Logger.getLoggerOpenSPCoopConsole();
  363.             int dimensioneCache = properties.getDimensioneCacheGestoreMessaggi();
  364.             String algoritmoCache = properties.getAlgoritmoCacheGestoreMessaggi();
  365.             long itemIdleTime = properties.getItemIdleTimeCacheGestoreMessaggi();
  366.             long itemLifeSecond = properties.getItemLifeSecondCacheGestoreMessaggi();
  367.             CacheType cacheType = properties.getCacheTypeMessage();
  368.             GestoreMessaggi.initCacheGestoreMessaggi(cacheType, dimensioneCache,algoritmoCache,itemIdleTime,itemLifeSecond,log,logConsole);
  369.         }
  370.     }

  372.     public static void initCacheGestoreMessaggi(CacheType cacheType, int dimensioneCache,String algoritmoCache,long itemIdleTime,long itemLifeSecond,Logger log,Logger logConsole) throws Exception{

  374.         if(log!=null)
  375.             log.info("Inizializzazione cache gestoreMessaggi");
  376.         if(logConsole!=null)
  377.             logConsole.info("Inizializzazione cache gestoreMessaggi");

  379.         GestoreMessaggi.cacheMappingGestoreMessaggi = new Cache(cacheType, GestoreMessaggi.GESTORE_MESSAGGI_CACHE_NAME);

  381.         String msg = null;
  382.         if( (dimensioneCache>0) ||
  383.                 (algoritmoCache != null) ){

  385.             if( dimensioneCache>0 ){
  386.                 try{
  387.                     msg = "Dimensione della cache (Gestore Messaggi) impostata al valore: "+dimensioneCache;
  388.                     if(log!=null)
  389.                         log.info(msg);
  390.                     if(logConsole!=null)
  391.                         logConsole.info(msg);
  392.                     GestoreMessaggi.cacheMappingGestoreMessaggi.setCacheSize(dimensioneCache);
  393.                 }catch(Exception error){
  394.                     throw new DriverConfigurazioneException("Parametro errato per la dimensione della cache (Gestore Messaggi): "+error.getMessage());
  395.                 }
  396.             }
  397.             if(algoritmoCache != null ){
  398.                 msg = "Algoritmo di cache (Gestore Messaggi) impostato al valore: "+algoritmoCache;
  399.                 if(log!=null)
  400.                     log.info(msg);
  401.                 if(logConsole!=null)
  402.                     logConsole.info(msg);
  403.                 if(CostantiConfigurazione.CACHE_MRU.toString().equalsIgnoreCase(algoritmoCache))
  404.                     GestoreMessaggi.cacheMappingGestoreMessaggi.setCacheAlgoritm(CacheAlgorithm.MRU);
  405.                 else
  406.                     GestoreMessaggi.cacheMappingGestoreMessaggi.setCacheAlgoritm(CacheAlgorithm.LRU);
  407.             }

  409.         }

  411.         if( itemIdleTime > 0  ){
  412.             try{
  413.                 msg = "Attributo 'IdleTime' (Gestore Messaggi) impostato al valore: "+itemIdleTime;
  414.                 if(log!=null)
  415.                     log.info(msg);
  416.                 if(logConsole!=null)
  417.                     logConsole.info(msg);
  418.                 GestoreMessaggi.cacheMappingGestoreMessaggi.setItemIdleTime(itemIdleTime);
  419.             }catch(Exception error){
  420.                 throw new DriverConfigurazioneException("Parametro errato per l'attributo 'IdleTime' (Gestore Messaggi): "+error.getMessage());
  421.             }
  422.         }

  424.         try{
  425.             msg = "Attributo 'MaxLifeSecond' (Gestore Messaggi) impostato al valore: "+itemLifeSecond;
  426.             if(log!=null)
  427.                 log.info(msg);
  428.             if(logConsole!=null)
  429.                 logConsole.info(msg);
  430.             GestoreMessaggi.cacheMappingGestoreMessaggi.setItemLifeTime(itemLifeSecond);
  431.         }catch(Exception error){
  432.             throw new DriverConfigurazioneException("Parametro errato per l'attributo 'MaxLifeSecond' (Gestore Messaggi): "+error.getMessage());
  433.         }

  435.         GestoreMessaggi.cacheMappingGestoreMessaggi.build();
  436.     }
  437.     
  438.     
  439.     @SuppressWarnings("deprecation")
  440.     @Deprecated
  441.     public static void disableSyncronizedGet() throws UtilsException {
  442.         if(GestoreMessaggi.cacheMappingGestoreMessaggi==null) {
  443.             throw new UtilsException("Cache disabled");
  444.         }
  445.         GestoreMessaggi.cacheMappingGestoreMessaggi.disableSyncronizedGet();
  446.     }
  447.     @SuppressWarnings("deprecation")
  448.     @Deprecated
  449.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  450.         if(GestoreMessaggi.cacheMappingGestoreMessaggi==null) {
  451.             throw new UtilsException("Cache disabled");
  452.         }
  453.         return GestoreMessaggi.cacheMappingGestoreMessaggi.isDisableSyncronizedGet();
  454.     }
  455.     



  459.     /** Elementi in cache 
  460.      * @throws UtilsException */
  461.     public static String cacheToString() throws UtilsException{
  462.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  463.             StringBuilder bf = new StringBuilder();
  464.             bf.append("Cache GestoreMessaggi: "+GestoreMessaggi.cacheMappingGestoreMessaggi.printStats(" "));
  465.             return bf.toString();
  466.         }else
  467.             return "Cache non abilitata";
  468.     }

  470.     /** Registrazione Mapping rifMsg-id */
  471.     public static void addIntoCache_MappingRifMsgToId(MsgDiagnostico msgDiag, String tipoMessaggio,String riferimentoMessaggio, String idBusta) throws UtilsException{
  472.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  473.             String key = "mappingRifMsgToId_"+tipoMessaggio+"_"+riferimentoMessaggio;
  474.             GestoreMessaggi.cacheMappingGestoreMessaggi.put(key, idBusta);
  475.             /* PUT SAFE COSTOSO
  476.             try{
  477.                 GestoreMessaggi.cacheMappingGestoreMessaggi.putSafe(key, idBusta);
  478.             }catch(ObjectExistsException ex){
  479.                 //String oldValue = (String) GestoreMessaggi.cacheMappingGestoreMessaggi.get(key);
  480.                 //msgDiag.highDebug("RiferimentoMessaggio ["+tipoMessaggio+"]/["+riferimentoMessaggio+"] gia registrato, con il valore "+oldValue + " (nuovo valore:"+idBusta+")");
  481.                 msgDiag.highDebug("RiferimentoMessaggio ["+tipoMessaggio+"]/["+riferimentoMessaggio+"] gia registrato (nuovo valore:"+idBusta+")");
  482.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  483.                 GestoreMessaggi.cacheMappingGestoreMessaggi.put(key, idBusta);
  484.             }
  485.              */
  486.             //System.out.println("AGGIORNO CACHE RIFERIMENTO RIF["+tipoMessaggio+"_"+riferimentoMessaggio+"] ID["+idBusta+"]");
  487.         }
  488.     }
  489.     /** Get RiferimentoMessaggio */
  490.     public static String getFromCache_idFromRifMsgMapping(String tipoMessaggio,String riferimentoMessaggio){
  491.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  492.             Object obj = GestoreMessaggi.cacheMappingGestoreMessaggi.get("mappingRifMsgToId_"+tipoMessaggio+"_"+riferimentoMessaggio);
  493.             // System.out.println("GET FROM CACHE RIFERIMENTO RIF["+tipoMessaggio+"_"+riferimentoMessaggio+"] ID TROVATO: ["+obj+"]");
  494.             if(obj!=null)
  495.                 return (String) obj;
  496.             else
  497.                 return null;
  498.         }else
  499.             return null;
  500.     }
  501.     /** delete exists */
  502.     public static void deleteFromCache_idFromRifMsgMapping(String tipoMessaggio,String riferimentoMessaggio){
  503.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  504.             String key = "mappingRifMsgToId_"+tipoMessaggio+"_"+riferimentoMessaggio;
  505.             try{
  506.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  507.                 //System.out.println("DELETE FROM CACHE RIF MSG KEY["+key+"]");
  508.             }catch(Exception e){
  509.                 //System.out.println("DELETE FROM CACHE RIF MSG KEY["+key+"] ERROR:"+e.getMessage());
  510.             }
  511.         }
  512.     }

  514.     /** Registrazione proprietario */
  515.     public static void addIntoCache_Proprietario(MsgDiagnostico msgDiag, String tipoMessaggio,String idBusta, String proprietario) throws UtilsException{
  516.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){

  518.             String prop = proprietario;
  519.             if(prop.startsWith(RicezioneContenutiApplicativi.ID_MODULO)){
  520.                 prop = RicezioneContenutiApplicativi.ID_MODULO;
  521.             }else if(prop.startsWith(RicezioneBuste.ID_MODULO)){
  522.                 prop = RicezioneBuste.ID_MODULO;
  523.             }

  525.             String key = "proprietario_to"+prop+"_("+tipoMessaggio+"_"+idBusta+")";
  526.             GestoreMessaggi.cacheMappingGestoreMessaggi.put(key, proprietario);
  527.             /* PUT SAFE COSTOSO
  528.             try{
  529.                 GestoreMessaggi.cacheMappingGestoreMessaggi.putSafe(key, proprietario);
  530.             }catch(ObjectExistsException ex){
  531.                 //String oldValue = (String) GestoreMessaggi.cacheMappingGestoreMessaggi.get(key);
  532.                 //msgDiag.highDebug("Proprietario ["+tipoMessaggio+"]/["+idBusta+"] gia registrato, con il valore "+oldValue + " (nuovo valore:"+proprietario+")");
  533.                 msgDiag.highDebug("Proprietario ["+tipoMessaggio+"]/["+idBusta+"] gia registrato, (nuovo valore:"+proprietario+")");
  534.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  535.                 GestoreMessaggi.cacheMappingGestoreMessaggi.put(key, proprietario);
  536.             }
  537.              */
  538.             //System.out.println("AGGIORNO CACHE PROPRIETARIO KEY["+key+"] ID["+proprietario+"]");
  539.         }
  540.     }
  541.     /** Get proprietario */
  542.     public static String getFromCache_Proprietario(String idModulo,String tipoMessaggio,String idBusta){
  543.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){

  545.             String prop = idModulo;
  546.             if(prop.startsWith(RicezioneContenutiApplicativi.ID_MODULO)){
  547.                 prop = RicezioneContenutiApplicativi.ID_MODULO;
  548.             }else if(prop.startsWith(RicezioneBuste.ID_MODULO)){
  549.                 prop = RicezioneBuste.ID_MODULO;
  550.             }

  552.             String key = "proprietario_to"+prop+"_("+tipoMessaggio+"_"+idBusta+")";
  553.             Object obj = GestoreMessaggi.cacheMappingGestoreMessaggi.get(key);
  554.             //System.out.println("GET FROM CACHE PROPRIETARIO KEY["+key+"] ID TROVATO: ["+obj+"]");
  555.             if(obj!=null)
  556.                 return (String) obj;
  557.             else
  558.                 return null;
  559.         }else
  560.             return null;
  561.     }
  562.     /** delete proprietario */
  563.     public static void deleteFromCache_Proprietario(String modulo,String tipoMessaggio,String idBusta){
  564.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  565.             String key = "proprietario_to"+modulo+"_("+tipoMessaggio+"_"+idBusta+")";
  566.             try{
  567.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  568.                 //System.out.println("DELETE FROM CACHE Proprietario KEY["+key+"]");
  569.             }catch(Exception e){
  570.                 //System.out.println("DELETE FROM CACHE Proprietario KEY["+key+"] ERROR:"+e.getMessage());
  571.             }
  572.         }
  573.     }
  574.     /** Registrazione messaggio */
  575.     public static void addIntoCache_existsMessage(MsgDiagnostico msgDiag,String tipoMessaggio,String idBusta) throws UtilsException{
  576.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  577.             String key = "existsMessage_"+tipoMessaggio+"_"+idBusta;
  578.             GestoreMessaggi.cacheMappingGestoreMessaggi.put(key, true);
  579.             /* PUT SAFE COSTOSO
  580.             try{
  581.                 GestoreMessaggi.cacheMappingGestoreMessaggi.putSafe(key, true);
  582.             }catch(ObjectExistsException ex){
  583.                 msgDiag.highDebug("Messaggio (existsMessage) ["+tipoMessaggio+"]/["+idBusta+"] gia registrato");
  584.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  585.                 GestoreMessaggi.cacheMappingGestoreMessaggi.put(key, true);
  586.             }*/
  587.             //System.out.println("AGGIORNO CACHE EXISTS MESSAGGIO ID["+tipoMessaggio+"_"+idBusta+"]");
  588.         }
  589.     }
  590.     /** exists messaggio */
  591.     public static boolean getFromCache_existsMessage(String tipoMessaggio,String idBusta){
  592.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  593.             Object obj = GestoreMessaggi.cacheMappingGestoreMessaggi.get("existsMessage_"+tipoMessaggio+"_"+idBusta);
  594.             //System.out.println("GET FROM CACHE EXISTS MESSAGGIO["+tipoMessaggio+"_"+idBusta+"] ID TROVATO: ["+obj+"]");
  595.             if(obj!=null)
  596.                 return (Boolean) obj;
  597.             else
  598.                 return false;
  599.         }else
  600.             return false;
  601.     }
  602.     /** delete exists */
  603.     public static void deleteFromCache_existsMessage(String tipoMessaggio,String idBusta){
  604.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  605.             String key = "existsMessage_"+tipoMessaggio+"_"+idBusta;
  606.             try{
  607.                 GestoreMessaggi.cacheMappingGestoreMessaggi.remove(key);
  608.                 //System.out.println("DELETE FROM CACHE EXISTS MESSAGE KEY["+key+"]");
  609.             }catch(Exception e){
  610.                 //System.out.println("DELETE FROM CACHE EXISTS MESSAGE KEY["+key+"] ERROR: "+e.getMessage());
  611.             }
  612.         }
  613.     }



  617.     /** Tabella Hash contenente il mapping tra tipo-id e proprietario */
  618.     private Map<String,String> tableProprietariMessaggiGestiti;

  620.     /**
  621.      * Aggiunge il proprietario di un idGestito.
  622.      * 
  623.      * @param tipo
  624.      * @param idBusta
  625.      * @param proprietario
  626.      */
  627.     private void addProprietarioIntoTable(String tipo,String idBusta,String proprietario){
  628.         this.tableProprietariMessaggiGestiti.put(tipo+"@"+idBusta, proprietario);
  629.     }
  630.     /*
  631.     private String getProprietarioFromTable(String tipo,String idBusta){
  632.         return this.tableProprietariMessaggiGestiti.get(tipo+"@"+idBusta);
  633.     }
  634.      */
  635.     public void addProprietariMsgGestitiFromTable(Map<String,String> t)throws UtilsException{
  636.         this.tableProprietariMessaggiGestiti.putAll(t);
  637.     }
  638.     public Map<String, String> getTableProprietariMessaggiGestiti() {
  639.         return this.tableProprietariMessaggiGestiti;
  640.     }
  641.     public void addProprietariIntoCache_readFromTable(String modulo,String descrizione,String idBustaRichiestaCorrelata,boolean router){

  643.         if (this.openspcoopstate instanceof OpenSPCoopStateless) return; // NOP

  645.         for (String key : this.tableProprietariMessaggiGestiti.keySet()) {
  646.             String idTipo [] = key.split("@");
  647.             String value = this.tableProprietariMessaggiGestiti.get(key);
  648.             try{
  649.                 //System.out.println("Aggiornamento proprietario ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] ...");
  650.                 this.msgDiag.highDebug("Aggiornamento proprietario ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] ...");
  651.                 GestoreMessaggi.addIntoCache_Proprietario(this.msgDiag,idTipo[0],idTipo[1],value);
  652.                 this.msgDiag.highDebug("Aggiornamento proprietario ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] effettuata");

  654.                 if(TimerGestoreMessaggi.ID_MODULO.equals(value)){
  655.                     //  System.out.println("Gestione eliminazione messaggio");
  656.                     this.puliziaCache(modulo, this.idBusta, this.tipo, idBustaRichiestaCorrelata, router);
  657.                 }else{
  658.                     //System.out.println("Pulizia vecchi proprietari");
  659.                     this.puliziaCacheAltriProprietari(modulo, this.idBusta, this.tipo);
  660.                 }

  662.             }catch(Exception e){
  663.                 //System.out.println("Aggiornamento proprietario ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] ERROR");
  664.                 this.msgDiag.logErroreGenerico(e,"GestoreMessaggi.addIntoCache_Proprietario(Descr:"+descrizione+",Modulo:"+modulo+",Per:"+idTipo[0]+"/"+idTipo[1]+",Value:"+value+"");
  665.                 this.log.error("Aggiornamento proprietario ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] non riuscita",e);
  666.             }
  667.         }
  668.     }
  669.     public void puliziaCacheAltriProprietari(String moduloVecchio,String idBusta,String tipo){
  670.         //System.out.println("OLD");
  671.         if(moduloVecchio.indexOf(RicezioneContenutiApplicativi.ID_MODULO)>=0){
  672.             GestoreMessaggi.deleteFromCache_Proprietario(RicezioneContenutiApplicativi.ID_MODULO,tipo, idBusta);
  673.         }
  674.         else if(moduloVecchio.indexOf(Imbustamento.ID_MODULO)>=0){
  675.             GestoreMessaggi.deleteFromCache_Proprietario(Imbustamento.ID_MODULO,tipo, idBusta);
  676.         }
  677.         else if(moduloVecchio.indexOf(InoltroBuste.ID_MODULO)>=0){
  678.             GestoreMessaggi.deleteFromCache_Proprietario(InoltroBuste.ID_MODULO,tipo, idBusta);
  679.         }
  680.         else if(moduloVecchio.indexOf(SbustamentoRisposte.ID_MODULO)>=0){
  681.             GestoreMessaggi.deleteFromCache_Proprietario(SbustamentoRisposte.ID_MODULO,tipo, idBusta);
  682.         }
  683.         else if(moduloVecchio.indexOf(RicezioneBuste.ID_MODULO)>=0){
  684.             GestoreMessaggi.deleteFromCache_Proprietario(RicezioneBuste.ID_MODULO,tipo, idBusta);
  685.         }
  686.         else if(moduloVecchio.indexOf(Sbustamento.ID_MODULO)>=0){
  687.             GestoreMessaggi.deleteFromCache_Proprietario(Sbustamento.ID_MODULO,tipo, idBusta);
  688.         }
  689.         else if(moduloVecchio.indexOf(ConsegnaContenutiApplicativi.ID_MODULO)>=0){
  690.             GestoreMessaggi.deleteFromCache_Proprietario(ConsegnaContenutiApplicativi.ID_MODULO,tipo, idBusta);
  691.         }
  692.         else if(moduloVecchio.indexOf(InoltroRisposte.ID_MODULO)>=0){
  693.             GestoreMessaggi.deleteFromCache_Proprietario(InoltroRisposte.ID_MODULO,tipo, idBusta);
  694.         }
  695.         else if(moduloVecchio.indexOf(ImbustamentoRisposte.ID_MODULO)>=0){
  696.             GestoreMessaggi.deleteFromCache_Proprietario(ImbustamentoRisposte.ID_MODULO,tipo, idBusta);
  697.         }
  698.     }
  699.     public void puliziaCache(String modulo,String idBusta,String tipo,String idBustaRichiesta,boolean router){
  700.         try{
  701.             //System.out.println("delete existsMessage....");
  702.             // Pulizia esistenza Messaggio
  703.             GestoreMessaggi.deleteFromCache_existsMessage(tipo, idBusta);

  705.             // Pulizia riferimentoMessaggio
  706.             if(idBustaRichiesta!=null){
  707.                 //System.out.println("delete riferimentoMsg....");
  708.                 GestoreMessaggi.deleteFromCache_idFromRifMsgMapping(tipo, idBustaRichiesta);
  709.             }

  711.             // Pulizia proprietari
  712.             if(router){
  713.                 if(idBustaRichiesta==null){
  714.                     // delete Richiesta
  715.                     //System.out.println("router richiesta....");
  716.                     GestoreMessaggi.deleteFromCache_Proprietario(InoltroBuste.ID_MODULO,tipo, idBusta);
  717.                 }else{
  718.                     // delete Risposta
  719.                     //System.out.println("router risposta....");
  720.                     GestoreMessaggi.deleteFromCache_Proprietario(RicezioneBuste.ID_MODULO,tipo, idBusta);
  721.                 }
  722.             }else{

  724.                 if(idBustaRichiesta==null){
  725.                     if(Costanti.OUTBOX.equals(tipo)){
  726.                         // portaDelegata richiesta
  727.                         //System.out.println("pd richiesta....");
  728.                         GestoreMessaggi.deleteFromCache_Proprietario(Imbustamento.ID_MODULO,tipo, idBusta);
  729.                         GestoreMessaggi.deleteFromCache_Proprietario(InoltroBuste.ID_MODULO,tipo, idBusta);
  730.                     }else{
  731.                         // portaApplicativa richiesta
  732.                         //System.out.println("pa richiesta....");
  733.                         GestoreMessaggi.deleteFromCache_Proprietario(Sbustamento.ID_MODULO,tipo, idBusta);
  734.                         GestoreMessaggi.deleteFromCache_Proprietario(ConsegnaContenutiApplicativi.ID_MODULO,tipo, idBusta);
  735.                     }
  736.                 }else{
  737.                     if(Costanti.INBOX.equals(tipo)){
  738.                         // portaDelegata risposta
  739.                         //System.out.println("pd risposta....");
  740.                         GestoreMessaggi.deleteFromCache_Proprietario(SbustamentoRisposte.ID_MODULO,tipo, idBusta);
  741.                         GestoreMessaggi.deleteFromCache_Proprietario(RicezioneContenutiApplicativi.ID_MODULO,tipo, idBusta);
  742.                     }else{
  743.                         // portaApplicativa risposta
  744.                         //System.out.println("pa risposta....");
  745.                         GestoreMessaggi.deleteFromCache_Proprietario(ImbustamentoRisposte.ID_MODULO,tipo, idBusta);
  746.                         // nota: solo una delle due delete sara' effettiva, poiche' il msg di sblocco dato a RicezioneBuste e il msg reale dato a InoltroRisposte hanno id diverso
  747.                         GestoreMessaggi.deleteFromCache_Proprietario(RicezioneBuste.ID_MODULO,tipo, idBusta);
  748.                         GestoreMessaggi.deleteFromCache_Proprietario(InoltroRisposte.ID_MODULO,tipo, idBusta);
  749.                     }
  750.                 }
  751.             }
  752.             //System.out.println("fine");

  754.         }catch(Exception e){
  755.             this.msgDiag.logErroreGenerico(e,"GestoreMessaggi.puliziaCache(Modulo:"+modulo+",Per:"+idBusta+"/"+tipo+",Router:"+router+"");
  756.             this.log.error("Pulizia della cache non riuscita (Modulo:"+modulo+") per ["+idBusta+"/"+tipo+"] router["+router+"]",e);
  757.         }
  758.     }




  763.     /** Tabella Hash contenente l'informazione sull'esistenza di un messaggio */
  764.     private Map<String,Boolean> tableMessaggiGestiti;

  766.     /**
  767.      * Regitra l'id di un msg gestito
  768.      * 
  769.      * @param tipo
  770.      * @param idBusta
  771.      */
  772.     private void addMessaggioIntoTable(String tipo,String idBusta){
  773.         this.tableMessaggiGestiti.put(tipo+"@"+idBusta,true);
  774.     }
  775.     /*
  776.     public boolean getMessaggioFromTable(String tipo,String idBusta){
  777.         Object v = this.tableMessaggiGestiti.get(tipo+"@"+idBusta);
  778.         if(v!=null)
  779.             return (Boolean )v;
  780.         else
  781.             return false;

  783.     }
  784.      */
  785.     public void addMsgGestitiFromTable(Map<String,Boolean> t)throws UtilsException{
  786.         this.tableMessaggiGestiti.putAll(t);
  787.     }
  788.     public Map<String, Boolean> getTableMessaggiGestiti() {
  789.         return this.tableMessaggiGestiti;
  790.     }
  791.     public void addMessaggiIntoCache_readFromTable(String modulo,String descrizione){

  793.         if (this.openspcoopstate instanceof OpenSPCoopStateless) return; //NOP

  795.         for (String key : this.tableMessaggiGestiti.keySet()) {
  796.             String idTipo [] = key.split("@");
  797.             Boolean value = this.tableMessaggiGestiti.get(key);
  798.             try{
  799.                 this.msgDiag.highDebug("Aggiornamento existsMessage ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] ...");
  800.                 GestoreMessaggi.addIntoCache_existsMessage(this.msgDiag,idTipo[0],idTipo[1]);
  801.                 this.msgDiag.highDebug("Aggiornamento existsMessage ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] effettuata");
  802.             }catch(Exception e){
  803.                 this.msgDiag.logErroreGenerico(e,"GestoreMessaggi.addIntoCache_existsMessage(Descr:"+descrizione+",Modulo:"+modulo+",Per:"+idTipo[0]+"/"+idTipo[1]+",Value:"+value+"");
  804.                 this.log.error("Aggiornamento existsMessage ["+descrizione+"] (Modulo:"+modulo+") per ["+idTipo[0]+"/"+idTipo[1]+"] a ["+value+"] non riuscita",e);
  805.             }
  806.         }
  807.     }



  811.     /* ********  S T A T I C  JDBC ADAPTER  ******** */

  813.     /** adapterJDBC di OpenSPCoop di OpenSPCoop */
  814.     private static IJDBCAdapter adapter=null;
  815.     private static boolean adapterInitialized = false;
  816.     private static synchronized void initAdapter(Logger log,OpenSPCoop2Properties propertiesReader){
  817.         if(GestoreMessaggi.adapterInitialized==false){
  818.             if(propertiesReader.isRepositoryOnFS() == false){
  819.                 try{
  820.                     String jdbcAdapter = propertiesReader.getRepositoryJDBCAdapter();
  821.                     if(propertiesReader.getDatabaseType()!=null && TipiDatabase.DEFAULT.equals(jdbcAdapter)){
  822.                         //System.out.println("PASSO DA FACTORY GESTORE MESSAGGI");
  823.                         GestoreMessaggi.adapter = JDBCAdapterFactory.createJDBCAdapter(propertiesReader.getDatabaseType());
  824.                     }
  825.                     else{
  826.                         ClassNameProperties classNameProperties = ClassNameProperties.getInstance();
  827.                         //      Ricerco connettore
  828.                         String adapterClass = classNameProperties.getJDBCAdapter(jdbcAdapter);
  829.                         if(adapterClass == null){
  830.                             log.error("Inizializzione GestoreMessaggi non riuscita: AdapterClass non registrata ["+propertiesReader.getRepositoryJDBCAdapter()+"]");
  831.                         }
  832.                         Loader loader = Loader.getInstance();
  833.                         GestoreMessaggi.adapter = (IJDBCAdapter) loader.newInstance(adapterClass);
  834.                     }
  835.                 }catch(Exception e){
  836.                     log.error("Inizializzione GestoreMessaggi non riuscita: AdapterClass non trovata ["+propertiesReader.getRepositoryJDBCAdapter()+"]:"+e.getMessage(),e);
  837.                 }
  838.             }
  839.             GestoreMessaggi.adapterInitialized = true;
  840.         }
  841.     }



  845.     /* ********  S T A T I C  PDDCONTEXT SERIALIZER  ******** */

  847.     /** PdDContextSerializer */
  848.     private static IPdDContextSerializer pddContextSerializer = null;
  849.     private static boolean pddContextSerializerInitialized = false;
  850.     private static synchronized void initPddContextSerializer(Logger log,OpenSPCoop2Properties propertiesReader){
  851.         if(GestoreMessaggi.pddContextSerializerInitialized==false){
  852.             String pddContextSerializerClass = propertiesReader.getPddContextSerializer();
  853.             if(pddContextSerializerClass!=null && !CostantiConfigurazione.NONE.equals(pddContextSerializerClass)){
  854.                 try{
  855.                     Loader loader = Loader.getInstance();
  856.                     GestoreMessaggi.pddContextSerializer = (IPdDContextSerializer) loader.newInstance(pddContextSerializerClass);
  857.                 }catch(Exception e){
  858.                     log.error("Inizializzione GestoreMessaggi non riuscita: IPdDContextSerializer non trovata ["+pddContextSerializerClass+"]:"+e.getMessage(),e);
  859.                 }
  860.             }
  861.             GestoreMessaggi.pddContextSerializerInitialized = true;
  862.         }
  863.     }



  867.     /* ********  C O S T R U T T O R E  ******** */

  869.     /**
  870.      * Costruttore. 
  871.      *
  872.      * @param openspcoopstate Oggetto che rappresenta lo stato di una busta
  873.      * 
  874.      */
  875.     public GestoreMessaggi(IOpenSPCoopState openspcoopstate, boolean isRichiesta,MsgDiagnostico msgDiag,PdDContext pddContext){
  876.         this(openspcoopstate, isRichiesta, null,null,OpenSPCoop2Logger.getLoggerOpenSPCoopCore(),msgDiag,pddContext);
  877.     }
  878.     /**
  879.      * Costruttore. 
  880.      *
  881.      * @param openspcoopstate Oggetto che rappresenta lo stato di una busta
  882.      * 
  883.      */
  884.     public GestoreMessaggi(IOpenSPCoopState openspcoopstate, boolean isRichiesta,Logger alog,MsgDiagnostico msgDiag,PdDContext pddContext){
  885.         this(openspcoopstate, isRichiesta,null,null,alog,msgDiag,pddContext);
  886.     }

  888.     /**
  889.      * Costruttore. 
  890.      * @param openspcoopstate Oggetto che rappresenta lo stato di una busta 
  891.      * @param idBusta Identificativo del Messaggio
  892.      * @param tipo Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX
  893.      * 
  894.      */
  895.     public GestoreMessaggi(IOpenSPCoopState openspcoopstate, boolean isRichiesta,String idBusta, String tipo,MsgDiagnostico msgDiag,PdDContext pddContext){
  896.         this(openspcoopstate, isRichiesta, idBusta,tipo,Configurazione.getLibraryLog(),msgDiag,pddContext);
  897.     }
  898.     /**
  899.      * Costruttore. 
  900.      *
  901.      * @param openspcoopstate Oggetto che rappresenta lo stato di una busta
  902.      * @param idBusta Identificativo del Messaggio
  903.      * @param tipo Indicazione se il messaggio sara' salvato nella INBOX dei messaggi, o nella OUTBOX
  904.      * 
  905.      */
  906.     public GestoreMessaggi(IOpenSPCoopState openspcoopstate, boolean isRichiesta, String idBusta, String tipo,Logger alog,MsgDiagnostico msgDiag,PdDContext pddContext){
  907.         this.openspcoopstate = openspcoopstate;
  908.         this.isRichiesta = isRichiesta;
  909.         //state = (isRichiesta) ? openspcoopstate.getStatoRichiesta() : openspcoopstate.getStatoRisposta();
  910.         // new  HashMap<String,PreparedStatement>(); in stateful ?? inizializzo ?
  911.         this.tableProprietariMessaggiGestiti = new  ConcurrentHashMap<String,String>();
  912.         this.tableMessaggiGestiti = new ConcurrentHashMap<String, Boolean>();
  913.         this.idBusta = idBusta;
  914.         this.tipo = tipo;
  915.         this.propertiesReader = OpenSPCoop2Properties.getInstance();
  916.         this.msgDiag = msgDiag;
  917.         if(alog!=null){
  918.             this.log = alog;
  919.         }else{
  920.             this.log = LoggerWrapperFactory.getLogger(GestoreMessaggi.class);
  921.         }

  923.         if(this.propertiesReader.isRepositoryOnFS() == false){
  924.             if(GestoreMessaggi.adapterInitialized==false){
  925.                 GestoreMessaggi.initAdapter(this.log,this.propertiesReader);
  926.             }
  927.         }else{
  928.             this.workDir = this.propertiesReader.getRepositoryDirectory();
  929.         }

  931.         if(GestoreMessaggi.pddContextSerializerInitialized==false){
  932.             GestoreMessaggi.initPddContextSerializer(this.log,this.propertiesReader);
  933.         }

  935.         GestoreMessaggi.cluster_id = this.propertiesReader.getClusterId(false);

  937.         this.pddContext = pddContext;
  938.         try{
  939.             if(this.pddContext!=null) {
  940.                 this.idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  941.                 this.protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  942.             }
  943.         }catch(Exception e){
  944.             this.log.error("Inizializzione GestoreMessaggi non riuscita [ProtocoFactoryManager.getInstance]:"+e.getMessage(),e);
  945.         }

  947.     }












  960.     /* ********  U T I L I T Y  ******** */

  962.     /**
  963.      * Imposta lo stateMessage
  964.      *
  965.      * @param openspcoopstate oggetto che rappresenta lo stato della busta
  966.      * 
  967.      */
  968.     public void updateOpenSPCoopState(IOpenSPCoopState openspcoopstate){
  969.         this.openspcoopstate = openspcoopstate;
  970.     }




  975.     /**
  976.      * Restituisce il nome della colonna associata al nodo con identificativo <var>nomeNodo</var>.
  977.      *
  978.      * @param idNodo Identificatore del nodo.
  979.      * 
  980.      */
  981.     private String getColonnaSQL(String idNodo) throws SQLException{
  982.         if(idNodo.startsWith(RicezioneContenutiApplicativi.ID_MODULO))
  983.             return "MOD_RICEZ_CONT_APPLICATIVI";
  984.         else if(ConsegnaContenutiApplicativi.ID_MODULO.equals(idNodo))
  985.             return "MOD_CONSEGNA_CONT_APPLICATIVI";
  986.         else if(idNodo.startsWith(RicezioneBuste.ID_MODULO))
  987.             return "MOD_RICEZ_BUSTE";
  988.         else if(InoltroBuste.ID_MODULO.equals(idNodo))
  989.             return "MOD_INOLTRO_BUSTE";
  990.         else if(InoltroRisposte.ID_MODULO.equals(idNodo))
  991.             return "MOD_INOLTRO_RISPOSTE";
  992.         else if(Imbustamento.ID_MODULO.equals(idNodo))
  993.             return "MOD_IMBUSTAMENTO";
  994.         else if(ImbustamentoRisposte.ID_MODULO.equals(idNodo))
  995.             return "MOD_IMBUSTAMENTO_RISPOSTE";
  996.         else if(Sbustamento.ID_MODULO.equals(idNodo))
  997.             return "MOD_SBUSTAMENTO";
  998.         else if(SbustamentoRisposte.ID_MODULO.equals(idNodo))
  999.             return "MOD_SBUSTAMENTO_RISPOSTE";
  1000.         else
  1001.             throw new SQLException("Traduzione IDModulo->ColonnaSQL per modulo ["+idNodo+"] non possibile");
  1002.     }





















  1024.     /* ********  C R E A Z I O N E  ******** */
  1025.     /**
  1026.      * Crea lo stato di un messaggio gestito da OpenSPCoop, salvandolo anche su fileSystem/DB. 
  1027.      *
  1028.      * @param message Messaggio.
  1029.      * 
  1030.      */
  1031.     public void registraMessaggio(OpenSPCoop2Message message,String correlazioneApplicativaRichiesta) throws GestoreMessaggiException{
  1032.         registraMessaggio(message,null, false,correlazioneApplicativaRichiesta,null);
  1033.     }
  1034.     public void registraMessaggio(OpenSPCoop2Message message,String correlazioneApplicativaRichiesta,String correlazioneApplicativaRisposta) throws GestoreMessaggiException{
  1035.         registraMessaggio(message,null, false,correlazioneApplicativaRichiesta,correlazioneApplicativaRisposta);
  1036.     }

  1038.     public void registraMessaggio(OpenSPCoop2Message message,Date oraRegistrazione,String correlazioneApplicativaRichiesta) throws GestoreMessaggiException{
  1039.         registraMessaggio(message,oraRegistrazione, false,correlazioneApplicativaRichiesta,null);
  1040.     }
  1041.     public void registraMessaggio(OpenSPCoop2Message message,Date oraRegistrazione,String correlazioneApplicativaRichiesta,String correlazioneApplicativaRisposta) throws GestoreMessaggiException{
  1042.         registraMessaggio(message,oraRegistrazione, false,correlazioneApplicativaRichiesta,correlazioneApplicativaRisposta);
  1043.     }

  1045.     /**
  1046.      * Crea lo stato di un messaggio gestito da OpenSPCoop, salvandolo anche su fileSystem/DB. 
  1047.      *
  1048.      * @param message Messaggio.
  1049.      * 
  1050.      */
  1051.     public void registraMessaggio(OpenSPCoop2Message message, Date oraRegistrazione, boolean salvaNelloStateless,
  1052.             String correlazioneApplicativaRichiesta) throws GestoreMessaggiException {
  1053.         registraMessaggio(message,oraRegistrazione,salvaNelloStateless,correlazioneApplicativaRichiesta,null);
  1054.     }
  1055.     public void registraMessaggio(OpenSPCoop2Message message, Date oraRegistrazione, boolean salvaNelloStateless,
  1056.             String correlazioneApplicativaRichiesta,String correlazioneApplicativaRisposta) throws GestoreMessaggiException {

  1058.         // OraRegistrazione
  1059.         java.sql.Timestamp oraRegistrazioneT = null;
  1060.         if (oraRegistrazione == null) {
  1061.             oraRegistrazioneT = DateManager.getTimestamp();
  1062.         } else {
  1063.             oraRegistrazioneT = new java.sql.Timestamp(oraRegistrazione.getTime());
  1064.         }

  1066.         // Gestione stateless 
  1067.         boolean gestisciInfoGenericheDB = true;
  1068.         if( this.openspcoopstate instanceof OpenSPCoopStateless ){

  1070.             if (this.isRichiesta) 
  1071.                 ((OpenSPCoopStateless)this.openspcoopstate).getTempiAttraversamentoPDD().setRicezioneMsgIngresso(oraRegistrazioneT);
  1072.             else 
  1073.                 ((OpenSPCoopStateless)this.openspcoopstate).getTempiAttraversamentoPDD().setRicezioneMsgRisposta(oraRegistrazioneT);

  1075.             ((OpenSPCoopStateless)this.openspcoopstate).setIDCorrelazioneApplicativa(correlazioneApplicativaRichiesta);
  1076.             ((OpenSPCoopStateless)this.openspcoopstate).setIDCorrelazioneApplicativaRisposta(correlazioneApplicativaRisposta);
  1077.             ((OpenSPCoopStateless)this.openspcoopstate).setPddContext(this.pddContext);

  1079.             if(!this.isRichiesta){
  1080.                 ((OpenSPCoopStateless)this.openspcoopstate).setRispostaMsg(message);
  1081.                 return;
  1082.             }else{
  1083.                 if( (this.oneWayVersione11==false) || this.routingStateless){
  1084.                     gestisciInfoGenericheDB = false;
  1085.                 }
  1086.             }
  1087.         }

  1089.         // stato
  1090.         StateMessage stato = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  1092.         // Gestione info DB
  1093.         if(gestisciInfoGenericheDB){


  1096.             Connection connectionDB = stato.getConnectionDB();  

  1098.             /* ----- Registrazione in contesto OpenSPCoop ------- */
  1099.             PreparedStatement pstmt = null;
  1100.             try {

  1102.                 // PdDContext
  1103.                 StringBuilder fieldNamesPdDContext = new StringBuilder();
  1104.                 StringBuilder fieldValuesPdDContext = new StringBuilder();
  1105.                 Map<String, String> contextSerializerParameters = null;
  1106.                 List<Object> objectSerializer = new ArrayList<>();
  1107.                 if(GestoreMessaggi.pddContextSerializer!=null){
  1108.                     contextSerializerParameters = GestoreMessaggi.pddContextSerializer.getGestoreMessaggiKeywords();
  1109.                     if(contextSerializerParameters!=null && contextSerializerParameters.size()>0){
  1110.                         for (String keyword : contextSerializerParameters.keySet()) {

  1112.                             MapKey<String> mapKey = org.openspcoop2.utils.Map.newMapKey(keyword);
  1113.                             Object o = this.pddContext.getObject(mapKey);
  1114.                             if(o==null){
  1115.                                 continue; // un oggetto puo' essere opzionale in un context
  1116.                             }

  1118.                             fieldNamesPdDContext.append(" , ");
  1119.                             fieldValuesPdDContext.append(" , ");
  1120.                             fieldNamesPdDContext.append(contextSerializerParameters.get(keyword));
  1121.                             fieldValuesPdDContext.append("?");

  1123.                             if( !(o instanceof String) && !(o instanceof Long) && !(o instanceof Timestamp)){
  1124.                                 throw new Exception("Oggetto con chiave ["+keyword+"] e' di tipo ["+o.getClass().getName()+"], e' possibile serializzare solo i tipi java.lang.String/java.lang.Long/java.sql.Timestamp");
  1125.                             }
  1126.                             objectSerializer.add(o);
  1127.                         }
  1128.                     }
  1129.                 }


  1132.                 StringBuilder query = new StringBuilder();
  1133.                 query.append("INSERT INTO ");

  1135.                 query.append(GestoreMessaggi.MESSAGGI);
  1136.                 query.append("(ID_MESSAGGIO,TIPO,ORA_REGISTRAZIONE,RISPEDIZIONE, REDELIVERY_DELAY, CLUSTER_ID, CORRELAZIONE_APPLICATIVA, CORRELAZIONE_RISPOSTA, PROTOCOLLO, id_transazione"+fieldNamesPdDContext.toString()
  1137.                         +") VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ?"+fieldValuesPdDContext.toString()+")");
  1138.                 //this.log.debug("[registraMessaggio] Aggiorno MSG["+this.tipo+"/"+this.idBusta+"] ORA_REGISTRAZIONE["+oraRegistrazioneT.toString()+"] e RISPEDIZIONE["+oraRegistrazioneT.toString()+"]");


  1141.                 pstmt = connectionDB.prepareStatement(query.toString());
  1142.                 int index = 1;
  1143.                 pstmt.setString(index++, this.idBusta);
  1144.                 pstmt.setString(index++, this.tipo);
  1145.                 pstmt.setTimestamp(index++, oraRegistrazioneT);
  1146.                 pstmt.setTimestamp(index++, oraRegistrazioneT);
  1147.                 pstmt.setTimestamp(index++, oraRegistrazioneT);
  1148.                 pstmt.setString(index++, GestoreMessaggi.cluster_id);
  1149.                 pstmt.setString(index++, correlazioneApplicativaRichiesta);
  1150.                 pstmt.setString(index++, correlazioneApplicativaRisposta);
  1151.                 pstmt.setString(index++, this.protocolFactory.getProtocol());
  1152.                 pstmt.setString(index++, this.idTransazione);
  1153.                 for (int i = 0; i < objectSerializer.size(); i++) {
  1154.                     Object o = objectSerializer.get(i);
  1155.                     if(o instanceof String){
  1156.                         pstmt.setString(index++, o.toString());
  1157.                     } else if(o instanceof Long){
  1158.                         pstmt.setLong(index++, (Long)o);
  1159.                     } else if(o instanceof Timestamp){
  1160.                         pstmt.setTimestamp(index++, (Timestamp)o);
  1161.                     }
  1162.                 }

  1164.                 // Add PreparedStatement: 
  1165.                 stato.getPreparedStatement().put("INSERT (MSG_OP_STEP1) registraMessaggioOpenSPCoop " + this.tipo + "/" + this.idBusta, pstmt);

  1167.                 // Add Messaggio into table
  1168.                 this.addMessaggioIntoTable(this.tipo, this.idBusta);

  1170.             } catch (Exception e) {
  1171.                 String errorMsg = "GESTORE_MESSAGGI, Errore di registrazione " + this.tipo + "/" + this.idBusta + ": " + e.getMessage();
  1172.                 this.log.error(errorMsg, e);
  1173.                 try {
  1174.                     if (pstmt != null) {
  1175.                         pstmt.close();
  1176.                     }
  1177.                 } catch (Exception er) {
  1178.                 }
  1179.                 throw new GestoreMessaggiException(errorMsg, e);
  1180.             }
  1181.         }

  1183.         //  Salvo contenuto messaggio 
  1184.         if (message != null) {

  1186.             SavedMessage msgSoap = null;
  1187.             try {
  1188.                 msgSoap = new SavedMessage(this.idBusta, this.openspcoopstate, this.tipo, this.workDir, GestoreMessaggi.adapter, this.log);
  1189.                 boolean consume = true;
  1190.                 msgSoap.save(message, this.isRichiesta, salvaNelloStateless, consume, oraRegistrazioneT);
  1191.             } catch (Exception e) {
  1192.                 String errorMsg = "GESTORE_MESSAGGI, Errore di registrazione (SoapMessage) " + this.tipo + "/" + this.idBusta + ": " + e.getMessage();
  1193.                 if (msgSoap != null) {
  1194.                     stato.closePreparedStatement(); // Chiude le PreparedStatement aperte(e non eseguite) per il salvataggio del Msg
  1195.                 }
  1196.                 this.log.error(errorMsg, e);
  1197.                 throw new GestoreMessaggiException(errorMsg, e);
  1198.             }
  1199.         }
  1200.     }

  1202.     public java.sql.Timestamp registraInformazioniMessaggio_statelessEngine(Date oraRegistrazione,String proprietarioMessaggio,
  1203.             String correlazioneApplicativaRichiesta) throws GestoreMessaggiException {
  1204.         return this.registraInformazioniMessaggio_statelessEngine(oraRegistrazione, proprietarioMessaggio, null,correlazioneApplicativaRichiesta,null);
  1205.     }
  1206.     public java.sql.Timestamp registraInformazioniMessaggio_statelessEngine(Date oraRegistrazione,String proprietarioMessaggio,String riferimentoMessaggio,
  1207.             String correlazioneApplicativaRichiesta,String correlazioneApplicativaRisposta) throws GestoreMessaggiException {

  1209.         // OraRegistrazione
  1210.         java.sql.Timestamp oraRegistrazioneT = null;
  1211.         if (oraRegistrazione == null) {
  1212.             oraRegistrazioneT = DateManager.getTimestamp();
  1213.         } else {
  1214.             oraRegistrazioneT = new java.sql.Timestamp(oraRegistrazione.getTime());
  1215.         }

  1217.         // stato
  1218.         StateMessage stato = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  1220.         // Gestione info DB
  1221.         Connection connectionDB = stato.getConnectionDB();  

  1223.         /* ----- Registrazione in contesto OpenSPCoop ------- */
  1224.         PreparedStatement pstmt = null;
  1225.         try {

  1227.             // PdDContext
  1228.             StringBuilder fieldNamesPdDContext = new StringBuilder();
  1229.             StringBuilder fieldValuesPdDContext = new StringBuilder();
  1230.             Map<String, String> contextSerializerParameters = null;
  1231.             List<Object> objectSerializer = new ArrayList<>();
  1232.             if(GestoreMessaggi.pddContextSerializer!=null){
  1233.                 contextSerializerParameters = GestoreMessaggi.pddContextSerializer.getGestoreMessaggiKeywords();
  1234.                 if(contextSerializerParameters!=null && contextSerializerParameters.size()>0){
  1235.                     for (String keyword : contextSerializerParameters.keySet()) {

  1237.                         MapKey<String> mapKey = org.openspcoop2.utils.Map.newMapKey(keyword);
  1238.                         Object o = this.pddContext.getObject(mapKey);
  1239.                         if(o==null){
  1240.                             continue; // un oggetto puo' essere opzionale in un context
  1241.                         }

  1243.                         fieldNamesPdDContext.append(" , ");
  1244.                         fieldValuesPdDContext.append(" , ");
  1245.                         fieldNamesPdDContext.append(contextSerializerParameters.get(keyword));
  1246.                         fieldValuesPdDContext.append("?");

  1248.                         if( !(o instanceof String) && !(o instanceof Long) && !(o instanceof Timestamp)){
  1249.                             throw new Exception("Oggetto con chiave ["+keyword+"] e' di tipo ["+o.getClass().getName()+"], e' possibile serializzare solo i tipi java.lang.String/java.lang.Long/java.sql.Timestamp");
  1250.                         }
  1251.                         objectSerializer.add(o);
  1252.                     }
  1253.                 }
  1254.             }


  1257.             StringBuilder query = new StringBuilder();
  1258.             query.append("INSERT INTO ");

  1260.             query.append(GestoreMessaggi.MESSAGGI);
  1261.             query.append("(ID_MESSAGGIO,TIPO,ORA_REGISTRAZIONE,RISPEDIZIONE, REDELIVERY_DELAY, CLUSTER_ID, PROPRIETARIO, CORRELAZIONE_APPLICATIVA, CORRELAZIONE_RISPOSTA, PROTOCOLLO, id_transazione ");
  1262.             if(riferimentoMessaggio!=null)
  1263.                 query.append(", RIFERIMENTO_MSG");
  1264.             query.append(fieldNamesPdDContext.toString());
  1265.             query.append(") VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? ");
  1266.             if(riferimentoMessaggio!=null)
  1267.                 query.append(", ?");
  1268.             query.append(fieldValuesPdDContext);
  1269.             query.append(" )");

  1271.             //this.log.debug("[registraMessaggio] Aggiorno MSG["+this.tipo+"/"+this.idBusta+"] ORA_REGISTRAZIONE["+oraRegistrazioneT.toString()+"] e RISPEDIZIONE["+oraRegistrazioneT.toString()+"]");


  1274.             pstmt = connectionDB.prepareStatement(query.toString());
  1275.             int index = 1;
  1276.             pstmt.setString(index++, this.idBusta);
  1277.             pstmt.setString(index++, this.tipo);
  1278.             pstmt.setTimestamp(index++, oraRegistrazioneT);
  1279.             pstmt.setTimestamp(index++, oraRegistrazioneT);
  1280.             pstmt.setTimestamp(index++, oraRegistrazioneT);
  1281.             pstmt.setString(index++, GestoreMessaggi.cluster_id);
  1282.             pstmt.setString(index++, proprietarioMessaggio);
  1283.             pstmt.setString(index++, correlazioneApplicativaRichiesta);
  1284.             pstmt.setString(index++, correlazioneApplicativaRisposta);
  1285.             pstmt.setString(index++, this.protocolFactory.getProtocol());
  1286.             pstmt.setString(index++, this.idTransazione);
  1287.             if(riferimentoMessaggio!=null){
  1288.                 pstmt.setString(index++,riferimentoMessaggio);
  1289.             }
  1290.             for (int i = 0; i < objectSerializer.size(); i++) {
  1291.                 Object o = objectSerializer.get(i);
  1292.                 if(o instanceof String){
  1293.                     pstmt.setString(index++, o.toString());
  1294.                 } else if(o instanceof Long){
  1295.                     pstmt.setLong(index++, (Long)o);
  1296.                 } else if(o instanceof Timestamp){
  1297.                     pstmt.setTimestamp(index++, (Timestamp)o);
  1298.                 }
  1299.             }

  1301.             // Add PreparedStatement: 
  1302.             stato.getPreparedStatement().put("INSERT (MSG_OP_STEP1) registraMessaggioOpenSPCoop(stateless engine) " + this.tipo + "/" + this.idBusta, pstmt);

  1304.             // Add Messaggio into table
  1305.             this.addMessaggioIntoTable(this.tipo, this.idBusta);

  1307.         } catch (Exception e) {
  1308.             String errorMsg = "GESTORE_MESSAGGI, Errore di registrazione (stateless engine) " + this.tipo + "/" + this.idBusta + ": " + e.getMessage();
  1309.             this.log.error(errorMsg, e);
  1310.             try {
  1311.                 if (pstmt != null) {
  1312.                     pstmt.close();
  1313.                 }
  1314.             } catch (Exception er) {
  1315.             }
  1316.             throw new GestoreMessaggiException(errorMsg, e);
  1317.         }

  1319.         return oraRegistrazioneT;
  1320.     }

  1322.     public void registraMessaggio_statelessEngine(OpenSPCoop2Message message, boolean consumeMessage, java.sql.Timestamp oraRegistrazioneT) throws GestoreMessaggiException {
  1323.         // Salvo contenuto messaggio 
  1324.         if (message != null) {

  1326.             // stato
  1327.             StateMessage stato = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;


  1330.             SavedMessage msgSoap = null;
  1331.             try {
  1332.                 msgSoap = new SavedMessage(this.idBusta, this.openspcoopstate, this.tipo, this.workDir, GestoreMessaggi.adapter, this.log);
  1333.                 msgSoap.save(message, this.isRichiesta, false, consumeMessage, oraRegistrazioneT);
  1334.             } catch (Exception e) {
  1335.                 String errorMsg = "GESTORE_MESSAGGI, Errore di registrazione (SoapMessage) " + this.tipo + "/" + this.idBusta + ": " + e.getMessage();
  1336.                 if (msgSoap != null) {
  1337.                     stato.closePreparedStatement(); // Chiude le PreparedStatement aperte(e non eseguite) per il salvataggio del Msg
  1338.                 }
  1339.                 this.log.error(errorMsg, e);
  1340.                 throw new GestoreMessaggiException(errorMsg, e);
  1341.             }
  1342.         }
  1343.     }
  1344.     
  1345.     public void registraRisposta_statelessEngine(String identificativo, OpenSPCoop2Message message, boolean consumeMessage) throws GestoreMessaggiException {
  1346.         // Salvo contenuto messaggio 
  1347.         if (message != null) {

  1349.             String id = identificativo!=null ? identificativo : this.idBusta;
  1350.             
  1351.             // stato
  1352.             StateMessage stato = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;


  1355.             SavedMessage msgSoap = null;
  1356.             try {
  1357.                 msgSoap = new SavedMessage(id, this.openspcoopstate, this.tipo, this.workDir, GestoreMessaggi.adapter, this.log);
  1358.                 msgSoap.updateResponse(message, consumeMessage);
  1359.             } catch (Exception e) {
  1360.                 String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento (SoapMessage) " + this.tipo + "/" + id + ": " + e.getMessage();
  1361.                 if (msgSoap != null) {
  1362.                     stato.closePreparedStatement(); // Chiude le PreparedStatement aperte(e non eseguite) per il salvataggio del Msg
  1363.                 }
  1364.                 this.log.error(errorMsg, e);
  1365.                 throw new GestoreMessaggiException(errorMsg, e);
  1366.             }
  1367.         }
  1368.     }
  1369.     
  1370.     public void registraTransactionContext_statelessEngine(String identificativo, Context context) throws GestoreMessaggiException {
  1371.         // Salvo contenuto messaggio 
  1372.         if (context != null) {

  1374.             String id = identificativo!=null ? identificativo : this.idBusta;
  1375.             
  1376.             // stato
  1377.             StateMessage stato = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;


  1380.             SavedMessage msgSoap = null;
  1381.             try {
  1382.                 msgSoap = new SavedMessage(id, this.openspcoopstate, this.tipo, this.workDir, GestoreMessaggi.adapter, this.log);
  1383.                 msgSoap.updateTransactionContext(context);
  1384.             } catch (Exception e) {
  1385.                 String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento (TransactionContext) " + this.tipo + "/" + id + ": " + e.getMessage();
  1386.                 if (msgSoap != null) {
  1387.                     stato.closePreparedStatement(); // Chiude le PreparedStatement aperte(e non eseguite) per il salvataggio del Msg
  1388.                 }
  1389.                 this.log.error(errorMsg, e);
  1390.                 throw new GestoreMessaggiException(errorMsg, e);
  1391.             }
  1392.         }
  1393.     }

  1395.     /**
  1396.      * Registra un destinatario (servizio applicativo) il quale dovra' ricevere un messaggio gestito da OpenSPCoop. 
  1397.      *
  1398.      * @param serv Servizio Applicativo da registrare come destinatario del messaggio
  1399.      * @param sbustamentoSOAP Indicazione se al servizio applicativo deve essere ritornato un messaggio sbustato
  1400.      * @param integrationManager Indiciazione se il servizio applicativo e' autorizzato a ricevere il contenuto anche attraverso il servizio integrationManager
  1401.      * @param tipoConsegna Assume il valore 'Connettore' se la consegna avviente tramite un connettore, 'ConnectionReply' se viene ritornato tramite connectionReply, 'IntegrationManager' se e' solo ottenibile tramite IntegrationManager
  1402.      * 
  1403.      */
  1404.     public void registraDestinatarioMessaggio(String serv, 
  1405.             boolean sbustamentoSOAP,boolean sbustamentoInfoProtocol,
  1406.             boolean integrationManager,String tipoConsegna,Timestamp oraRegistrazioneMessaggio,
  1407.             String nomePorta, boolean attesaEsito, boolean impostaPerConsegnaTimerContenutiApplicativi,
  1408.             String coda, String priorita, boolean schedulingNonAttivo)throws GestoreMessaggiException{
  1409.         if(this.openspcoopstate instanceof OpenSPCoopStateful || this.oneWayVersione11) {
  1410.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1411.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  1413.             Connection connectionDB = stateMSG.getConnectionDB();
  1414.             PreparedStatement pstmt = null;
  1415.             try{    

  1417.                 // Costruzione Query
  1418.                 StringBuilder query = new StringBuilder();
  1419.                 query.append("INSERT INTO ");
  1420.                 query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  1421.                 String columnCoda = "";
  1422.                 String valueCoda = "";
  1423.                 String columnPriorita = "";
  1424.                 String valuePriorita = "";
  1425.                 String columnErroreProcessamento = "";
  1426.                 String valueErroreProcessamento = "";
  1427.                 String columnLockConsegna = "";
  1428.                 String valueLockConsegna = "";
  1429.                 if(coda!=null) {
  1430.                     columnCoda=",CODA";
  1431.                     valueCoda=", ?";
  1432.                 }
  1433.                 if(priorita!=null) {
  1434.                     columnPriorita=",PRIORITA";
  1435.                     valuePriorita=", ?";
  1436.                 }
  1437.                 if(impostaPerConsegnaTimerContenutiApplicativi) {
  1438.                     columnErroreProcessamento = ",ERRORE_PROCESSAMENTO,ERRORE_PROCESSAMENTO_COMPACT";
  1439.                     valueErroreProcessamento = ", ? , ?";
  1440.                 }
  1441.                 if(schedulingNonAttivo) {
  1442.                     columnLockConsegna=",LOCK_CONSEGNA";
  1443.                     valueLockConsegna=", ?";
  1444.                 }
  1445.                 query.append("(ID_MESSAGGIO,SERVIZIO_APPLICATIVO,SBUSTAMENTO_SOAP,SBUSTAMENTO_INFO_PROTOCOL,INTEGRATION_MANAGER,TIPO_CONSEGNA,ORA_REGISTRAZIONE,RISPEDIZIONE,NOME_PORTA,ATTESA_ESITO"+
  1446.                             columnCoda+
  1447.                             columnPriorita+
  1448.                             columnErroreProcessamento+
  1449.                             columnLockConsegna+
  1450.                         ") VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ?"+
  1451.                             valueCoda+
  1452.                             valuePriorita+
  1453.                             valueErroreProcessamento+
  1454.                             valueLockConsegna+
  1455.                             ")");

  1457.                 pstmt = connectionDB.prepareStatement(query.toString());
  1458.                 int index = 1;
  1459.                 pstmt.setString(index++,this.idBusta);
  1460.                 pstmt.setString(index++,serv);
  1461.                 if(sbustamentoSOAP)
  1462.                     pstmt.setInt(index++,CostantiDB.TRUE);
  1463.                 else
  1464.                     pstmt.setInt(index++,CostantiDB.FALSE);
  1465.                 if(sbustamentoInfoProtocol)
  1466.                     pstmt.setInt(index++,CostantiDB.TRUE);
  1467.                 else
  1468.                     pstmt.setInt(index++,CostantiDB.FALSE);
  1469.                 if(integrationManager)
  1470.                     pstmt.setInt(index++,CostantiDB.TRUE);
  1471.                 else
  1472.                     pstmt.setInt(index++,CostantiDB.FALSE);
  1473.                 pstmt.setString(index++,tipoConsegna);

  1475.                 pstmt.setTimestamp(index++,oraRegistrazioneMessaggio);

  1477.                 pstmt.setTimestamp(index++,oraRegistrazioneMessaggio); // rispedizione, verra aggiornata
  1478.                 
  1479.                 pstmt.setString(index++,nomePorta);
  1480.                 
  1481.                 if(attesaEsito)
  1482.                     pstmt.setInt(index++,CostantiDB.TRUE);
  1483.                 else
  1484.                     pstmt.setInt(index++,CostantiDB.FALSE);
  1485.                 
  1486.                 if(coda!=null) {
  1487.                     pstmt.setString(index++, coda);
  1488.                 }
  1489.                 if(priorita!=null) {
  1490.                     pstmt.setString(index++, priorita);
  1491.                 }
  1492.                 
  1493.                 if(impostaPerConsegnaTimerContenutiApplicativi) {
  1494.                     pstmt.setString(index++, TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  1495.                     pstmt.setString(index++, TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  1496.                 }
  1497.                 
  1498.                 if(schedulingNonAttivo) {
  1499.                     pstmt.setTimestamp(index++, TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA);
  1500.                 }

  1502.                 //this.log.debug("[registraDestinatarioMessaggio] Aggiorno MSG["+this.tipo+"/"+this.idBusta+"] RISPEDIZIONE["+oraRegistrazioneMessaggio.toString()+"]");

  1504.                 // Add PreparedStatement 
  1505.                 stateMSG.getPreparedStatement().put("INSERT (MSG_OP_STEP2) registraDestinatarioMessaggioOpenSPCoop["+serv+"]["+this.idBusta+"]",pstmt);

  1507.             } catch(Exception e) {
  1508.                 String errorMsg = "GESTORE_MESSAGGI, Errore di registrazione destinatario Messaggio "+this.tipo+"/"+this.idBusta+": "+e.getMessage();       
  1509.                 try{
  1510.                     if(pstmt != null)
  1511.                         pstmt.close();
  1512.                 } catch(Exception er) {
  1513.                     // close
  1514.                 }
  1515.                 this.log.error(errorMsg,e);
  1516.                 throw new GestoreMessaggiException(errorMsg,e);
  1517.             }
  1518.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless && !this.oneWayVersione11){
  1519.             //NOP
  1520.         }else{
  1521.             throw new GestoreMessaggiException("Metodo invocato con IState non valido"); //CAMBIARE FIRMA PER TRATTARE ECCEZIONE?
  1522.         }
  1523.     }








  1532.     /* ********  A G G I O R N A M E N T I  ******** */



  1536.     /**
  1537.      * Aggiorna lo stato di un messaggio gestito da OpenSPCoop, configurando il nodo dell'infrastruttura autorizzato a processarlo. 
  1538.      *
  1539.      * @param nodoOpenSPCoop  Nodo OpenSPCoop autorizzato a processare il messaggio
  1540.      * 
  1541.      */
  1542.     public void aggiornaProprietarioMessaggio(String nodoOpenSPCoop)throws GestoreMessaggiException{
  1543.         this.aggiornaProprietarioMessaggio_engine(nodoOpenSPCoop, false, false);
  1544.     }

  1546.     /**
  1547.      * Aggiorna lo stato di un messaggio gestito da OpenSPCoop, configurando il nodo dell'infrastruttura autorizzato a processarlo. 
  1548.      *
  1549.      * @param nodoOpenSPCoop  Nodo OpenSPCoop autorizzato a processare il messaggio
  1550.      * 
  1551.      */
  1552.     public void aggiornaProprietarioMessaggio(String nodoOpenSPCoop,boolean searchForRiferimentoMsg)throws GestoreMessaggiException{
  1553.         this.aggiornaProprietarioMessaggio_engine(nodoOpenSPCoop, searchForRiferimentoMsg,false);
  1554.     }


  1557.     /**
  1558.      * Aggiorna lo stato di un messaggio gestito da OpenSPCoop, configurando il nodo dell'infrastruttura autorizzato a processarlo. 
  1559.      *
  1560.      * @param nodoOpenSPCoop  Nodo OpenSPCoop autorizzato a processare il messaggio
  1561.      * 
  1562.      */
  1563.     private boolean deleted = false;
  1564.     private void aggiornaProprietarioMessaggio_engine(String nodoOpenSPCoop,boolean searchForRiferimentoMsg,boolean executePreparedStatement)throws GestoreMessaggiException{

  1566.         if(this.deleted){
  1567.             return; // gia' marcato per eliminazione
  1568.         }

  1570.         boolean stateful = this.openspcoopstate instanceof OpenSPCoopStateful;

  1572.         if(!stateful){
  1573.             if (this.isRichiesta) ((OpenSPCoopStateless)this.openspcoopstate).setDestinatarioRequestMsgLib(nodoOpenSPCoop);
  1574.             else ((OpenSPCoopStateless)this.openspcoopstate).setDestinatarioResponseMsgLib(nodoOpenSPCoop);
  1575.         }

  1577.         if( stateful || this.readyForDrop || this.oneWayVersione11) {
  1578.             StateMessage stateMsg = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1579.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  1581.             Connection connectionDB = stateMsg.getConnectionDB();

  1583.             PreparedStatement pstmt = null;
  1584.             try{    

  1586.                 // Costruzione Query
  1587.                 StringBuilder query = new StringBuilder();
  1588.                 query.append("UPDATE ");
  1589.                 query.append(GestoreMessaggi.MESSAGGI);
  1590.                 query.append(" SET PROPRIETARIO=? WHERE ");
  1591.                 // Se devo aggiornare per riferimento, devo invertire il tipo del messaggio, e devo cercare i messaggi che possiedono l'id come riferimento
  1592.                 String tipoMessaggio = null;
  1593.                 if(searchForRiferimentoMsg){
  1594.                     if(Costanti.OUTBOX.equals(this.tipo)){
  1595.                         tipoMessaggio = Costanti.INBOX;
  1596.                     }else{
  1597.                         tipoMessaggio = Costanti.OUTBOX;
  1598.                     }
  1599.                     query.append(" RIFERIMENTO_MSG=? AND TIPO=? ");
  1600.                 }else{
  1601.                     tipoMessaggio = this.tipo;
  1602.                     query.append(" ID_MESSAGGIO=? AND TIPO=? ");
  1603.                 }
  1604.                 pstmt = connectionDB.prepareStatement(query.toString());
  1605.                 pstmt.setString(1,nodoOpenSPCoop);
  1606.                 pstmt.setString(2,this.idBusta);
  1607.                 pstmt.setString(3,tipoMessaggio);

  1609.                 // Add PreparedStatement
  1610.                 if(executePreparedStatement){
  1611.                     pstmt.executeUpdate();
  1612.                     pstmt.close();
  1613.                 }
  1614.                 else{
  1615.                     //System.out.println("UPDATE ["+query.toString()+"] 1["+nodoOpenSPCoop+"] 2["+this.idBusta+"] 3["+tipoMessaggio+"]");
  1616.                     stateMsg.getPreparedStatement().put("UPDATE aggiornaProprietarioMessaggioOpenSPCoop "+this.tipo+"/"+this.idBusta,pstmt);
  1617.                 }

  1619.                 // Add Proprietario into table
  1620.                 this.addProprietarioIntoTable(this.tipo, this.idBusta, nodoOpenSPCoop);

  1622.             } catch(Exception e) {
  1623.                 String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento proprietario Messaggio "+this.tipo+"/"+this.idBusta+": "+e.getMessage();       
  1624.                 try{
  1625.                     if(pstmt != null)
  1626.                         pstmt.close();
  1627.                 } catch(Exception er) {
  1628.                     // close
  1629.                 }
  1630.                 this.log.error(errorMsg,e);
  1631.                 throw new GestoreMessaggiException(errorMsg,e);
  1632.             }
  1633.         }

  1635.         if(TimerGestoreMessaggi.ID_MODULO.equals(nodoOpenSPCoop)){
  1636.             this.deleted = true;
  1637.         }
  1638.     }

  1640.     /**
  1641.      * Aggiorna lo stato di un messaggio gestito da OpenSPCoop, configurando l'ID del campo riferimento messaggio di una busta gestita
  1642.      *
  1643.      * @param riferimentoMessaggio Riferimento Messaggio di una busta gestita
  1644.      * 
  1645.      */
  1646.     public void aggiornaRiferimentoMessaggio(String riferimentoMessaggio)throws GestoreMessaggiException{
  1647.         this.aggiornaRiferimentoMessaggio(riferimentoMessaggio, false);
  1648.     }
  1649.     public void aggiornaRiferimentoMessaggio(String riferimentoMessaggio,boolean saveIntoDB)throws GestoreMessaggiException{

  1651.         if((this.openspcoopstate instanceof OpenSPCoopStateful) || saveIntoDB) {
  1652.             StateMessage state = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1653.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  1655.             Connection connectionDB = state.getConnectionDB();

  1657.             PreparedStatement pstmt = null;
  1658.             try{    

  1660.                 // Costruzione Query
  1661.                 StringBuilder query = new StringBuilder();
  1662.                 query.append("UPDATE ");
  1663.                 query.append(GestoreMessaggi.MESSAGGI);
  1664.                 query.append(" SET RIFERIMENTO_MSG=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1665.                 pstmt = connectionDB.prepareStatement(query.toString());
  1666.                 pstmt.setString(1,riferimentoMessaggio);
  1667.                 pstmt.setString(2,this.idBusta);
  1668.                 pstmt.setString(3,this.tipo);

  1670.                 // Add PreparedStatement
  1671.                 state.getPreparedStatement().put("UPDATE aggiornaRiferimentoMessaggioOpenSPCoop "+this.tipo+"/"+this.idBusta,pstmt);

  1673.                 // add in cache
  1674.                 if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){
  1675.                     try{
  1676.                         this.msgDiag.highDebug("Aggiornamento riferimentoMessaggio per ["+this.tipo+"/"+riferimentoMessaggio+"] a ["+this.idBusta+"] ...");
  1677.                         GestoreMessaggi.addIntoCache_MappingRifMsgToId(this.msgDiag,this.tipo,riferimentoMessaggio,this.idBusta);
  1678.                         this.msgDiag.highDebug("Aggiornamento riferimentoMessaggio per ["+this.tipo+"/"+riferimentoMessaggio+"] a ["+this.idBusta+"] effettuata.");
  1679.                     }catch(Exception e){
  1680.                         this.msgDiag.logErroreGenerico(e,"GestoreMessaggi.addIntoCache_MappingRifMsgToId(Per:"+this.tipo+"/"+riferimentoMessaggio+",Value:"+this.idBusta+"");
  1681.                     }
  1682.                 }

  1684.             } catch(Exception e) {
  1685.                 String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento riferimento messaggio "+this.tipo+"/"+this.idBusta+": "+e.getMessage();        
  1686.                 try{
  1687.                     if(pstmt != null)
  1688.                         pstmt.close();
  1689.                 } catch(Exception er) {
  1690.                     // close
  1691.                 }
  1692.                 this.log.error(errorMsg,e);
  1693.                 throw new GestoreMessaggiException(errorMsg,e);
  1694.             }
  1695.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  1696.             // NOP
  1697.         }else{
  1698.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido"); //cambiare la firma ?
  1699.         }
  1700.     }


  1703.     /**
  1704.      * Aggiorna lo stato di un messaggio gestito da OpenSPCoop, configurando il motivo di un eventuale errore verificatosi
  1705.      * durante la gestione del messaggio stesso. 
  1706.      *
  1707.      * @param motivoErrore Motivo dell'errore
  1708.      * 
  1709.      */
  1710.     public void aggiornaErroreProcessamentoMessaggio(String motivoErrore,String servizioApplicativo) throws GestoreMessaggiException{
  1711.         aggiornaErroreProcessamentoMessaggio(motivoErrore, servizioApplicativo, true);
  1712.     }
  1713.     public boolean aggiornaErroreProcessamentoMessaggio(String motivoErrore,String servizioApplicativo, boolean throwExceptionConnectionNull) throws GestoreMessaggiException{

  1715.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || this.oneWayVersione11) {
  1716.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1717.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  1718.             Connection connectionDB = stateMSG.getConnectionDB();

  1720.             if(connectionDB==null) {
  1721.                 if(throwExceptionConnectionNull) {
  1722.                     throw new GestoreMessaggiException("Connessione non disponibile");
  1723.                 }
  1724.                 else {
  1725.                     return false;
  1726.                 }
  1727.             }
  1728.             
  1729.             String motivoErroreGiaRegistrato = this.getErroreProcessamentoMessaggio(servizioApplicativo);
  1730.             String prefix = "";
  1731.             if(motivoErroreGiaRegistrato!=null &&
  1732.                 motivoErroreGiaRegistrato.startsWith(GestoreMessaggi.NUMERO_RISPEDIZIONE)){
  1733.                 int index =  motivoErroreGiaRegistrato.indexOf("]");
  1734.                 prefix = motivoErroreGiaRegistrato.substring(0,(index+2));
  1735.                 motivoErroreGiaRegistrato = motivoErroreGiaRegistrato.substring(index+2);
  1736.             }

  1738.             // aggiorno il motivo dell'errore solo se ho un errore diverso da quanto e' capitato precedentemente
  1739.             // o se non avevo ancora registrato un errore.
  1740.             if(motivoErroreGiaRegistrato==null || 
  1741.                     (motivoErroreGiaRegistrato.equals(motivoErrore)==false)){

  1743.                 PreparedStatement pstmt = null;
  1744.                 try{    

  1746.                     // Costruzione Query
  1747.                     StringBuilder query = new StringBuilder();
  1748.                     query.append("UPDATE ");
  1749.                     if(servizioApplicativo==null) {
  1750.                         query.append(GestoreMessaggi.MESSAGGI);
  1751.                         query.append(" SET ERRORE_PROCESSAMENTO=? WHERE ID_MESSAGGIO = ?");
  1752.                     }else {
  1753.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  1754.                         query.append(" SET ERRORE_PROCESSAMENTO=?, ERRORE_PROCESSAMENTO_COMPACT=? WHERE ID_MESSAGGIO = ?");
  1755.                     }
  1756.                     if(servizioApplicativo!=null)
  1757.                         query.append(" AND SERVIZIO_APPLICATIVO=?");
  1758.                     else
  1759.                         query.append(" AND TIPO=?");
  1760.                     pstmt = connectionDB.prepareStatement(query.toString());
  1761.                     int index = 1;
  1762.                     this.log.debug("UPDATE ERRORE PROCESSAMENTO TIPO-1 ["+prefix+"]["+motivoErrore+"] tipo["+this.tipo+"] sa["+servizioApplicativo+"]");
  1763.                     pstmt.setString(index++,prefix+motivoErrore);
  1764.                     if(servizioApplicativo!=null) {
  1765.                         if(motivoErrore!=null && motivoErrore.length()>=200) { // per evitare anche caratteri strani che occupano maggiore spazio
  1766.                             pstmt.setString(index++,motivoErrore.substring(0, 200)+" ...");
  1767.                         }
  1768.                         else {
  1769.                             pstmt.setString(index++,motivoErrore);
  1770.                         }
  1771.                     }
  1772.                     pstmt.setString(index++,this.idBusta);
  1773.                     if(servizioApplicativo!=null)
  1774.                         pstmt.setString(index++,servizioApplicativo);
  1775.                     else
  1776.                         pstmt.setString(index++,this.tipo);

  1778.                     pstmt.execute();
  1779.                     pstmt.close();

  1781.                 } catch(Exception e) {
  1782.                     String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento errore processamento messaggio "+this.tipo+"/"+this.idBusta+" sa["+servizioApplicativo+"]: "+e.getMessage();       
  1783.                     try{
  1784.                         if(pstmt != null)
  1785.                             pstmt.close();
  1786.                     } catch(Exception er) {
  1787.                         // close
  1788.                     }
  1789.                     this.log.error(errorMsg,e);
  1790.                     throw new GestoreMessaggiException(errorMsg,e);
  1791.                 }
  1792.             }
  1793.             
  1794.             return true;
  1795.             
  1796.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  1797.             //NOP
  1798.             return false;
  1799.         }else{
  1800.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  1801.         }
  1802.     }

  1804.     public void aggiungiMessaggioSerializzato(IJDBCAdapter adapter,byte [] msgByte) throws GestoreMessaggiException {

  1806.         StateMessage stateMsg = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1807.                 : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  1808.         Connection connectionDB = stateMsg.getConnectionDB();


  1811.         PreparedStatement pstmt = null;
  1812.         try{    

  1814.             // Costruzione Query
  1815.             StringBuilder query = new StringBuilder();
  1816.             query.append("UPDATE ");
  1817.             query.append(GestoreMessaggi.MESSAGGI);
  1818.             query.append(" SET msg_bytes=? WHERE id_messaggio= ? and tipo= ?");



  1822.             pstmt = connectionDB.prepareStatement(query.toString());
  1823.             adapter.setBinaryData(pstmt,1,msgByte);
  1824.             pstmt.setString(2,this.idBusta);
  1825.             pstmt.setString(3, this.tipo);


  1828.             // Add PreparedStatement
  1829.             stateMsg.getPreparedStatement().put("UPDATE aggiungiMessaggioSerializzatoInMessaggioOpenSPCoop "+this.tipo+"/"+this.idBusta,pstmt);
  1830.         }catch (Exception e){       
  1831.             String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento errore processamento messaggio "+this.tipo+"/"+this.idBusta+" "+e.getMessage();        
  1832.             try{
  1833.                 if(pstmt != null)
  1834.                     pstmt.close();
  1835.             } catch(Exception er) { 
  1836.                 // close
  1837.             }
  1838.             this.log.error(errorMsg,e);
  1839.             throw new GestoreMessaggiException(errorMsg,e);
  1840.         }

  1842.     }

  1844.     public void ripristinaMessaggio() throws GestoreMessaggiException {

  1846.         StateMessage stateMsg = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1847.                 : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  1848.         Connection connectionDB = stateMsg.getConnectionDB();
  1849.         PreparedStatement pstmt = null;

  1851.         String sql = "UPDATE MESSAGGI SET scheduling=0 where id_messaggio=? AND tipo=?";

  1853.         try {
  1854.             pstmt = connectionDB.prepareStatement(sql);
  1855.             pstmt.setString(1,this.idBusta);
  1856.             pstmt.setString(2,this.tipo);
  1857.             pstmt.execute();
  1858.         }catch (Exception e){       
  1859.             String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento errore processamento messaggio "+this.tipo+"/"+this.idBusta+" "+e.getMessage();        
  1860.             this.log.error(errorMsg,e);
  1861.             throw new GestoreMessaggiException(errorMsg,e);
  1862.         }finally {
  1863.             try{
  1864.                 if(pstmt != null)
  1865.                     pstmt.close();
  1866.             } catch(Exception er) { 
  1867.                 // close
  1868.             }
  1869.         }
  1870.     }









  1880.     public static final String NUMERO_RISPEDIZIONE = "[spedizione n.";

  1882.     /**
  1883.      * Aggiorna la data di rispedizione di un messaggio gestito da OpenSPCoop. 
  1884.      *
  1885.      * @param dataRispedizione Data di rispedizione
  1886.      * 
  1887.      */
  1888.     public void aggiornaDataRispedizione(java.sql.Timestamp dataRispedizione,String servizioApplicativo)throws GestoreMessaggiException{

  1890.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || this.oneWayVersione11) {
  1891.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  1892.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  1893.             Connection connectionDB = stateMSG.getConnectionDB();

  1895.             String motivoErroreGiaRegistrato = this.getErroreProcessamentoMessaggio(servizioApplicativo);

  1897.             PreparedStatement pstmt = null;
  1898.             try{    
  1899.                 boolean updateErroreProcessamento = true;
  1900.                 
  1901.                 int numeroSpedizione = 0;
  1902.                 // Costruzione numero rispedizione
  1903.                 if(motivoErroreGiaRegistrato==null){
  1904.                     motivoErroreGiaRegistrato = GestoreMessaggi.NUMERO_RISPEDIZIONE + "1] ";
  1905.                     numeroSpedizione = 1;
  1906.                 }else{
  1907.                     if( motivoErroreGiaRegistrato.startsWith(GestoreMessaggi.NUMERO_RISPEDIZIONE) == false ){
  1908.                         motivoErroreGiaRegistrato = GestoreMessaggi.NUMERO_RISPEDIZIONE + "1] "+motivoErroreGiaRegistrato;
  1909.                         numeroSpedizione = 1 ;
  1910.                     }else{
  1911.                         
  1912.                         if(this.pddContext!=null && this.pddContext.containsKey(CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_NUMERO_TENTATIVI_RICONSEGNA_UPDATED)) {
  1913.                             updateErroreProcessamento = false;
  1914.                             numeroSpedizione = (Integer) this.pddContext.getObject(CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_NUMERO_TENTATIVI_RICONSEGNA_UPDATED);
  1915.                         }
  1916.                         if(updateErroreProcessamento) {
  1917.                             int indexNumber = motivoErroreGiaRegistrato.indexOf("]");
  1918.                             if(indexNumber == -1)
  1919.                                 throw new GestoreMessaggiException("Errore processamento corrotto (] non presente)");
  1920.                             try{
  1921.                                 StringBuilder bf = new StringBuilder();
  1922.                                 int j = indexNumber - 1;
  1923.                                 while( motivoErroreGiaRegistrato.charAt(j)!='.' ){
  1924.                                     bf.append(motivoErroreGiaRegistrato.charAt(j));
  1925.                                     j = j - 1;
  1926.                                 }
  1927.                                 bf.reverse();
  1928.                                 numeroSpedizione = Integer.parseInt(bf.toString());
  1929.                                 numeroSpedizione = numeroSpedizione+1;
  1930.                                 String oldMotivo = motivoErroreGiaRegistrato.substring(indexNumber+2);
  1931.                                 motivoErroreGiaRegistrato = GestoreMessaggi.NUMERO_RISPEDIZIONE + numeroSpedizione + "] "+oldMotivo;
  1932.                             }catch(Exception e){
  1933.                                 throw new GestoreMessaggiException("Aggiornamento numero spedizione non riuscito: "+e.getMessage(),e);
  1934.                             }
  1935.                         }
  1936.                     }
  1937.                 }

  1939.                 // incremento dataSpedizione
  1940.                 long spedizione = dataRispedizione.getTime();
  1941.                 if(this.propertiesReader.isRitardoConsegnaAbilitato() && numeroSpedizione>1){
  1942.                     long ritardoEsponenziale = this.propertiesReader.getRitardoConsegnaEsponenziale();
  1943.                     long ritardo = 1;
  1944.                     boolean moltiplicazione = this.propertiesReader.isRitardoConsegnaEsponenzialeConMoltiplicazione();
  1945.                     if(moltiplicazione==false)
  1946.                         ritardo = 0;
  1947.                     long limite = (numeroSpedizione-1);
  1948.                     if(limite > this.propertiesReader.getRitardoConsegnaEsponenzialeLimite())
  1949.                         limite = this.propertiesReader.getRitardoConsegnaEsponenzialeLimite();
  1950.                     for(int i=0; i<limite; i++){
  1951.                         if(moltiplicazione){
  1952.                             ritardo = ritardo * ritardoEsponenziale;
  1953.                         }
  1954.                         else{
  1955.                             ritardo = ritardo + ritardoEsponenziale;
  1956.                         }
  1957.                     }
  1958.                     spedizione = spedizione + (ritardo*1000);
  1959.                 }


  1962.                 // Costruzione Query
  1963.                 StringBuilder query = new StringBuilder();
  1964.                 query.append("UPDATE ");
  1965.                 if(servizioApplicativo!=null)
  1966.                     query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  1967.                 else
  1968.                     query.append(GestoreMessaggi.MESSAGGI);
  1969.                 query.append(" SET RISPEDIZIONE=?");
  1970.                 if(updateErroreProcessamento) {
  1971.                     query.append(", ERRORE_PROCESSAMENTO=?");
  1972.                 }
  1973.                 query.append(" WHERE  ID_MESSAGGIO = ?"); // non devo aggiornare ERRORE_PROCESSAMENTO_COMPACT poichè li non vi è l'informazione sulla rispedizione.
  1974.                 if(servizioApplicativo!=null)
  1975.                     query.append(" AND SERVIZIO_APPLICATIVO=?");
  1976.                 else
  1977.                     query.append(" AND TIPO=?");
  1978.                 pstmt = connectionDB.prepareStatement(query.toString());
  1979.                 Timestamp t = new Timestamp(spedizione);
  1980.                 int index = 1;
  1981.                 pstmt.setTimestamp(index++,t);
  1982.                 if(updateErroreProcessamento) {
  1983.                     this.log.debug("UPDATE ERRORE PROCESSAMENTO TIPO-2 ["+motivoErroreGiaRegistrato+"] tipo["+this.tipo+"] sa["+servizioApplicativo+"]");
  1984.                     pstmt.setString(index++,motivoErroreGiaRegistrato);
  1985.                 }
  1986.                 pstmt.setString(index++,this.idBusta);
  1987.                 if(servizioApplicativo!=null)
  1988.                     pstmt.setString(index++,servizioApplicativo);
  1989.                 else
  1990.                     pstmt.setString(index++,this.tipo);

  1992.                 /*
  1993.             if(servizioApplicativo!=null)
  1994.                 this.log.debug("[aggiornaDataRispedizione SA("+servizioApplicativo+")] Aggiorno MSG["+this.tipo+"/"+this.idBusta+"] RISPEDIZIONE["+t.toString()+"]");
  1995.             else
  1996.                 this.log.debug("[aggiornaDataRispedizione] Aggiorno MSG["+this.tipo+"/"+this.idBusta+"] RISPEDIZIONE["+t.toString()+"]");
  1997.                  */

  1999.                 pstmt.execute();
  2000.                 pstmt.close();
  2001.                 
  2002.                 if(updateErroreProcessamento) {
  2003.                     if(this.pddContext!=null) {
  2004.                         this.pddContext.addObject(CostantiPdD.OPENSPCOOP2_PDD_CONTEXT_NUMERO_TENTATIVI_RICONSEGNA_UPDATED, numeroSpedizione);
  2005.                     }
  2006.                 }

  2008.             } catch(Exception e) {
  2009.                 String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento data rispedizione Messaggio "+this.tipo+"/"+this.idBusta+" sa["+servizioApplicativo+"]: "+e.getMessage();      
  2010.                 try{
  2011.                     if(pstmt != null)
  2012.                         pstmt.close();
  2013.                 } catch(Exception er) {
  2014.                     // close
  2015.                 }
  2016.                 this.log.error(errorMsg,e);
  2017.                 throw new GestoreMessaggiException(errorMsg,e);
  2018.             }
  2019.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  2020.             //NOP
  2021.         }else{
  2022.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2023.         }
  2024.     }

  2026.     /**
  2027.      * Aggiorna l'id JMS di un messaggio ricevuto da un nodo di OpenSPCoop. 
  2028.      *
  2029.      * @param nodoOpenSPCoop  Nodo OpenSPCoop che ha ricevuto il messaggio
  2030.      * @param idHeaderJMS Identificativo JMS del messaggio ricevuto
  2031.      * 
  2032.      */
  2033.     public void aggiornaIDHeaderJMS(String nodoOpenSPCoop,String idHeaderJMS) throws GestoreMessaggiException{
  2034.         aggiornaIDHeaderJMS(nodoOpenSPCoop,idHeaderJMS,null);
  2035.     }
  2036.     /**
  2037.      * Aggiorna l'id JMS di un messaggio ricevuto da un nodo di OpenSPCoop. 
  2038.      *
  2039.      * @param nodoOpenSPCoop  Nodo OpenSPCoop che ha ricevuto il messaggio
  2040.      * @param idHeaderJMS Identificativo JMS del messaggio ricevuto
  2041.      * @param servizioApplicativo Servizio Applicativo utilizzato come chiave insieme all'idBusta
  2042.      * 
  2043.      */
  2044.     public void aggiornaIDHeaderJMS(String nodoOpenSPCoop,String idHeaderJMS,String servizioApplicativo) throws GestoreMessaggiException{
  2045.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  2046.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  2047.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  2048.             Connection connectionDB = stateful.getConnectionDB();
  2049.             PreparedStatement pstmt = null;
  2050.             try{    

  2052.                 // Costruzione Query
  2053.                 String query = null;
  2054.                 if( ConsegnaContenutiApplicativi.ID_MODULO.equals(nodoOpenSPCoop)  ){
  2055.                     query = "UPDATE "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" SET "+getColonnaSQL(nodoOpenSPCoop)+
  2056.                             "=? WHERE  ID_MESSAGGIO = ? AND SERVIZIO_APPLICATIVO=?";
  2057.                 }else{
  2058.                     query = "UPDATE "+GestoreMessaggi.MESSAGGI+" SET "+getColonnaSQL(nodoOpenSPCoop)+"=? WHERE  ID_MESSAGGIO = ? AND TIPO=?";
  2059.                 }
  2060.                 pstmt = connectionDB.prepareStatement(query);
  2061.                 pstmt.setString(1,idHeaderJMS);
  2062.                 pstmt.setString(2,this.idBusta);
  2063.                 if( ConsegnaContenutiApplicativi.ID_MODULO.equals(nodoOpenSPCoop)  )
  2064.                     pstmt.setString(3,servizioApplicativo);
  2065.                 else
  2066.                     pstmt.setString(3,this.tipo);
  2067.                 pstmt.execute();
  2068.                 pstmt.close();

  2070.             } catch(Exception e) {
  2071.                 String errorMsg = "GESTORE_MESSAGGI, Errore di aggiornamento IDHeaderJMS "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  2072.                 try{
  2073.                     if(pstmt != null)
  2074.                         pstmt.close();
  2075.                 } catch(Exception er) {
  2076.                     // close
  2077.                 }
  2078.                 this.log.error(errorMsg,e);
  2079.                 throw new GestoreMessaggiException(errorMsg,e);
  2080.             }
  2081.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  2082.             //NOP
  2083.         }else{
  2084.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2085.         }
  2086.     }













  2100.     /* ********  R E A D    M E S S A G E   (Gestione Transazione Interna di OpenSPCoop) ******** */


  2103.     /**
  2104.      * Ritorna il proprietario (nodo OpenSPCoop) di un messaggio gestito da OpenSPCoop. 
  2105.      * La lettura del proprietario viene effettuata in Serializable Level
  2106.      *
  2107.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  2108.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  2109.      * @return il proprietario di un messaggio
  2110.      * 
  2111.      */
  2112.     public String getProprietario_SerializableRead(String idModulo,long attesaAttiva,int checkInterval) throws GestoreMessaggiException{
  2113.         return getProprietario(idModulo,true,attesaAttiva,checkInterval,false);
  2114.     }
  2115.     /**
  2116.      * Ritorna il proprietario (nodo OpenSPCoop) di un messaggio gestito da OpenSPCoop. 
  2117.      * La lettura del proprietario viene effettuata in Serializable Level
  2118.      *
  2119.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  2120.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  2121.      * @return il proprietario di un messaggio
  2122.      * 
  2123.      */
  2124.     public String getProprietario_SerializableRead(String idModulo,long attesaAttiva,int checkInterval,boolean onlyCache) throws GestoreMessaggiException{
  2125.         return getProprietario(idModulo,true,attesaAttiva,checkInterval,onlyCache);
  2126.     }
  2127.     /**
  2128.      * Ritorna il proprietario (nodo OpenSPCoop) di un messaggio gestito da OpenSPCoop. 
  2129.      *
  2130.      * @return il proprietario di un messaggio
  2131.      * 
  2132.      */
  2133.     public String getProprietario(String idModulo) throws GestoreMessaggiException{
  2134.         return getProprietario(idModulo,false,-1,-1,false);
  2135.     }
  2136.     /**
  2137.      * Ritorna il proprietario (nodo OpenSPCoop) di un messaggio gestito da OpenSPCoop. 
  2138.      *
  2139.      * @return il proprietario di un messaggio
  2140.      * 
  2141.      */
  2142.     public String getProprietario(String idModulo,boolean onlyCache) throws GestoreMessaggiException{
  2143.         return getProprietario(idModulo,false,-1,-1,onlyCache);
  2144.     }
  2145.     /**
  2146.      * Ritorna il proprietario (nodo OpenSPCoop) di un messaggio gestito da OpenSPCoop. 
  2147.      *
  2148.      * @param serializable Indicazione se la ricerca deve avvenire in serializable mode
  2149.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  2150.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  2151.      * @return il proprietario di un messaggio
  2152.      * 
  2153.      */
  2154.     private String getProprietario(String idModulo,boolean serializable,long attesaAttiva,int checkInterval,boolean onlyCache) throws GestoreMessaggiException{

  2156.         if ( (this.openspcoopstate instanceof OpenSPCoopStateless) && (this.oneWayVersione11==false) ) { 
  2157.             return (this.isRichiesta) ? ((OpenSPCoopStateless)this.openspcoopstate).getDestinatarioRequestMsgLib() 
  2158.                     : ((OpenSPCoopStateless)this.openspcoopstate).getDestinatarioResponseMsgLib();
  2159.         }
  2160.         else if ( (this.openspcoopstate instanceof OpenSPCoopStateful) || (this.oneWayVersione11)) {

  2162.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  2163.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  2165.             Connection connectionDB = stateMSG.getConnectionDB();

  2167.             if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){

  2169.                 try{
  2170.                     // get from cache
  2171.                     this.msgDiag.highDebug("getProprietario, read from cache...");
  2172.                     String proprietario = GestoreMessaggi.getFromCache_Proprietario(idModulo,this.tipo,this.idBusta);
  2173.                     if(proprietario!=null)
  2174.                         return proprietario;
  2175.                     else{
  2176.                         if(onlyCache){
  2177.                             return null;
  2178.                         }
  2179.                     }
  2180.                 }catch(Exception e){
  2181.                     String errorMsg = "GESTORE_MESSAGGI, error getProprietario (Cache) "+this.tipo+"/"+this.idBusta+": "+e.getMessage();        
  2182.                     this.log.error(errorMsg,e);
  2183.                     throw new GestoreMessaggiException(errorMsg,e);
  2184.                 }

  2186.             }

  2188.             this.msgDiag.highDebug("getProprietario, read from DB...");


  2191.             if(serializable == false){
  2192.                 // NON SERIALIZABLE MODE

  2194.                 PreparedStatement pstmt = null;
  2195.                 ResultSet rs = null;
  2196.                 String value = null;
  2197.                 try{
  2198.                     String query = "SELECT PROPRIETARIO FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  2199.                     //log.debug("Query: "+query);
  2200.                     pstmt = connectionDB.prepareStatement(query);
  2201.                     pstmt.setString(1,this.idBusta);
  2202.                     pstmt.setString(2,this.tipo);
  2203.                     rs = pstmt.executeQuery();      
  2204.                     if(rs.next()){
  2205.                         value = rs.getString("PROPRIETARIO");
  2206.                     }
  2207.                     rs.close();
  2208.                     pstmt.close();
  2209.                 } catch(Exception e) {
  2210.                     try{
  2211.                         if(rs != null)
  2212.                             rs.close();
  2213.                     } catch(Exception er) {
  2214.                         // close
  2215.                     }
  2216.                     try{
  2217.                         if(pstmt != null)
  2218.                             pstmt.close();
  2219.                     } catch(Exception er) {
  2220.                         // close
  2221.                     }
  2222.                 }
  2223.                 return value;

  2225.             }else{

  2227.                 // SERIALIZABLE MODE

  2229.                 /*
  2230.           Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  2231.           che esecuzioni parallele non leggano dati inconsistenti.
  2232.           Con il livello SERIALIZABLE, se ritorna una eccezione, deve essere riprovato
  2233.           La sincronizzazione e' necessaria per via del possibile accesso simultaneo del servizio Gop
  2234.           e del servizio che si occupa di eliminare destinatari di messaggi
  2235.                  */
  2236.                 // setAutoCommit e livello Isolamento
  2237.                 int oldTransactionIsolation = -1;
  2238.                 try{
  2239.                     oldTransactionIsolation = connectionDB.getTransactionIsolation();
  2240.                     connectionDB.setAutoCommit(false);
  2241.                     JDBCUtilities.setTransactionIsolationSerializable(this.propertiesReader.getDatabaseType(), connectionDB);
  2242.                 } catch(Exception er) {
  2243.                     String errorMsg = "GESTORE_MESSAGGI, Errore getProprietario Messaggio(setIsolation) "+this.tipo+"/"+this.idBusta+": "+er.getMessage();      
  2244.                     this.log.error(errorMsg,er);
  2245.                     throw new GestoreMessaggiException(errorMsg,er);
  2246.                 }

  2248.                 PreparedStatement pstmt = null;
  2249.                 ResultSet rs = null;
  2250.                 boolean getProprietarioOK = false;
  2251.                 String value = null;

  2253.                 long scadenzaWhile = DateManager.getTimeMillis() + attesaAttiva;

  2255.                 while(getProprietarioOK==false && DateManager.getTimeMillis() < scadenzaWhile){

  2257.                     try{    
  2258.                         // Costruzione Query
  2259.                         String query = "SELECT PROPRIETARIO FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO=? AND TIPO=? FOR UPDATE";
  2260.                         //log.debug("Query: "+query);
  2261.                         pstmt = connectionDB.prepareStatement(query);
  2262.                         pstmt.setString(1,this.idBusta);
  2263.                         pstmt.setString(2,this.tipo);
  2264.                         rs = pstmt.executeQuery();      
  2265.                         if(rs.next()){
  2266.                             value = rs.getString("PROPRIETARIO");
  2267.                         }
  2268.                         rs.close();
  2269.                         pstmt.close();

  2271.                         // Chiusura Transazione
  2272.                         connectionDB.commit();

  2274.                         // ID Costruito
  2275.                         getProprietarioOK = true;

  2277.                     } catch(Exception e) {
  2278.                         try{
  2279.                             if(rs != null)
  2280.                                 rs.close();
  2281.                         } catch(Exception er) {
  2282.                             // close
  2283.                         }
  2284.                         try{
  2285.                             if(pstmt != null)
  2286.                                 pstmt.close();
  2287.                         } catch(Exception er) {
  2288.                             // close
  2289.                         }
  2290.                         try{
  2291.                             connectionDB.rollback();
  2292.                         } catch(Exception er) {
  2293.                             // ignore
  2294.                         }
  2295.                     }

  2297.                     if(getProprietarioOK == false){
  2298.                         // Per aiutare ad evitare conflitti
  2299.                         try{
  2300.                             Utilities.sleep((getRandom()).nextInt(checkInterval)); // random da 0ms a checkIntervalms
  2301.                         }catch(Exception eRandom){
  2302.                             // ignore
  2303.                         }
  2304.                     }
  2305.                 }
  2306.                 // Ripristino Transazione
  2307.                 try{
  2308.                     connectionDB.setTransactionIsolation(oldTransactionIsolation);
  2309.                     connectionDB.setAutoCommit(true);
  2310.                     stateMSG.updateConnection(connectionDB);
  2311.                 } catch(Exception er) {
  2312.                     String errorMsg = "GESTORE_MESSAGGI, Errore getProprietario Messaggio(ripristinoIsolation) "+this.tipo+"/"+this.idBusta+": "+er.getMessage();       
  2313.                     this.log.error(errorMsg,er);
  2314.                     throw new GestoreMessaggiException(errorMsg,er);

  2316.                 }
  2317.                 return value;
  2318.             }
  2319.         }else{
  2320.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2321.         }
  2322.     }


  2325.     /**
  2326.      * Ritorna l'id JMS di un messaggio ricevuto da un nodo di OpenSPCoop. 
  2327.      *
  2328.      * @param nodoOpenSPCoop  Nodo OpenSPCoop desiderato
  2329.      * 
  2330.      */
  2331.     public String getIDJMSRicevuto(String nodoOpenSPCoop) throws GestoreMessaggiException{
  2332.         return getIDJMSRicevuto(nodoOpenSPCoop,null);
  2333.     }
  2334.     /**
  2335.      * Ritorna l'id JMS di un messaggio ricevuto da un nodo di OpenSPCoop. 
  2336.      *
  2337.      * @param nodoOpenSPCoop  Nodo OpenSPCoop desiderato
  2338.      * @param servizioApplicativo Servizio Applicativo utilizzato come chiave insieme all'id
  2339.      * 
  2340.      */
  2341.     public String getIDJMSRicevuto(String nodoOpenSPCoop,String servizioApplicativo) throws GestoreMessaggiException{
  2342.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  2343.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  2344.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  2345.             Connection connectionDB = stateful.getConnectionDB();
  2346.             PreparedStatement pstmt = null;
  2347.             ResultSet rs = null; 
  2348.             try{    
  2349.                 // Costruzione Query
  2350.                 String query = null;
  2351.                 if( ConsegnaContenutiApplicativi.ID_MODULO.equals(nodoOpenSPCoop)  ){
  2352.                     query = "SELECT "+getColonnaSQL(nodoOpenSPCoop)+" FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+
  2353.                             " WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  2354.                 }else{
  2355.                     query = "SELECT "+getColonnaSQL(nodoOpenSPCoop)+" FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  2356.                 }
  2357.                 //log.debug("Query: "+query);
  2358.                 pstmt = connectionDB.prepareStatement(query);
  2359.                 pstmt.setString(1,this.idBusta);
  2360.                 if( ConsegnaContenutiApplicativi.ID_MODULO.equals(nodoOpenSPCoop)  )
  2361.                     pstmt.setString(2,servizioApplicativo);
  2362.                 else
  2363.                     pstmt.setString(2,this.tipo);
  2364.                 rs = pstmt.executeQuery();
  2365.                 String value = null;
  2366.                 if(rs.next()){
  2367.                     value = rs.getString(getColonnaSQL(nodoOpenSPCoop));
  2368.                 }
  2369.                 rs.close();
  2370.                 pstmt.close();

  2372.                 return value;

  2374.             } catch(Exception e) {
  2375.                 String errorMsg = "GESTORE_MESSAGGI, Errore get IDHeaderJMS "+this.tipo+"/"+this.idBusta+": "+e.getMessage();       
  2376.                 try{
  2377.                     if(rs != null)
  2378.                         rs.close();
  2379.                 } catch(Exception er) {
  2380.                     // close
  2381.                 }
  2382.                 try{
  2383.                     if(pstmt != null)
  2384.                         pstmt.close();
  2385.                 } catch(Exception er) {
  2386.                     // close
  2387.                 }
  2388.                 this.log.error(errorMsg,e);
  2389.                 throw new GestoreMessaggiException(errorMsg,e);
  2390.             }   
  2391.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  2392.             //          //TODO Metodo stateful only
  2393.             //          return null;
  2394.         }else{
  2395.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2396.         }
  2397.     }

















  2415.     /* ********  R E A D    M E S S A G E   ******** */
  2416.     /**
  2417.      * Ritorna true se il messaggi risulta gia' registrato
  2418.      *
  2419.      * @return true se il  messaggio risulta gia' registrato
  2420.      * @throws GestoreMessaggiException 
  2421.      * 
  2422.      */
  2423.     public boolean existsMessage_onlyCache(boolean searchForRiferimentoMsg) throws GestoreMessaggiException{
  2424.         return existsMessage_engine(searchForRiferimentoMsg,true,false);
  2425.     }

  2427.     /**
  2428.      * Ritorna true se il messaggi risulta gia' registrato
  2429.      *
  2430.      * @return true se il  messaggio risulta gia' registrato
  2431.      * @throws GestoreMessaggiException 
  2432.      * 
  2433.      */
  2434.     public boolean existsMessage_onlyCache() throws GestoreMessaggiException{
  2435.         return existsMessage_engine(false,true,false);
  2436.     }

  2438.     /**
  2439.      * Ritorna true se il messaggi risulta gia' registrato
  2440.      *
  2441.      * @return true se il  messaggio risulta gia' registrato
  2442.      * @throws GestoreMessaggiException 
  2443.      * 
  2444.      */
  2445.     public boolean existsMessage_noCache(boolean searchForRiferimentoMsg) throws GestoreMessaggiException{
  2446.         return existsMessage_engine(searchForRiferimentoMsg,false,true);
  2447.     }

  2449.     /**
  2450.      * Ritorna true se il messaggi risulta gia' registrato
  2451.      *
  2452.      * @return true se il  messaggio risulta gia' registrato
  2453.      * @throws GestoreMessaggiException 
  2454.      * 
  2455.      */
  2456.     public boolean existsMessage_noCache() throws GestoreMessaggiException{
  2457.         return existsMessage_engine(false,false,true);
  2458.     }

  2460.     /**
  2461.      * Ritorna true se il messaggi risulta gia' registrato
  2462.      *
  2463.      * @return true se il  messaggio risulta gia' registrato
  2464.      * @throws GestoreMessaggiException 
  2465.      * 
  2466.      */
  2467.     public boolean existsMessage(boolean searchForRiferimentoMsg) throws GestoreMessaggiException{
  2468.         return existsMessage_engine(searchForRiferimentoMsg,false,false);
  2469.     }

  2471.     /**
  2472.      * Ritorna true se il messaggi risulta gia' registrato
  2473.      *
  2474.      * @return true se il  messaggio risulta gia' registrato
  2475.      * @throws GestoreMessaggiException 
  2476.      * 
  2477.      */
  2478.     public boolean existsMessage() throws GestoreMessaggiException{
  2479.         return existsMessage_engine(false,false,false);
  2480.     }

  2482.     /**
  2483.      * Ritorna true se il messaggi risulta gia' registrato
  2484.      *
  2485.      * @return true se il  messaggio risulta gia' registrato
  2486.      * @throws GestoreMessaggiException 
  2487.      * 
  2488.      */
  2489.     private boolean existsMessage_engine(boolean searchForRiferimentoMsg,boolean onlyCache,boolean noCache) throws GestoreMessaggiException{

  2491.         if( (this.openspcoopstate instanceof OpenSPCoopStateless) && 
  2492.                 ( (this.oneWayVersione11==false) || (this.routingStateless)  ) ){
  2493.             return false; // il messaggio non viene mai salvato
  2494.         }



  2498.         StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  2499.                 : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  2501.         Connection connectionDB = stateMSG.getConnectionDB();


  2504.         // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  2505.         // come riferimento Messaggio l'ID del gestore.
  2506.         // In caso di esistenza uso l'ID del messaggio trovato e non quello del gestore
  2507.         String idBustaSearch = this.idBusta;
  2508.         if(searchForRiferimentoMsg){
  2509.             try{
  2510.                 idBustaSearch = mapRiferimentoIntoIDBusta();
  2511.             }catch(Exception e){
  2512.                 // ignore
  2513.             }
  2514.             //System.out.println("Cerco riferimento di id["+this.idBusta+"]: "+idBustaSearch);
  2515.             if(idBustaSearch==null){
  2516.                 return false;
  2517.             }
  2518.         }

  2520.         if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null && (noCache==false) ){

  2522.             try{
  2523.                 // get from cache
  2524.                 this.msgDiag.highDebug("existsMessage, read from cache ID["+idBustaSearch+"]...");
  2525.                 Object value = GestoreMessaggi.getFromCache_existsMessage(this.tipo,idBustaSearch);

  2527.                 if((value!=null) && (((Boolean)value)==true)){
  2528.                     return true;
  2529.                 }else{
  2530.                     if(onlyCache){
  2531.                         return false;
  2532.                     }
  2533.                 }
  2534.             }catch(Exception e){
  2535.                 String errorMsg = "GESTORE_MESSAGGI, error existsMessage (Cache) "+this.tipo+"/"+idBustaSearch+": "+e.getMessage();     
  2536.                 this.log.error(errorMsg,e);
  2537.                 return false;
  2538.             }

  2540.         }

  2542.         this.msgDiag.highDebug("existsMessage, read from DB ID["+idBustaSearch+"]...");

  2544.         PreparedStatement pstmt = null;
  2545.         ResultSet rs = null; 
  2546.         try{    
  2547.             // Costruzione Query
  2548.             String query = "SELECT ID_MESSAGGIO FROM "+GestoreMessaggi.MESSAGGI+
  2549.                     " WHERE ID_MESSAGGIO=? AND TIPO=?";
  2550.             //log.debug("Query: "+query);
  2551.             pstmt = connectionDB.prepareStatement(query);
  2552.             pstmt.setString(1,idBustaSearch);
  2553.             pstmt.setString(2,this.tipo);
  2554.             rs = pstmt.executeQuery();
  2555.             if(rs.next()){
  2556.                 rs.close();
  2557.                 pstmt.close();
  2558.                 return true;
  2559.             }
  2560.             rs.close();
  2561.             pstmt.close();

  2563.             return false;

  2565.         } catch(Exception e) {
  2566.             String errorMsg = "GESTORE_MESSAGGI, Errore existsMessage "+this.tipo+"/"+idBustaSearch+": "+e.getMessage();        
  2567.             try{
  2568.                 if(rs != null)
  2569.                     rs.close();
  2570.             } catch(Exception er) {
  2571.                 // close
  2572.             }
  2573.             try{
  2574.                 if(pstmt != null)
  2575.                     pstmt.close();
  2576.             } catch(Exception er) {
  2577.                 // close
  2578.             }
  2579.             this.log.error(errorMsg,e);
  2580.             return false;
  2581.         }
  2582.     }


  2585.     /**
  2586.      * Ritorna il messaggio gestito da OpenSPCoop. 
  2587.      *
  2588.      * @return il  messaggio
  2589.      * 
  2590.      */
  2591.     public OpenSPCoop2Message getMessage() throws GestoreMessaggiException{
  2592.         return getMessage(null);
  2593.     }
  2594.     public OpenSPCoop2Message getMessage(Date oraRegistrazione) throws GestoreMessaggiException{
  2595.         return getMessage(false, oraRegistrazione);
  2596.     }

  2598.     /**
  2599.      * Ritorna il messaggio gestito da OpenSPCoop. 
  2600.      *
  2601.      * @param searchForRiferimentoMsg Se true, il messaggio viene ricercato per Riferimento Messaggio
  2602.      * @return il  messaggio
  2603.      * 
  2604.      */
  2605.     public OpenSPCoop2Message getMessage(boolean searchForRiferimentoMsg) throws GestoreMessaggiException{
  2606.         return getMessage(searchForRiferimentoMsg, null);
  2607.     }
  2608.     public OpenSPCoop2Message getMessage(boolean searchForRiferimentoMsg, Date oraRegistrazione) throws GestoreMessaggiException{

  2610.         //      if (openspcoopstate instanceof OpenSPCoopStateless) {
  2611.         //          if (isRichiesta) return ((OpenSPCoopStateless)openspcoopstate).getRichiestaMsg() ;
  2612.         //          else return ((OpenSPCoopStateless)openspcoopstate).getRispostaMsg() ;
  2613.         //      }

  2615.         OpenSPCoop2Message msg = null;

  2617.         // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  2618.         // come riferimento Messaggio l'ID del gestore.
  2619.         // In caso di esistenza uso l'ID del messaggio trovato e non quello del gestore
  2620.         String idBustaSearch = this.idBusta;
  2621.         if(searchForRiferimentoMsg){
  2622.             idBustaSearch = mapRiferimentoIntoIDBusta();
  2623.         }

  2625.         SavedMessage soapMsg = null;
  2626.         try{
  2627.             soapMsg = new SavedMessage(idBustaSearch, this.openspcoopstate, this.tipo,this.workDir,GestoreMessaggi.adapter,this.log);
  2628.             msg = soapMsg.read(this.isRichiesta, (this.portaDiTipoStateless || this.routingStateless), oraRegistrazione);
  2629.         }catch(Exception e){
  2630.             String errorMsg = "GESTORE_MESSAGGI, getMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();
  2631.             this.log.error(errorMsg,e);
  2632.             throw new GestoreMessaggiException(errorMsg,e);
  2633.         }
  2634.         return msg;
  2635.     }

  2637.     
  2638.     public OpenSPCoop2Message getResponseMessage(boolean updateTransportRequest, boolean throwExceptionIfNotExists) throws GestoreMessaggiException{
  2639.         return getResponseMessage(null, updateTransportRequest, throwExceptionIfNotExists);
  2640.     }
  2641.     public OpenSPCoop2Message getResponseMessage(Date oraRegistrazione, boolean updateTransportRequest, boolean throwExceptionIfNotExists) throws GestoreMessaggiException{

  2643.         //      if (openspcoopstate instanceof OpenSPCoopStateless) {
  2644.         //          if (isRichiesta) return ((OpenSPCoopStateless)openspcoopstate).getRichiestaMsg() ;
  2645.         //          else return ((OpenSPCoopStateless)openspcoopstate).getRispostaMsg() ;
  2646.         //      }

  2648.         OpenSPCoop2Message msg = null;

  2650.         // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  2651.         // come riferimento Messaggio l'ID del gestore.
  2652.         // In caso di esistenza uso l'ID del messaggio trovato e non quello del gestore
  2653.         String idBustaSearch = this.idBusta;
  2654.         
  2655.         SavedMessage soapMsg = null;
  2656.         try{
  2657.             soapMsg = new SavedMessage(idBustaSearch, this.openspcoopstate, this.tipo,this.workDir,GestoreMessaggi.adapter,this.log);
  2658.             msg = soapMsg.readResponse(oraRegistrazione, throwExceptionIfNotExists);
  2659.         }catch(Exception e){
  2660.             String errorMsg = "GESTORE_MESSAGGI, getMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();
  2661.             this.log.error(errorMsg,e);
  2662.             throw new GestoreMessaggiException(errorMsg,e);
  2663.         }
  2664.         
  2665.         try{
  2666.             if(updateTransportRequest) {
  2667.                 if(msg.getTransportResponseContext()!=null &&
  2668.                         msg.getTransportResponseContext().getHeaders()!=null &&
  2669.                         !msg.getTransportResponseContext().getHeaders().isEmpty()) {
  2670.                     if(msg.getTransportRequestContext()==null) {
  2671.                         msg.setTransportRequestContext(new TransportRequestContext());
  2672.                     }
  2673.                     if(msg.getTransportRequestContext().getHeaders()==null) {
  2674.                         msg.getTransportRequestContext().setHeaders(msg.getTransportResponseContext().getHeaders());
  2675.                     }
  2676.                     else if(msg.getTransportRequestContext().getHeaders().isEmpty()) {
  2677.                         msg.getTransportRequestContext().getHeaders().putAll(msg.getTransportResponseContext().getHeaders());
  2678.                     }
  2679.                     else {
  2680.                         for (String hdr : msg.getTransportResponseContext().getHeaders().keySet()) {
  2681.                             List<String> vResponse = msg.getTransportResponseContext().getHeaderValues(hdr);
  2682.                             if(vResponse!=null && !vResponse.isEmpty()){
  2683.                                 List<String> vRequest = msg.getTransportRequestContext().getHeaderValues(hdr);
  2684.                                 if(vRequest==null || vRequest.isEmpty()) {
  2685.                                     msg.getTransportRequestContext().getHeaders().put(hdr, vResponse);
  2686.                                 }
  2687.                                 else{
  2688.                                     for (String v : vResponse) {
  2689.                                         if(!vRequest.contains(v)) {
  2690.                                             vRequest.add(v);
  2691.                                         }
  2692.                                     }
  2693.                                 }
  2694.                             }
  2695.                         }
  2696.                     }
  2697.                 }
  2698.             }
  2699.         }catch(Exception e){
  2700.             String errorMsg = "GESTORE_MESSAGGI, getMessage "+this.tipo+"/"+this.idBusta+" (fixTransportRequest): "+e.getMessage();
  2701.             this.log.error(errorMsg,e);
  2702.             throw new GestoreMessaggiException(errorMsg,e);
  2703.         }
  2704.         
  2705.         return msg;
  2706.     }
  2707.     
  2708.     public Context getSyncTransactionContext() throws GestoreMessaggiException{
  2709.         return getSyncTransactionContext(null);
  2710.     }
  2711.     public Context getSyncTransactionContext(Date oraRegistrazione) throws GestoreMessaggiException{

  2713.         Context context = null;

  2715.         // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  2716.         // come riferimento Messaggio l'ID del gestore.
  2717.         // In caso di esistenza uso l'ID del messaggio trovato e non quello del gestore
  2718.         String idBustaSearch = this.idBusta;
  2719.         
  2720.         SavedMessage soapMsg = null;
  2721.         try{
  2722.             soapMsg = new SavedMessage(idBustaSearch, this.openspcoopstate, this.tipo,this.workDir,GestoreMessaggi.adapter,this.log);
  2723.             context = soapMsg.readTransactionContext(oraRegistrazione);
  2724.         }catch(Exception e){
  2725.             String errorMsg = "GESTORE_MESSAGGI, getSyncTransactionContext "+this.tipo+"/"+this.idBusta+": "+e.getMessage();
  2726.             this.log.error(errorMsg,e);
  2727.             throw new GestoreMessaggiException(errorMsg,e);
  2728.         }
  2729.                 
  2730.         return context;
  2731.     }
  2732.     

  2734.     /**
  2735.      * Ritorna l'idBusta di un messaggio che possiede come riferimento messaggio l'ID del gestore. 
  2736.      *
  2737.      * @return l'idBusta di un messaggio che possiede come riferimento messaggio l'ID del gestore in caso di esistenza del messaggio
  2738.      *         cercato, null altrimenti
  2739.      * 
  2740.      */
  2741.     public String mapRiferimentoIntoIDBusta()throws GestoreMessaggiException{
  2742.         return mapRiferimentoIntoIDBusta(false);
  2743.     }

  2745.     /**
  2746.      * Ritorna l'idBusta di un messaggio che possiede come riferimento messaggio l'ID del gestore. 
  2747.      *
  2748.      * @return l'idBusta di un messaggio che possiede come riferimento messaggio l'ID del gestore in caso di esistenza del messaggio
  2749.      *         cercato, null altrimenti
  2750.      * 
  2751.      */
  2752.     public String mapRiferimentoIntoIDBusta(boolean onlyCache)throws GestoreMessaggiException{
  2753.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  2754.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  2755.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  2757.             Connection connectionDB = stateful.getConnectionDB();

  2759.             if(GestoreMessaggi.cacheMappingGestoreMessaggi!=null){

  2761.                 try{
  2762.                     // get from cache
  2763.                     this.msgDiag.highDebug("mapRiferimentoIntoIDBusta, read from cache ...");
  2764.                     String id = GestoreMessaggi.getFromCache_idFromRifMsgMapping(this.tipo,this.idBusta);
  2765.                     if(id!=null)
  2766.                         return id;
  2767.                     else{
  2768.                         if(onlyCache){
  2769.                             return null;
  2770.                         }
  2771.                     }
  2772.                 }catch(Exception e){
  2773.                     String errorMsg = "GESTORE_MESSAGGI, error mapRiferimentoIntoIDBusta (Cache) "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  2774.                     this.log.error(errorMsg,e);
  2775.                     throw new GestoreMessaggiException(errorMsg,e);
  2776.                 }

  2778.             }

  2780.             this.msgDiag.highDebug("mapRiferimentoIntoIDBusta, read from DB ...");

  2782.             PreparedStatement pstmt = null;
  2783.             ResultSet rs = null;
  2784.             try{    
  2785.                 // Costruzione Query
  2786.                 String query = "SELECT ID_MESSAGGIO FROM "+GestoreMessaggi.MESSAGGI+" WHERE RIFERIMENTO_MSG=? AND TIPO=? AND PROPRIETARIO IS NOT NULL AND PROPRIETARIO != ? ORDER BY ORA_REGISTRAZIONE DESC";
  2787.                 //log.debug("Query: "+query);
  2788.                 pstmt = connectionDB.prepareStatement(query);
  2789.                 pstmt.setString(1,this.idBusta);
  2790.                 pstmt.setString(2,this.tipo);
  2791.                 pstmt.setString(3,TimerGestoreMessaggi.ID_MODULO);
  2792.                 rs = pstmt.executeQuery();
  2793.                 String value = null;
  2794.                 if(rs.next()){
  2795.                     value = rs.getString("ID_MESSAGGIO");
  2796.                 }

  2798.                 //System.out.println("GET FROM DB RIFERIMENTO RIF["+this.tipo+"_"+this.idBusta+"] ID TROVATO: ["+value+"]");

  2800.                 rs.close();
  2801.                 pstmt.close();

  2803.                 return value;

  2805.             } catch(Exception e) {
  2806.                 String errorMsg = "GESTORE_MESSAGGI, error mapRiferimentoIntoIDBusta "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  2807.                 try{
  2808.                     if(rs != null)
  2809.                         rs.close();
  2810.                 } catch(Exception er) {
  2811.                     // close
  2812.                 }
  2813.                 try{
  2814.                     if(pstmt != null)
  2815.                         pstmt.close();
  2816.                 } catch(Exception er) {
  2817.                     // close
  2818.                 }
  2819.                 this.log.error(errorMsg,e);
  2820.                 throw new GestoreMessaggiException(errorMsg,e);
  2821.             }   
  2822.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  2823.             //          //TODO Metodo stateful only
  2824.             //          return null;
  2825.         }else{
  2826.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2827.         }

  2829.     }

  2831.     public String getErroreProcessamentoMessaggio(String servizioApplicativo) throws GestoreMessaggiException{
  2832.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || this.oneWayVersione11) {
  2833.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  2834.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  2835.             Connection connectionDB = stateMSG.getConnectionDB();
  2836.             PreparedStatement pstmtRead = null;
  2837.             ResultSet rs = null; 
  2838.             String motivoErroreGiaRegistrato = null;
  2839.             try{    
  2840.                 // Costruzione Query
  2841.                 String query = null;
  2842.                 if(servizioApplicativo==null)
  2843.                     query = "SELECT ERRORE_PROCESSAMENTO FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";
  2844.                 else
  2845.                     query = "SELECT ERRORE_PROCESSAMENTO FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" WHERE ID_MESSAGGIO = ? AND SERVIZIO_APPLICATIVO=?";

  2847.                 //log.debug("Query: "+query);
  2848.                 pstmtRead = connectionDB.prepareStatement(query);
  2849.                 pstmtRead.setString(1,this.idBusta);
  2850.                 if(servizioApplicativo!=null)
  2851.                     pstmtRead.setString(2,servizioApplicativo);
  2852.                 else
  2853.                     pstmtRead.setString(2,this.tipo);

  2855.                 rs = pstmtRead.executeQuery();
  2856.                 if(rs.next()){
  2857.                     motivoErroreGiaRegistrato = rs.getString("ERRORE_PROCESSAMENTO");
  2858.                 }
  2859.                 rs.close();
  2860.                 pstmtRead.close();

  2862.             } catch(Exception e) {
  2863.                 String errorMsg = "GESTORE_MESSAGGI, Errore getErroreProcessamentoMessaggio "+this.tipo+"/"+this.idBusta+" sa["+servizioApplicativo+"]: "+e.getMessage();       
  2864.                 try{
  2865.                     if(rs != null)
  2866.                         rs.close();
  2867.                 } catch(Exception er) {
  2868.                     // close
  2869.                 }
  2870.                 try{
  2871.                     if(pstmtRead != null)
  2872.                         pstmtRead.close();
  2873.                 } catch(Exception er) {
  2874.                     // close
  2875.                 }
  2876.                 this.log.error(errorMsg,e);
  2877.                 throw new GestoreMessaggiException(errorMsg,e);
  2878.             }

  2880.             return motivoErroreGiaRegistrato;
  2881.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  2882.             //          //TODO Metodo stateful only
  2883.             //          return null;
  2884.         }else{
  2885.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2886.         }
  2887.     }

  2889.     public Timestamp getOraRegistrazioneMessaggio() throws GestoreMessaggiException{

  2891.         Timestamp t = null;

  2893.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  2894.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  2895.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  2897.             Connection connectionDB = stateful.getConnectionDB();

  2899.             PreparedStatement pstmtRead = null;
  2900.             ResultSet rs = null; 
  2901.             try{    
  2902.                 // Costruzione Query
  2903.                 String query = "SELECT ORA_REGISTRAZIONE FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";

  2905.                 //log.debug("Query: "+query);
  2906.                 pstmtRead = connectionDB.prepareStatement(query);
  2907.                 pstmtRead.setString(1,this.idBusta);
  2908.                 pstmtRead.setString(2,this.tipo);

  2910.                 rs = pstmtRead.executeQuery();
  2911.                 if(rs.next()){
  2912.                     t = rs.getTimestamp("ORA_REGISTRAZIONE");
  2913.                 }
  2914.                 rs.close();
  2915.                 pstmtRead.close();

  2917.                 if(t==null)
  2918.                     throw new Exception("Ora registrazione non registrata");
  2919.                 return t;

  2921.             } catch(Exception e) {
  2922.                 String errorMsg = "GESTORE_MESSAGGI, Errore getOraRegistrazioneMessaggio "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  2923.                 try{
  2924.                     if(rs != null)
  2925.                         rs.close();
  2926.                 } catch(Exception er) {
  2927.                     // close
  2928.                 }
  2929.                 try{
  2930.                     if(pstmtRead != null)
  2931.                         pstmtRead.close();
  2932.                 } catch(Exception er) {
  2933.                     // close
  2934.                 }
  2935.                 this.log.error(errorMsg,e);
  2936.                 throw new GestoreMessaggiException(errorMsg,e);
  2937.             }

  2939.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){

  2941.             if (this.isRichiesta) 
  2942.                 t = ((OpenSPCoopStateless)this.openspcoopstate).getTempiAttraversamentoPDD().getRicezioneMsgIngresso();
  2943.             else 
  2944.                 t = ((OpenSPCoopStateless)this.openspcoopstate).getTempiAttraversamentoPDD().getRicezioneMsgRisposta();

  2946.             if (t == null) throw new GestoreMessaggiException("Ora registrazione non registrata");

  2948.             return t;

  2950.         }else{
  2951.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  2952.         }
  2953.     }

  2955.     public Timestamp getDataRispedizioneMessaggio() throws GestoreMessaggiException{

  2957.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  2958.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  2959.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  2960.             Connection connectionDB = stateful.getConnectionDB();
  2961.             PreparedStatement pstmtRead = null;
  2962.             ResultSet rs = null; 
  2963.             try{    
  2964.                 // Costruzione Query
  2965.                 String query = "SELECT RISPEDIZIONE FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";

  2967.                 //log.debug("Query: "+query);
  2968.                 pstmtRead = connectionDB.prepareStatement(query);
  2969.                 pstmtRead.setString(1,this.idBusta);
  2970.                 pstmtRead.setString(2,this.tipo);

  2972.                 rs = pstmtRead.executeQuery();
  2973.                 Timestamp t = null;
  2974.                 if(rs.next()){
  2975.                     t = rs.getTimestamp("RISPEDIZIONE");
  2976.                 }
  2977.                 rs.close();
  2978.                 pstmtRead.close();

  2980.                 if(t==null)
  2981.                     throw new Exception("Ora rispedizione non registrata");
  2982.                 return t;

  2984.             } catch(Exception e) {
  2985.                 String errorMsg = "GESTORE_MESSAGGI, Errore getDataRispedizioneMessaggio "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  2986.                 try{
  2987.                     if(rs != null)
  2988.                         rs.close();
  2989.                 } catch(Exception er) {
  2990.                     // close
  2991.                 }
  2992.                 try{
  2993.                     if(pstmtRead != null)
  2994.                         pstmtRead.close();
  2995.                 } catch(Exception er) {
  2996.                     // close
  2997.                 }
  2998.                 this.log.error(errorMsg,e);
  2999.                 throw new GestoreMessaggiException(errorMsg,e);
  3000.             }
  3001.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3002.             //          //TODO Metodo stateful only
  3003.             //          return null;
  3004.             // do the right thing
  3005.         }else{
  3006.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3007.         }
  3008.     }

  3010.     /**
  3011.      * Controlla se il msg deve essere riconsegnato.
  3012.      *
  3013.      * @return true se la data di riconsegna del msg e' scaduta
  3014.      * 
  3015.      */
  3016.     public boolean isPrimaConsegna(String servizioApplicativo) throws GestoreMessaggiException{
  3017.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || (this.oneWayVersione11) ) {
  3018.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  3019.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  3020.             Connection connectionDB = stateMSG.getConnectionDB();
  3021.             PreparedStatement pstmtRead = null;
  3022.             ResultSet rs = null; 
  3023.             try{    

  3025.                 // Costruzione Query
  3026.                 String query = null;
  3027.                 if(servizioApplicativo==null)
  3028.                     query = "SELECT "+GestoreMessaggi.MESSAGGI+".RISPEDIZIONE,"+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";
  3029.                 else
  3030.                     query = "SELECT "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".RISPEDIZIONE,"+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE FROM "
  3031.                             +GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+","+GestoreMessaggi.MESSAGGI+" WHERE "
  3032.                             +GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO="+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO AND "+
  3033.                             ""+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO= ? AND "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO=? AND "+GestoreMessaggi.MESSAGGI+".TIPO=?";

  3035.                 //log.debug("Query: "+query);
  3036.                 pstmtRead = connectionDB.prepareStatement(query);
  3037.                 pstmtRead.setString(1,this.idBusta);
  3038.                 if(servizioApplicativo!=null){
  3039.                     pstmtRead.setString(2,servizioApplicativo);
  3040.                     pstmtRead.setString(3, Costanti.INBOX);
  3041.                 }
  3042.                 else
  3043.                     pstmtRead.setString(2,this.tipo);

  3045.                 rs = pstmtRead.executeQuery();
  3046.                 Timestamp oraRegistrazione = null;
  3047.                 Timestamp rispedizione = null;
  3048.                 if(rs.next()){
  3049.                     oraRegistrazione = rs.getTimestamp("ORA_REGISTRAZIONE");
  3050.                     rispedizione = rs.getTimestamp("RISPEDIZIONE");
  3051.                 }
  3052.                 rs.close();
  3053.                 pstmtRead.close();

  3055.                 //this.log.debug("[isPrimaConsegna] MSG["+this.tipo+"/"+this.ididBusta+"] ORA_REGISTRAZIONE["+oraRegistrazione.toString()+"] RISPEDIZIONE["+rispedizione.toString()+"]");

  3057.                 if(oraRegistrazione==null)
  3058.                     this.log.error("OraRegistrazione is null");
  3059.                 if(rispedizione==null)
  3060.                     this.log.error("Rispedizione is null");

  3062.                 return  oraRegistrazione!=null && rispedizione!=null && (oraRegistrazione.compareTo(rispedizione) == 0) ;

  3064.             } catch(Exception e) {
  3065.                 String errorMsg = "GESTORE_MESSAGGI, Errore isPrimaConsegna "+this.tipo+"/"+this.idBusta+" sa["+servizioApplicativo+"]: "+e.getMessage();       
  3066.                 try{
  3067.                     if(rs != null)
  3068.                         rs.close();
  3069.                 } catch(Exception er) {
  3070.                     // close
  3071.                 }
  3072.                 try{
  3073.                     if(pstmtRead != null)
  3074.                         pstmtRead.close();
  3075.                 } catch(Exception er) {
  3076.                     // close
  3077.                 }
  3078.                 this.log.error(errorMsg,e);
  3079.                 throw new GestoreMessaggiException(errorMsg,e);
  3080.             }
  3081.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3082.             //          //TODO Metodo stateful only
  3083.             //          return null;
  3084.             // do the right thing
  3085.         }else{
  3086.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3087.         }
  3088.     }

  3090.     /**
  3091.      * Controlla se il msg deve essere riconsegnato.
  3092.      *
  3093.      * @return true se la data di riconsegna del msg e' scaduta
  3094.      * 
  3095.      */
  3096.     public boolean isRiconsegnaMessaggio(String servizioApplicativo) throws GestoreMessaggiException{

  3098.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || (this.oneWayVersione11) ) {
  3099.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  3100.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  3101.             Connection connectionDB = stateMSG.getConnectionDB();
  3102.             if(this.isPrimaConsegna(servizioApplicativo))
  3103.                 return true; 

  3105.             PreparedStatement pstmt = null;
  3106.             ResultSet rs = null;
  3107.             try{    
  3108.                 // Costruzione Query
  3109.                 StringBuilder bf = new StringBuilder();
  3110.                 bf.append("SELECT RISPEDIZIONE FROM ");
  3111.                 if(servizioApplicativo!=null)
  3112.                     bf.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  3113.                 else
  3114.                     bf.append(GestoreMessaggi.MESSAGGI);
  3115.                 bf.append(" WHERE ID_MESSAGGIO=?");
  3116.                 if(servizioApplicativo!=null)
  3117.                     bf.append(" AND SERVIZIO_APPLICATIVO=?");
  3118.                 else
  3119.                     bf.append(" AND TIPO=?");
  3120.                 //log.debug("Query: "+query);
  3121.                 pstmt = connectionDB.prepareStatement(bf.toString());
  3122.                 pstmt.setString(1,this.idBusta);
  3123.                 if(servizioApplicativo!=null)
  3124.                     pstmt.setString(2,servizioApplicativo);
  3125.                 else
  3126.                     pstmt.setString(2,this.tipo);
  3127.                 rs = pstmt.executeQuery();
  3128.                 java.sql.Timestamp riconsegna = null;
  3129.                 if(rs.next()){
  3130.                     riconsegna = rs.getTimestamp("RISPEDIZIONE");
  3131.                 }
  3132.                 rs.close();
  3133.                 pstmt.close();

  3135.                 java.sql.Timestamp now = DateManager.getTimestamp();

  3137.                 //this.log.debug("[isRiconsegnaMessaggio] MSG["+this.tipo+"/"+this.idBusta+"] NOW["+now.toString()+"] RISPEDIZIONE["+riconsegna.toString()+"]");


  3140.                 // Eventuale msg Scaduto.
  3141.                 if(riconsegna==null){
  3142.                     //return false;
  3143.                     // Ritorno false, almeno la riconsegna viene riprovata dopo un po'...
  3144.                     // Il valore della riconsegna era null, poiche' il messaggio non era presente. Al prossimo giro l'algoritmo di TransactionManager
  3145.                     // Rendera' invalido il messaggio.
  3146.                     this.log.error("Calcolo riconsegna non riuscito ["+this.tipo+"/"+this.idBusta+"], riconsegna is null? query["+bf.toString()+"] sa["+servizioApplicativo+"]");
  3147.                     throw new Exception("Calcolo riconsegna non riuscito ["+this.tipo+"/"+this.idBusta+"]");
  3148.                 }


  3151.                 if (riconsegna.before(now)) 
  3152.                     return true;
  3153.                 else{
  3154.                     this.log.debug("Riconsegna messaggio prematura ["+this.tipo+"/"+this.idBusta+"] RICONSEGNA["+riconsegna.toString()+"] < NOW["+now.toString()+"] == false");
  3155.                     return false;
  3156.                 }

  3158.             } catch(Exception e) {
  3159.                 String errorMsg = "GESTORE_MESSAGGI, Errore isRiconsegnaMessaggio "+this.tipo+"/"+this.idBusta+": "+e.getMessage();     
  3160.                 try{
  3161.                     if(rs != null)
  3162.                         rs.close();
  3163.                 } catch(Exception er) {
  3164.                     // close
  3165.                 }
  3166.                 try{
  3167.                     if(pstmt != null)
  3168.                         pstmt.close();
  3169.                 } catch(Exception er) {
  3170.                     // close
  3171.                 }
  3172.                 this.log.error(errorMsg,e);
  3173.                 throw new GestoreMessaggiException(errorMsg,e);
  3174.             }   
  3175.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3176.             return true;
  3177.         }else{
  3178.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3179.         }
  3180.     }

  3182.     /**
  3183.      * Ritorna il riferimento messaggio associato al messaggio gestito da OpenSPCoop. 
  3184.      *
  3185.      * @return il riferimento messaggio associato al messaggio
  3186.      * 
  3187.      */
  3188.     public String getRiferimentoMessaggio() throws GestoreMessaggiException{
  3189.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3190.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3191.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  3192.             Connection connectionDB = stateful.getConnectionDB();
  3193.             PreparedStatement pstmt = null;
  3194.             ResultSet rs = null;
  3195.             try{    
  3196.                 // Costruzione Query
  3197.                 String query = "SELECT RIFERIMENTO_MSG FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  3198.                 //log.debug("Query: "+query);
  3199.                 pstmt = connectionDB.prepareStatement(query);
  3200.                 pstmt.setString(1,this.idBusta);
  3201.                 pstmt.setString(2,this.tipo);
  3202.                 rs = pstmt.executeQuery();
  3203.                 String value = null;
  3204.                 if(rs.next()){
  3205.                     value = rs.getString("RIFERIMENTO_MSG");
  3206.                 }
  3207.                 rs.close();
  3208.                 pstmt.close();

  3210.                 return value;

  3212.             } catch(Exception e) {
  3213.                 String errorMsg = "GESTORE_MESSAGGI, Errore get RIFERIMENTO_MSG "+this.tipo+"/"+this.idBusta+": "+e.getMessage();       
  3214.                 try{
  3215.                     if(rs != null)
  3216.                         rs.close();
  3217.                 } catch(Exception er) {
  3218.                     // close
  3219.                 }
  3220.                 try{
  3221.                     if(pstmt != null)
  3222.                         pstmt.close();
  3223.                 } catch(Exception er) {
  3224.                     // close
  3225.                 }
  3226.                 this.log.error(errorMsg,e);
  3227.                 throw new GestoreMessaggiException(errorMsg,e);
  3228.             }   
  3229.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3230.             //          //TODO Metodo stateful only
  3231.             //          return null;
  3232.             // do the right thing
  3233.         }else{
  3234.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3235.         }
  3236.     }

  3238.     public String getIDCorrelazioneApplicativa() throws GestoreMessaggiException{

  3240.         String id = null;

  3242.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3243.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3244.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  3246.             Connection connectionDB = stateful.getConnectionDB();

  3248.             PreparedStatement pstmtRead = null;
  3249.             ResultSet rs = null; 
  3250.             try{    
  3251.                 // Costruzione Query
  3252.                 String query = "SELECT CORRELAZIONE_APPLICATIVA FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";

  3254.                 //log.debug("Query: "+query);
  3255.                 pstmtRead = connectionDB.prepareStatement(query);
  3256.                 pstmtRead.setString(1,this.idBusta);
  3257.                 pstmtRead.setString(2,this.tipo);

  3259.                 rs = pstmtRead.executeQuery();
  3260.                 if(rs.next()){
  3261.                     id = rs.getString("CORRELAZIONE_APPLICATIVA");
  3262.                 }
  3263.                 rs.close();
  3264.                 pstmtRead.close();

  3266.                 if(id==null)
  3267.                     throw new Exception("ID di CorrelazioneApplicativa non registrata");
  3268.                 return id;

  3270.             } catch(Exception e) {
  3271.                 String errorMsg = "GESTORE_MESSAGGI, Errore getIDCorrelazioneApplicativa "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  3272.                 try{
  3273.                     if(rs != null)
  3274.                         rs.close();
  3275.                 } catch(Exception er) {
  3276.                     // close
  3277.                 }
  3278.                 try{
  3279.                     if(pstmtRead != null)
  3280.                         pstmtRead.close();
  3281.                 } catch(Exception er) {
  3282.                     // close
  3283.                 }
  3284.                 if(!e.getMessage().equals("ID di CorrelazioneApplicativa non registrata"))
  3285.                     this.log.error(errorMsg,e);
  3286.                 else
  3287.                     this.log.debug(errorMsg);
  3288.                 throw new GestoreMessaggiException(errorMsg,e);
  3289.             }

  3291.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){

  3293.             return ((OpenSPCoopStateless)this.openspcoopstate).getIDCorrelazioneApplicativa();

  3295.         }else{
  3296.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3297.         }
  3298.     }

  3300.     public String getIDCorrelazioneApplicativaRisposta() throws GestoreMessaggiException{

  3302.         String id = null;

  3304.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3305.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3306.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  3308.             Connection connectionDB = stateful.getConnectionDB();

  3310.             PreparedStatement pstmtRead = null;
  3311.             ResultSet rs = null; 
  3312.             try{    
  3313.                 // Costruzione Query
  3314.                 String query = "SELECT CORRELAZIONE_RISPOSTA FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";

  3316.                 //log.debug("Query: "+query);
  3317.                 pstmtRead = connectionDB.prepareStatement(query);
  3318.                 pstmtRead.setString(1,this.idBusta);
  3319.                 pstmtRead.setString(2,this.tipo);

  3321.                 rs = pstmtRead.executeQuery();
  3322.                 if(rs.next()){
  3323.                     id = rs.getString("CORRELAZIONE_RISPOSTA");
  3324.                 }
  3325.                 rs.close();
  3326.                 pstmtRead.close();

  3328.                 if(id==null)
  3329.                     throw new Exception("ID di CorrelazioneApplicativaRisposta non registrata");
  3330.                 return id;

  3332.             } catch(Exception e) {
  3333.                 String errorMsg = "GESTORE_MESSAGGI, Errore getIDCorrelazioneApplicativaRisposta "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  3334.                 try{
  3335.                     if(rs != null)
  3336.                         rs.close();
  3337.                 } catch(Exception er) {
  3338.                     // close
  3339.                 }
  3340.                 try{
  3341.                     if(pstmtRead != null)
  3342.                         pstmtRead.close();
  3343.                 } catch(Exception er) {
  3344.                     // close
  3345.                 }
  3346.                 if(!e.getMessage().equals("ID di CorrelazioneApplicativaRisposta non registrata")){
  3347.                     this.log.error(errorMsg,e);
  3348.                     throw new GestoreMessaggiException(errorMsg,e);
  3349.                 }
  3350.                 else{
  3351.                     this.log.debug(errorMsg);
  3352.                     return null;
  3353.                 }
  3354.             }

  3356.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){

  3358.             return ((OpenSPCoopStateless)this.openspcoopstate).getIDCorrelazioneApplicativaRisposta();

  3360.         }else{
  3361.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3362.         }
  3363.     }

  3365.     public PdDContext getPdDContext() throws GestoreMessaggiException{
  3366.         return this.getPdDContext(false);
  3367.     }
  3368.     public PdDContext getPdDContext(boolean saveInInstance) throws GestoreMessaggiException{

  3370.         if(this.openspcoopstate==null) {
  3371.             return this.pddContext;
  3372.         }
  3373.         
  3374.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3375.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3376.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  3378.             Connection connectionDB = stateful.getConnectionDB();

  3380.             PreparedStatement pstmtRead = null;
  3381.             ResultSet rs = null; 
  3382.             try{    

  3384.                 // PdDContext
  3385.                 StringBuilder fieldNamesPdDContext_db = new StringBuilder();
  3386.                 Map<String, String> mapping = new HashMap<>();
  3387.                 if(GestoreMessaggi.pddContextSerializer!=null){
  3388.                     Map<String, String> contextSerializerParameters = GestoreMessaggi.pddContextSerializer.getGestoreMessaggiKeywords();
  3389.                     if(contextSerializerParameters!=null && contextSerializerParameters.size()>0){
  3390.                         for (String keyword : contextSerializerParameters.keySet()) {
  3391.                             if(fieldNamesPdDContext_db.length()>0)
  3392.                                 fieldNamesPdDContext_db.append(" , ");
  3393.                             String nomeDB = contextSerializerParameters.get(keyword);
  3394.                             fieldNamesPdDContext_db.append(nomeDB);
  3395.                             mapping.put(nomeDB, keyword);
  3396.                         }
  3397.                     }
  3398.                 }
  3399.                 if(fieldNamesPdDContext_db.length() != 0) 
  3400.                     fieldNamesPdDContext_db.append(" , ");
  3401.                 fieldNamesPdDContext_db.append("PROTOCOLLO");
  3402.                 mapping.put("PROTOCOLLO", org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME.getValue());
  3403.                 PdDContext pddContext = new PdDContext();
  3404.                 if(mapping.size()<=0){
  3405.                     return pddContext;
  3406.                 }

  3408.                 // Costruzione Query
  3409.                 String query = "SELECT id_transazione, "+fieldNamesPdDContext_db.toString()+" FROM "+GestoreMessaggi.MESSAGGI+" WHERE ID_MESSAGGIO = ? AND TIPO=?";

  3411.                 //log.debug("Query: "+query);
  3412.                 pstmtRead = connectionDB.prepareStatement(query);
  3413.                 pstmtRead.setString(1,this.idBusta);
  3414.                 pstmtRead.setString(2,this.tipo);

  3416.                 rs = pstmtRead.executeQuery();
  3417.                 if(rs.next()){

  3419.                     for (String keyDB : mapping.keySet()) {
  3420.                         Object object = rs.getObject(keyDB);
  3421.                         String key = mapping.get(keyDB);
  3422.                         MapKey<String> mapKey = org.openspcoop2.utils.Map.newMapKey(key);
  3423.                         pddContext.addObject(mapKey, object);
  3424.                     }
  3425.                     
  3426.                     String idTransazione = rs.getString("id_transazione");
  3427.                     if(idTransazione!=null) {
  3428.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  3429.                     }

  3431.                 }else{
  3432.                     throw new Exception("Messaggio non trovato");
  3433.                 }
  3434.                 rs.close();
  3435.                 pstmtRead.close();

  3437.                 if(saveInInstance) {
  3438.                     this.pddContext = pddContext;
  3439.                 }
  3440.                 return pddContext;

  3442.             } catch(Exception e) {
  3443.                 String errorMsg = "GESTORE_MESSAGGI, Errore getPdDContext "+this.tipo+"/"+this.idBusta+": "+e.getMessage();     
  3444.                 try{
  3445.                     if(rs != null)
  3446.                         rs.close();
  3447.                 } catch(Exception er) {
  3448.                     // close
  3449.                 }
  3450.                 try{
  3451.                     if(pstmtRead != null)
  3452.                         pstmtRead.close();
  3453.                 } catch(Exception er) {
  3454.                     // close
  3455.                 }
  3456.                 if(!e.getMessage().equals("Messaggio non trovato"))
  3457.                     this.log.error(errorMsg,e);
  3458.                 else
  3459.                     this.log.debug(errorMsg,e);
  3460.                 throw new GestoreMessaggiException(errorMsg,e);
  3461.             }

  3463.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){

  3465.             return ((OpenSPCoopStateless)this.openspcoopstate).getPddContext();

  3467.         }else{
  3468.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3469.         }
  3470.     }











  3482.     /* ********  R E A D    M E S S A G E   (Destinato ad un SIL)  ******** */

  3484.     /**
  3485.      * Controlla l'esistenza di un messaggio gestito da OpenSPCoop, il quale e' stato associato ad un servizio applicativo. 
  3486.      *
  3487.      * @param servizioApplicativo Servizio Applicativo
  3488.      * @return true se il messaggio esiste
  3489.      * 
  3490.      */
  3491.     public MessaggioIM readMessageForSIL(String servizioApplicativo, Date oraRegistrazione)throws GestoreMessaggiException{
  3492.         return readMessageForSIL(servizioApplicativo,false,oraRegistrazione);
  3493.     }
  3494.     /**
  3495.      * Controlla l'esistenza di un messaggio gestito da OpenSPCoop, il quale e' stato associato ad un servizio applicativo. 
  3496.      *
  3497.      * @param servizioApplicativo Servizio Applicativo
  3498.      * @param searchForRiferimentoMsg Se true, il messaggio viene ricercato per Riferimento Messaggio
  3499.      * @return true se il messaggio esiste
  3500.      * 
  3501.      */
  3502.     public MessaggioIM readMessageForSIL(String servizioApplicativo,boolean searchForRiferimentoMsg, Date oraRegistrazione)throws GestoreMessaggiException{
  3503.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3504.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3505.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  3506.             Connection connectionDB = stateful.getConnectionDB();
  3507.             PreparedStatement pstmt = null;
  3508.             ResultSet rs = null;
  3509.             try{    

  3511.                 // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  3512.                 // come riferimento Messaggio l'ID del gestore.
  3513.                 // In caso di esistenza uso l'idBusta del messaggio trovato e non quello del gestore
  3514.                 String idBustaSearch = this.idBusta;
  3515.                 if(searchForRiferimentoMsg){
  3516.                     idBustaSearch = mapRiferimentoIntoIDBusta();
  3517.                 }

  3519.                 // Ricerco messaggio assiciato
  3520.                 String query = null;
  3521.                 if(Configurazione.getSqlQueryObjectType()==null){
  3522.                     query = "SELECT "+
  3523.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".INTEGRATION_MANAGER as authIM, "+
  3524.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SBUSTAMENTO_SOAP as sbSoap, "+
  3525.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SBUSTAMENTO_INFO_PROTOCOL as sbProtocol "+
  3526.                             GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG as rifMsg, "+
  3527.                             GestoreMessaggi.MESSAGGI+".id_transazione as idtransazione, "+
  3528.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO as sa, "+
  3529.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".NOME_PORTA as nomePorta, "+
  3530.                             GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE as oramess "+
  3531.                             " FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+","+GestoreMessaggi.MESSAGGI+
  3532.                             " WHERE ";
  3533.                     if(oraRegistrazione!=null) {
  3534.                         query = query + "("+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ORA_REGISTRAZIONE BETWEEN ? AND ?) AND ";
  3535.                         query = query + "("+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE BETWEEN ? AND ?) AND ";
  3536.                     }
  3537.                     query = query + GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO=? AND " +
  3538.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO=? AND "+
  3539.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO="+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO AND "+
  3540.                             GestoreMessaggi.MESSAGGI+".PROPRIETARIO=?";
  3541.                 }
  3542.                 else {
  3543.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  3544.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI,"m");
  3545.                     sqlQueryObject.addFromTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"sa");
  3546.                     
  3547.                     sqlQueryObject.addSelectAliasField("sa", "INTEGRATION_MANAGER", "authIM");
  3548.                     sqlQueryObject.addSelectAliasField("sa", "SBUSTAMENTO_SOAP", "sbSoap");
  3549.                     sqlQueryObject.addSelectAliasField("sa", "SBUSTAMENTO_INFO_PROTOCOL", "sbProtocol");
  3550.                     sqlQueryObject.addSelectAliasField("m", "RIFERIMENTO_MSG", "rifMsg");
  3551.                     sqlQueryObject.addSelectAliasField("m", "id_transazione", "idtransazione");
  3552.                     sqlQueryObject.addSelectAliasField("sa", "SERVIZIO_APPLICATIVO", "sa");
  3553.                     sqlQueryObject.addSelectAliasField("sa", "NOME_PORTA", "nomePorta");
  3554.                     sqlQueryObject.addSelectAliasField("m", "ORA_REGISTRAZIONE", "oramess");
  3555.                     
  3556.                     if(oraRegistrazione!=null) {
  3557.                         sqlQueryObject.addWhereBetweenCondition("sa.ORA_REGISTRAZIONE", false, "?", "?");
  3558.                         sqlQueryObject.addWhereBetweenCondition("m.ORA_REGISTRAZIONE", false, "?", "?");
  3559.                     }
  3560.                                         
  3561.                     sqlQueryObject.addWhereCondition("sa.ID_MESSAGGIO=?");
  3562.                     sqlQueryObject.addWhereCondition("sa.SERVIZIO_APPLICATIVO=?");
  3563.                     
  3564.                     // join
  3565.                     sqlQueryObject.addWhereCondition("m.ID_MESSAGGIO=sa.ID_MESSAGGIO");
  3566.                     
  3567.                     sqlQueryObject.addWhereCondition("m.PROPRIETARIO=?");
  3568.                     
  3569.                     sqlQueryObject.setANDLogicOperator(true);
  3570.                     
  3571.                     query = sqlQueryObject.createSQLQuery();
  3572.                 }
  3573.                 //log.debug("Query: "+query);
  3574.                 pstmt = connectionDB.prepareStatement(query);
  3575.                 int index = 1;
  3576.                 
  3577.                 Timestamp leftValue = null;
  3578.                 Timestamp rightValue = null;
  3579.                 if(oraRegistrazione!=null) {
  3580.                     leftValue = new Timestamp(oraRegistrazione.getTime() - (1000*60*5));
  3581.                     rightValue = new Timestamp(oraRegistrazione.getTime() + (1000*60*5));
  3582.                     pstmt.setTimestamp(index++,leftValue);
  3583.                     pstmt.setTimestamp(index++,rightValue);
  3584.                     pstmt.setTimestamp(index++,leftValue);
  3585.                     pstmt.setTimestamp(index++,rightValue);
  3586.                 }
  3587.                 
  3588.                 pstmt.setString(index++,idBustaSearch);
  3589.                 pstmt.setString(index++,servizioApplicativo);
  3590.                 pstmt.setString(index++,ConsegnaContenutiApplicativi.ID_MODULO);
  3591.                 rs = pstmt.executeQuery();
  3592.                 if(rs.next()==true){                
  3593.                     MessaggioIM messaggio = new MessaggioIM();
  3594.                     messaggio.setAuthorized(rs.getInt("authIM") == CostantiDB.TRUE);
  3595.                     messaggio.setSbustamentoSoap(rs.getInt("sbSoap") == CostantiDB.TRUE);
  3596.                     messaggio.setSbustamentoInformazioniProtocollo(rs.getInt("sbProtocol") == CostantiDB.TRUE);
  3597.                     messaggio.setRiferimentoMessaggio(rs.getString("rifMsg"));
  3598.                     messaggio.setIdentificativoRichiesta(idBustaSearch);
  3599.                     messaggio.setIdTransazione(rs.getString("idtransazione"));
  3600.                     messaggio.setServizioApplicativo(rs.getString("sa"));
  3601.                     messaggio.setOraRegistrazione(rs.getTimestamp("oramess"));
  3602.                     messaggio.setNomePorta(rs.getString("nomePorta"));
  3603.                     
  3604.                     rs.close();
  3605.                     pstmt.close();
  3606.                     
  3607.                     return messaggio;
  3608.                 }
  3609.                 rs.close();
  3610.                 pstmt.close();

  3612.                 return null;

  3614.             } catch(Exception e) {
  3615.                 String errorMsg = "GESTORE_MESSAGGI, error readMessageForSIL "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  3616.                 try{
  3617.                     if(rs != null)
  3618.                         rs.close();
  3619.                 } catch(Exception er) {
  3620.                     // close
  3621.                 }
  3622.                 try{
  3623.                     if(pstmt != null)
  3624.                         pstmt.close();
  3625.                 } catch(Exception er) {
  3626.                     // close
  3627.                 }
  3628.                 this.log.error(errorMsg,e);
  3629.                 throw new GestoreMessaggiException(errorMsg,e);
  3630.             }   
  3631.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3632.             //          //TODO Metodo stateful only
  3633.             //          return null;
  3634.             // do the right thing
  3635.         }else{
  3636.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3637.         }
  3638.     }
  3639.     
  3640.     
  3641.     
  3642.     
  3643.     
  3644.     /**
  3645.      * Controlla l'esistenza di un messaggio gestito da OpenSPCoop, il quale e' stato associato ad un servizio applicativo. 
  3646.      *
  3647.      * @param servizioApplicativo Servizio Applicativo
  3648.      * @return true se il messaggio esiste
  3649.      * 
  3650.      */
  3651.     public boolean existsMessageForSIL(String servizioApplicativo)throws GestoreMessaggiException{
  3652.         return existsMessageForSIL(servizioApplicativo,false);
  3653.     }
  3654.     /**
  3655.      * Controlla l'esistenza di un messaggio gestito da OpenSPCoop, il quale e' stato associato ad un servizio applicativo. 
  3656.      *
  3657.      * @param servizioApplicativo Servizio Applicativo
  3658.      * @param searchForRiferimentoMsg Se true, il messaggio viene ricercato per Riferimento Messaggio
  3659.      * @return true se il messaggio esiste
  3660.      * 
  3661.      */
  3662.     public boolean existsMessageForSIL(String servizioApplicativo,boolean searchForRiferimentoMsg)throws GestoreMessaggiException{
  3663.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3664.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3665.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  3666.             Connection connectionDB = stateful.getConnectionDB();
  3667.             PreparedStatement pstmt = null;
  3668.             ResultSet rs = null;
  3669.             try{    

  3671.                 // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  3672.                 // come riferimento Messaggio l'ID del gestore.
  3673.                 // In caso di esistenza uso l'idBusta del messaggio trovato e non quello del gestore
  3674.                 String idBustaSearch = this.idBusta;
  3675.                 if(searchForRiferimentoMsg){
  3676.                     idBustaSearch = mapRiferimentoIntoIDBusta();
  3677.                 }


  3680.                 // Ricerco messaggio assiciato
  3681.                 String query = "SELECT * FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+","+GestoreMessaggi.MESSAGGI+
  3682.                         " WHERE ";
  3683.                 query = query + GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO=? AND " +
  3684.                         GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO=? AND "+
  3685.                         GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO="+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO AND "+
  3686.                         GestoreMessaggi.MESSAGGI+".PROPRIETARIO=?";
  3687.                 //log.debug("Query: "+query);
  3688.                 pstmt = connectionDB.prepareStatement(query);
  3689.                 int index = 1;
  3690.                 pstmt.setString(index++,idBustaSearch);
  3691.                 pstmt.setString(index++,servizioApplicativo);
  3692.                 pstmt.setString(index++,ConsegnaContenutiApplicativi.ID_MODULO);
  3693.                 rs = pstmt.executeQuery();
  3694.                 if(rs.next()==true){
  3695.                     rs.close();
  3696.                     pstmt.close();
  3697.                     return true;
  3698.                 }
  3699.                 rs.close();
  3700.                 pstmt.close();

  3702.                 return false;

  3704.             } catch(Exception e) {
  3705.                 String errorMsg = "GESTORE_MESSAGGI, error existsMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  3706.                 try{
  3707.                     if(rs != null)
  3708.                         rs.close();
  3709.                 } catch(Exception er) {
  3710.                     // close
  3711.                 }
  3712.                 try{
  3713.                     if(pstmt != null)
  3714.                         pstmt.close();
  3715.                 } catch(Exception er) {
  3716.                     // close
  3717.                 }
  3718.                 this.log.error(errorMsg,e);
  3719.                 throw new GestoreMessaggiException(errorMsg,e);
  3720.             }   
  3721.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3722.             //          //TODO Metodo stateful only
  3723.             //          return null;
  3724.             // do the right thing
  3725.         }else{
  3726.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3727.         }
  3728.     }

  3730.     /**
  3731.      * Ritorna true se il servizio applicativo e' autorizzato ad utilizzare il servizio IntegrationManager
  3732.      * per ricevere il messaggio 
  3733.      *
  3734.      * @param servizioApplicativo Servizio Applicativo
  3735.      * @return Ritorna true se il servizio applicativo e' autorizzato ad utilizzare il servizio IntegrationManager
  3736.      * 
  3737.      */
  3738.     public boolean checkAutorizzazione(String servizioApplicativo)throws GestoreMessaggiException{
  3739.         return checkAutorizzazione(servizioApplicativo,false);
  3740.     }
  3741.     /**
  3742.      * Ritorna true se il servizio applicativo e' autorizzato ad utilizzare il servizio IntegrationManager
  3743.      * per ricevere il messaggio 
  3744.      *
  3745.      * @param servizioApplicativo Servizio Applicativo
  3746.      * @param searchForRiferimentoMsg Se true, il messaggio viene ricercato per Riferimento Messaggio
  3747.      * @return Ritorna true se il servizio applicativo e' autorizzato ad utilizzare il servizio IntegrationManager
  3748.      * 
  3749.      */
  3750.     public boolean checkAutorizzazione(String servizioApplicativo,boolean searchForRiferimentoMsg)throws GestoreMessaggiException{
  3751.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3752.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3753.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  3754.             Connection connectionDB = stateful.getConnectionDB();
  3755.             PreparedStatement pstmt = null;
  3756.             ResultSet rs = null;
  3757.             try{   
  3758.                 // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  3759.                 // come riferimento Messaggio l'ID del gestore.
  3760.                 // In caso di esistenza uso l'idBusta del messaggio trovato e non quello del gestore
  3761.                 String idBustaSearch = this.idBusta;
  3762.                 if(searchForRiferimentoMsg){
  3763.                     idBustaSearch = mapRiferimentoIntoIDBusta();
  3764.                 }


  3767.                 // Costruzione Query
  3768.                 String query = "SELECT INTEGRATION_MANAGER FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI
  3769.                         +" WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  3770.                 //log.debug("Query: "+query);
  3771.                 pstmt =  connectionDB.prepareStatement(query);
  3772.                 pstmt.setString(1,idBustaSearch);
  3773.                 pstmt.setString(2,servizioApplicativo);
  3774.                 rs = pstmt.executeQuery();
  3775.                 boolean auth = false;
  3776.                 if(rs.next()){
  3777.                     if( rs.getInt("INTEGRATION_MANAGER") == 1)
  3778.                         auth = true;
  3779.                 }
  3780.                 rs.close();
  3781.                 pstmt.close();

  3783.                 return auth;

  3785.             } catch(Exception e) {
  3786.                 String errorMsg = "GESTORE_MESSAGGI, error existsMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  3787.                 try{
  3788.                     if(rs != null)
  3789.                         rs.close();
  3790.                 } catch(Exception er) {
  3791.                     // close
  3792.                 }
  3793.                 try{
  3794.                     if(pstmt != null)
  3795.                         pstmt.close();
  3796.                 } catch(Exception er) {
  3797.                     // close
  3798.                 }
  3799.                 this.log.error(errorMsg,e);
  3800.                 throw new GestoreMessaggiException(errorMsg,e);
  3801.             }                   
  3802.             //}else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3803.             //          //TODO Metodo stateful only
  3804.             //          return null;
  3805.             // do the right thing
  3806.         }else{
  3807.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3808.         }
  3809.     }

  3811.     /**
  3812.      * Ritorna true se il servizio applicativo ha richiesto lo sbustamento per il messaggio a lui destinato
  3813.      *
  3814.      * @param servizioApplicativo Servizio Applicativo
  3815.      * @return Ritorna true se il servizio applicativo ha richiesto lo sbustamento soap
  3816.      * 
  3817.      */
  3818.     public boolean sbustamentoSOAP(String servizioApplicativo)throws GestoreMessaggiException{
  3819.         return sbustamentoSOAP(servizioApplicativo,false);
  3820.     }
  3821.     /**
  3822.      * Ritorna true se il servizio applicativo ha richiesto lo sbustamento per il messaggio a lui destinato
  3823.      *
  3824.      * @param servizioApplicativo Servizio Applicativo
  3825.      * @param searchForRiferimentoMsg Se true, il messaggio viene ricercato per Riferimento Messaggio
  3826.      * @return Ritorna true se il servizio applicativo ha richiesto lo sbustamento soap
  3827.      * 
  3828.      */
  3829.     public boolean sbustamentoSOAP(String servizioApplicativo,boolean searchForRiferimentoMsg)throws GestoreMessaggiException{
  3830.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3831.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3832.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  3833.             Connection connectionDB = stateful.getConnectionDB();
  3834.             PreparedStatement pstmt = null;
  3835.             ResultSet rs = null;
  3836.             try{
  3837.                 // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  3838.                 // come riferimento Messaggio l'ID del gestore.
  3839.                 // In caso di esistenza uso l'idBusta del messaggio trovato e non quello del gestore
  3840.                 String idBustaSearch = this.idBusta;
  3841.                 if(searchForRiferimentoMsg){
  3842.                     idBustaSearch = mapRiferimentoIntoIDBusta();
  3843.                 }


  3846.                 // Costruzione Query
  3847.                 String query = "SELECT SBUSTAMENTO_SOAP FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI
  3848.                         +" WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  3849.                 //log.debug("Query: "+query);
  3850.                 pstmt =  connectionDB.prepareStatement(query);
  3851.                 pstmt.setString(1,idBustaSearch);
  3852.                 pstmt.setString(2,servizioApplicativo);
  3853.                 rs = pstmt.executeQuery();
  3854.                 boolean sbustamento = false;
  3855.                 if(rs.next()){
  3856.                     if( rs.getInt("SBUSTAMENTO_SOAP") == 1)
  3857.                         sbustamento = true;
  3858.                 }
  3859.                 rs.close();
  3860.                 pstmt.close();

  3862.                 return sbustamento;

  3864.             } catch(Exception e) {
  3865.                 String errorMsg = "GESTORE_MESSAGGI, error getSbustamentoSoap "+this.tipo+"/"+this.idBusta+": "+e.getMessage();     
  3866.                 try{
  3867.                     if(rs != null)
  3868.                         rs.close();
  3869.                 } catch(Exception er) {
  3870.                     // close
  3871.                 }
  3872.                 try{
  3873.                     if(pstmt != null)
  3874.                         pstmt.close();
  3875.                 } catch(Exception er) {
  3876.                     // close
  3877.                 }
  3878.                 this.log.error(errorMsg,e);
  3879.                 throw new GestoreMessaggiException(errorMsg,e);
  3880.             }       
  3881.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3882.             //          //TODO Metodo stateful only
  3883.             //          return null;
  3884.             // do the right thing
  3885.         }else{
  3886.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3887.         }
  3888.     }

  3890.     /**
  3891.      * Ritorna true se il servizio applicativo ha richiesto lo sbustamento per il messaggio a lui destinato
  3892.      *
  3893.      * @param servizioApplicativo Servizio Applicativo
  3894.      * @return Ritorna true se il servizio applicativo ha richiesto lo sbustamento soap
  3895.      * 
  3896.      */
  3897.     public boolean sbustamentoInformazioniProtocollo(String servizioApplicativo)throws GestoreMessaggiException{
  3898.         return sbustamentoInformazioniProtocollo(servizioApplicativo,false);
  3899.     }
  3900.     /**
  3901.      * Ritorna true se il servizio applicativo ha richiesto lo sbustamento per il messaggio a lui destinato
  3902.      *
  3903.      * @param servizioApplicativo Servizio Applicativo
  3904.      * @param searchForRiferimentoMsg Se true, il messaggio viene ricercato per Riferimento Messaggio
  3905.      * @return Ritorna true se il servizio applicativo ha richiesto lo sbustamento soap
  3906.      * 
  3907.      */
  3908.     public boolean sbustamentoInformazioniProtocollo(String servizioApplicativo,boolean searchForRiferimentoMsg)throws GestoreMessaggiException{
  3909.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  3910.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  3911.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  3912.             Connection connectionDB = stateful.getConnectionDB();
  3913.             PreparedStatement pstmt = null;
  3914.             ResultSet rs = null;
  3915.             try{
  3916.                 // Se devo cercare per riferimentoMessaggio, prima cerco un messaggio registrato, che possiede
  3917.                 // come riferimento Messaggio l'ID del gestore.
  3918.                 // In caso di esistenza uso l'idBusta del messaggio trovato e non quello del gestore
  3919.                 String idBustaSearch = this.idBusta;
  3920.                 if(searchForRiferimentoMsg){
  3921.                     idBustaSearch = mapRiferimentoIntoIDBusta();
  3922.                 }


  3925.                 // Costruzione Query
  3926.                 String query = "SELECT SBUSTAMENTO_INFO_PROTOCOL FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI
  3927.                         +" WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  3928.                 //log.debug("Query: "+query);
  3929.                 pstmt =  connectionDB.prepareStatement(query);
  3930.                 pstmt.setString(1,idBustaSearch);
  3931.                 pstmt.setString(2,servizioApplicativo);
  3932.                 rs = pstmt.executeQuery();
  3933.                 boolean sbustamento = false;
  3934.                 if(rs.next()){
  3935.                     if( rs.getInt("SBUSTAMENTO_INFO_PROTOCOL") == 1)
  3936.                         sbustamento = true;
  3937.                 }
  3938.                 rs.close();
  3939.                 pstmt.close();

  3941.                 return sbustamento;

  3943.             } catch(Exception e) {
  3944.                 String errorMsg = "GESTORE_MESSAGGI, error getSbustamentoSoap "+this.tipo+"/"+this.idBusta+": "+e.getMessage();     
  3945.                 try{
  3946.                     if(rs != null)
  3947.                         rs.close();
  3948.                 } catch(Exception er) {
  3949.                     // close
  3950.                 }
  3951.                 try{
  3952.                     if(pstmt != null)
  3953.                         pstmt.close();
  3954.                 } catch(Exception er) {
  3955.                     // close
  3956.                 }
  3957.                 this.log.error(errorMsg,e);
  3958.                 throw new GestoreMessaggiException(errorMsg,e);
  3959.             }       
  3960.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  3961.             //          //TODO Metodo stateful only
  3962.             //          return null;
  3963.             // do the right thing
  3964.         }else{
  3965.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  3966.         }
  3967.     }

  3969.     /**
  3970.      * Ritorna true se il messaggio risulta in gestione
  3971.      *
  3972.      * @return true se il  messaggio risulta in gestione
  3973.      * @throws GestoreMessaggiException 
  3974.      * 
  3975.      */
  3976.     public boolean existsMessageInProcessamento() throws GestoreMessaggiException{
  3977.         return this.existsMessageInProcessamento(false);
  3978.     }

  3980.     /**
  3981.      * Ritorna true se il messaggio con quel riferimento messaggio risulta in gestione
  3982.      *
  3983.      * @return true se il  messaggio con quel riferimento messaggio risulta in gestione
  3984.      * @throws GestoreMessaggiException 
  3985.      * 
  3986.      */
  3987.     public boolean existsMessageInProcessamentoByReference() throws GestoreMessaggiException{
  3988.         return this.existsMessageInProcessamento(true);
  3989.     }

  3991.     /**
  3992.      * Ritorna true se il messaggio risulta in gestione
  3993.      *
  3994.      * @return true se il  messaggio risulta in gestione
  3995.      * @throws GestoreMessaggiException 
  3996.      * 
  3997.      */
  3998.     private boolean existsMessageInProcessamento(boolean rifMsg) throws GestoreMessaggiException{
  3999.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  4000.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  4001.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  4002.             Connection connectionDB = stateful.getConnectionDB();
  4003.             PreparedStatement pstmt = null;
  4004.             ResultSet rs = null; 
  4005.             try{    
  4006.                 // Costruzione Query
  4007.                 StringBuilder bf = new StringBuilder();
  4008.                 bf.append("SELECT ID_MESSAGGIO FROM ");
  4009.                 bf.append(GestoreMessaggi.MESSAGGI);
  4010.                 bf.append(" WHERE ");
  4011.                 if(!rifMsg){
  4012.                     bf.append("ID_MESSAGGIO=?");
  4013.                 }else{
  4014.                     bf.append("RIFERIMENTO_MSG=?");
  4015.                 }
  4016.                 bf.append(" AND TIPO=? AND PROPRIETARIO<>?");
  4017.                 //log.debug("Query: "+query);
  4018.                 pstmt = connectionDB.prepareStatement(bf.toString());
  4019.                 pstmt.setString(1,this.idBusta);
  4020.                 pstmt.setString(2,this.tipo);
  4021.                 pstmt.setString(3,TimerGestoreMessaggi.ID_MODULO);
  4022.                 rs = pstmt.executeQuery();
  4023.                 if(rs.next()){
  4024.                     rs.close();
  4025.                     pstmt.close();
  4026.                     return true;
  4027.                 }
  4028.                 rs.close();
  4029.                 pstmt.close();
  4030.                 return false;

  4032.             } catch(Exception e) {
  4033.                 String errorMsg = "GESTORE_MESSAGGI, Errore existsMessageInProcessamento "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  4034.                 try{
  4035.                     if(rs != null)
  4036.                         rs.close();
  4037.                 } catch(Exception er) {
  4038.                     // close
  4039.                 }
  4040.                 try{
  4041.                     if(pstmt != null)
  4042.                         pstmt.close();
  4043.                 } catch(Exception er) {
  4044.                     // close
  4045.                 }
  4046.                 this.log.error(errorMsg,e);
  4047.                 return false;
  4048.             }
  4049.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  4050.             //          //TODO Metodo stateful only
  4051.             //          return null;
  4052.             // do the right thing
  4053.         }else{
  4054.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  4055.         }
  4056.     }

















  4074.     /* ********  GET ID MESSAGGI DESTINATI AD UN SERVIZIO APPLICATIVO   ******** */

  4076.     /**
  4077.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo
  4078.      *
  4079.      * @param servizioApplicativo Servizio Applicativo
  4080.      * @return ID dei messaggi destinati ad un servizio applicativo
  4081.      * 
  4082.      */
  4083.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo)throws GestoreMessaggiException{

  4085.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, -1, -1, null, null, null);

  4087.     }


  4090.     /**
  4091.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo
  4092.      *
  4093.      * @param servizioApplicativo Servizio Applicativo
  4094.      * @param counter Indica il numero di id da ritornare
  4095.      * @return ID dei messaggi destinati ad un servizio applicativo
  4096.      * 
  4097.      */
  4098.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,int counter)throws GestoreMessaggiException{

  4100.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, counter, -1, null, null, null);

  4102.     }

  4104.     /**
  4105.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo
  4106.      *
  4107.      * @param servizioApplicativo Servizio Applicativo
  4108.      * @param counter Indica il numero di id da ritornare
  4109.      * @param offset offset
  4110.      * @return ID dei messaggi destinati ad un servizio applicativo
  4111.      * 
  4112.      */
  4113.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,int counter, int offset)throws GestoreMessaggiException{

  4115.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, counter, offset, null, null, null);

  4117.     }


  4120.     /**
  4121.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo i quali possiedono un determinato servizio
  4122.      *
  4123.      * @param servizioApplicativo Servizio Applicativo
  4124.      * @param tipoServizio Filtro per TipoServizio
  4125.      * @param servizio Filtro per Servizio
  4126.      * @return ID dei messaggi destinati ad un servizio applicativo
  4127.      * 
  4128.      */
  4129.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,
  4130.             String tipoServizio,String servizio)throws GestoreMessaggiException{

  4132.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, -1, -1, tipoServizio, servizio, null);

  4134.     }

  4136.     /**
  4137.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo i quali possiedono un determinato servizio
  4138.      *
  4139.      * @param servizioApplicativo Servizio Applicativo
  4140.      * @param tipoServizio Filtro per TipoServizio
  4141.      * @param servizio Filtro per Servizio
  4142.      * @param counter Indica il numero di id da ritornare
  4143.      * @return ID dei messaggi destinati ad un servizio applicativo
  4144.      * 
  4145.      */
  4146.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,
  4147.             String tipoServizio,String servizio,int counter)throws GestoreMessaggiException{

  4149.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, counter, -1, tipoServizio, servizio, null);

  4151.     }

  4153.     /**
  4154.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo i quali possiedono un determinato servizio
  4155.      *
  4156.      * @param servizioApplicativo Servizio Applicativo
  4157.      * @param tipoServizio Filtro per TipoServizio
  4158.      * @param servizio Filtro per Servizio
  4159.      * @param counter Indica il numero di id da ritornare
  4160.      * @param offset offset
  4161.      * @return ID dei messaggi destinati ad un servizio applicativo
  4162.      * 
  4163.      */
  4164.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,
  4165.             String tipoServizio,String servizio,int counter, int offset)throws GestoreMessaggiException{

  4167.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, counter, offset, tipoServizio, servizio, null);

  4169.     }

  4171.     /**
  4172.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo i quali possiedono un determinato servizio e azione
  4173.      *
  4174.      * @param servizioApplicativo Servizio Applicativo
  4175.      * @param tipoServizio Filtro per TipoServizio
  4176.      * @param servizio Filtro per Servizio
  4177.      * @param azione Filtro per Azione
  4178.      * @return ID dei messaggi destinati ad un servizio applicativo
  4179.      * 
  4180.      */
  4181.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,
  4182.             String tipoServizio,String servizio,String azione)throws GestoreMessaggiException{

  4184.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, -1, -1, tipoServizio, servizio, azione);

  4186.     }

  4188.     /**
  4189.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo i quali possiedono un determinato servizio e azione
  4190.      *
  4191.      * @param servizioApplicativo Servizio Applicativo
  4192.      * @param tipoServizio Filtro per TipoServizio
  4193.      * @param servizio Filtro per Servizio
  4194.      * @param azione Filtro per Azione
  4195.      * @param counter Indica il numero di id da ritornare
  4196.      * @return ID dei messaggi destinati ad un servizio applicativo
  4197.      * 
  4198.      */
  4199.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,
  4200.             String tipoServizio,String servizio,String azione,int counter)throws GestoreMessaggiException{

  4202.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, counter, -1, tipoServizio, servizio, azione);

  4204.     }

  4206.     /**
  4207.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo i quali possiedono un determinato servizio e azione
  4208.      *
  4209.      * @param servizioApplicativo Servizio Applicativo
  4210.      * @param tipoServizio Filtro per TipoServizio
  4211.      * @param servizio Filtro per Servizio
  4212.      * @param azione Filtro per Azione
  4213.      * @param counter Indica il numero di id da ritornare
  4214.      * @param offset offset
  4215.      * @return ID dei messaggi destinati ad un servizio applicativo
  4216.      * 
  4217.      */
  4218.     public List<IdentificativoIM> getIDMessaggi_ServizioApplicativo(String servizioApplicativo,
  4219.             String tipoServizio,String servizio,String azione,int counter, int offset)throws GestoreMessaggiException{

  4221.         return this.getIDMessaggi_ServizioApplicativo_engine(servizioApplicativo, counter, offset, tipoServizio, servizio, azione);

  4223.     }





  4229.     /**
  4230.      * Ritorna gli ID dei messaggi destinati ad un servizio applicativo
  4231.      *
  4232.      * @param servizioApplicativo Servizio Applicativo
  4233.      * @param counter Indica il numero di id da ritornare
  4234.      * @param tipoServizio Filtro per TipoServizio
  4235.      * @param servizio Filtro per Servizio
  4236.      * @param azione Filtro per Azione
  4237.      * @return ID dei messaggi destinati ad un servizio applicativo
  4238.      * 
  4239.      */
  4240.     private List<IdentificativoIM> getIDMessaggi_ServizioApplicativo_engine(String servizioApplicativo,
  4241.             int counterParam,int offset,String tipoServizio,String servizio,String azione)throws GestoreMessaggiException{

  4243.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  4244.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  4245.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  4246.             Connection connectionDB = stateful.getConnectionDB();
  4247.             PreparedStatement pstmt = null;
  4248.             ResultSet rs = null;
  4249.             List<IdentificativoIM> ids = new ArrayList<IdentificativoIM>();
  4250.             String queryString = null;
  4251.             try{
  4252.                 
  4253.                 int limit = counterParam;
  4254.                 if(limit<=0) {
  4255.                     Integer defaultV = this.propertiesReader.getIntegrationManagerIdsLimit();
  4256.                     if(defaultV!=null && defaultV.intValue()>0) {
  4257.                         limit = defaultV.intValue();
  4258.                     }
  4259.                 }
  4260.                 
  4261.                 // Calcolo data minima
  4262.                 queryString = getQueryStringGetAllMessagesId(servizioApplicativo,
  4263.                         limit, offset, tipoServizio, servizio, azione,
  4264.                         true);
  4265.                 pstmt = connectionDB.prepareStatement(queryString);
  4266.                 setPreparedStatementGetAllMessagesId(pstmt,
  4267.                         servizioApplicativo,
  4268.                         tipoServizio,servizio,azione,
  4269.                         null);
  4270.                 //System.out.println("QUERY MIN DATE ID MESSAGGI IS: ["+queryString+"]");
  4271.                 rs = pstmt.executeQuery();
  4272.                 Timestamp minDate = null;
  4273.                 if(rs.next()) {
  4274.                     minDate = rs.getTimestamp("MinOraRegistrazione");
  4275.                 }
  4276.                 rs.close();
  4277.                 pstmt.close();
  4278.                 
  4279.                 if(minDate!=null) {
  4280.                 
  4281.                     // Effettuo ricerca ID DEL SERVIZIO APPLICATIVO
  4282.     
  4283.                     queryString = getQueryStringGetAllMessagesId(servizioApplicativo,
  4284.                             limit, offset, tipoServizio, servizio, azione,
  4285.                             false);
  4286.                     //System.out.println("QUERY ID MESSAGGI IS: ["+queryString+"]");
  4287.     
  4288.                     pstmt = connectionDB.prepareStatement(queryString);
  4289.                     setPreparedStatementGetAllMessagesId(pstmt,
  4290.                             servizioApplicativo,
  4291.                             tipoServizio,servizio,azione,
  4292.                             minDate);
  4293.                     rs = pstmt.executeQuery();
  4294.     
  4295.     
  4296.                     int countLimit = 0;
  4297.                     while(rs.next()){
  4298.                         
  4299.                         IdentificativoIM idIM = new IdentificativoIM(rs.getString("IdMsgServizioApplicativo"), rs.getTimestamp("OraMessaggio"));
  4300.                         ids.add(idIM);
  4301.                         
  4302.                         // LIMIT Applicativo
  4303.                         if(limit>=0 && Configurazione.getSqlQueryObjectType()==null){
  4304.                             countLimit++;
  4305.                             if(countLimit==limit)
  4306.                                 break;
  4307.                         }
  4308.                     }
  4309.                     rs.close();
  4310.                     pstmt.close();
  4311.                     
  4312.                 }

  4314.             } catch(Exception e) {
  4315.                 String errorMsg = "[GestoreMessaggi.getIDMessaggi_ServizioApplicativo_engine] errore, queryString["+queryString+"]: "+e.getMessage();       
  4316.                 try{
  4317.                     if(rs != null)
  4318.                         rs.close();
  4319.                 } catch(Exception er) {
  4320.                     // close
  4321.                 }
  4322.                 try{
  4323.                     if(pstmt != null)
  4324.                         pstmt.close();
  4325.                 } catch(Exception er) {
  4326.                     // close
  4327.                 }
  4328.                 this.log.error(errorMsg,e);
  4329.                 throw new GestoreMessaggiException(errorMsg,e);
  4330.             }

  4332.             return ids;
  4333.             //          }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  4334.             //          //TODO Metodo stateful only
  4335.             //          return null;
  4336.             // do the right thing
  4337.         }else{
  4338.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  4339.         }
  4340.     }
  4341.     
  4342.     private String getQueryStringGetAllMessagesId(String servizioApplicativo,
  4343.             int counter,int offset,String tipoServizio,String servizio,String azione,
  4344.             boolean findMinDate) throws Exception {
  4345.         String queryString = null;
  4346.         if(Configurazione.getSqlQueryObjectType()==null){

  4348.             if(offset>=0){
  4349.                 throw new GestoreMessaggiException("La funzione di ricerca tramite offset e limit non e' utilizzabile se nella configurazione della PdD non viene specificato il tipo di database");
  4350.             }

  4352.             StringBuilder query = new StringBuilder();
  4353.             query.append("SELECT ");

  4355.             // Select
  4356.             if(findMinDate) {
  4357.                 query.append("MIN(");
  4358.                 query.append(GestoreMessaggi.MESSAGGI);
  4359.                 query.append(".ORA_REGISTRAZIONE) as MinOraRegistrazione ");
  4360.             }
  4361.             else {
  4362.                 query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  4363.                 query.append(".ID_MESSAGGIO as IdMsgServizioApplicativo, ");
  4364.                 query.append(GestoreMessaggi.MESSAGGI);
  4365.                 query.append(".ORA_REGISTRAZIONE as OraMessaggio ");
  4366.             }
  4367.             
  4368.             query.append(" FROM ");

  4370.             // FROM
  4371.             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  4372.             query.append(",");
  4373.             query.append(GestoreMessaggi.MESSAGGI);
  4374.             if(tipoServizio!=null || servizio!=null || azione!=null){
  4375.                 query.append(",");
  4376.                 query.append(Costanti.REPOSITORY);
  4377.             }
  4378.             query.append(" WHERE ");

  4380.             // join MSG_SERVIZI_APPLICATIVI con MESSAGGI
  4381.             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  4382.             query.append(".ID_MESSAGGIO=");
  4383.             query.append(GestoreMessaggi.MESSAGGI);
  4384.             query.append(".ID_MESSAGGIO AND ");

  4386.             if(tipoServizio!=null || servizio!=null || azione!=null){
  4387.                 // join REPOSITORY_BUSTE con MESSAGGI
  4388.                 query.append(Costanti.REPOSITORY);
  4389.                 query.append(".ID_MESSAGGIO=");
  4390.                 query.append(GestoreMessaggi.MESSAGGI);
  4391.                 query.append(".ID_MESSAGGIO AND ");
  4392.                 query.append(Costanti.REPOSITORY);
  4393.                 query.append(".TIPO=");
  4394.                 query.append(GestoreMessaggi.MESSAGGI);
  4395.                 query.append(".TIPO AND ");
  4396.             }

  4398.             // Selezione messaggio del servizio applicativo
  4399.             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  4400.             query.append(".SERVIZIO_APPLICATIVO=? AND ");
  4401.             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  4402.             query.append(".INTEGRATION_MANAGER=1 AND ");
  4403.             query.append(GestoreMessaggi.MESSAGGI);
  4404.             query.append(".TIPO=? AND ");
  4405.             query.append(GestoreMessaggi.MESSAGGI);
  4406.             query.append(".PROPRIETARIO=? ");
  4407.             if(!findMinDate) {
  4408.                 query.append("AND ");
  4409.                 query.append(GestoreMessaggi.MESSAGGI);
  4410.                 query.append(".ORA_REGISTRAZIONE>=? ");
  4411.             }

  4413.             // Filtro busta
  4414.             if(tipoServizio!=null){
  4415.                 query.append("AND ");
  4416.                 query.append(Costanti.REPOSITORY);
  4417.                 query.append(".TIPO_SERVIZIO=? ");
  4418.             }
  4419.             if(servizio!=null){
  4420.                 query.append("AND ");
  4421.                 query.append(Costanti.REPOSITORY);
  4422.                 query.append(".SERVIZIO=? ");
  4423.             }
  4424.             if(azione!=null){
  4425.                 query.append("AND ");
  4426.                 query.append(Costanti.REPOSITORY);
  4427.                 query.append(".AZIONE=? ");
  4428.             }

  4430.             // Ordine risultato
  4431.             if(!findMinDate) {
  4432.                 query.append("ORDER BY ");
  4433.                 query.append(GestoreMessaggi.MESSAGGI);
  4434.                 query.append(".ORA_REGISTRAZIONE,");
  4435.                 query.append(GestoreMessaggi.MESSAGGI);
  4436.                 query.append(".ID_MESSAGGIO");
  4437.             }
  4438.             queryString = query.toString();
  4439.         }else{
  4440.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  4441.             //  FROM
  4442.             sqlQueryObject.addFromTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  4443.             sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  4444.             if(tipoServizio!=null || servizio!=null || azione!=null){
  4445.                 sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  4446.             }
  4447.             
  4448.             // Select
  4449.             if(findMinDate) {
  4450.                 sqlQueryObject.addSelectMinField(GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE", "MinOraRegistrazione");
  4451.             }
  4452.             else {
  4453.                 sqlQueryObject.addSelectAliasField(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"ID_MESSAGGIO","IdMsgServizioApplicativo");
  4454.                 sqlQueryObject.addSelectAliasField(GestoreMessaggi.MESSAGGI,"ID_MESSAGGIO","IdBustaMessaggio");
  4455.                 sqlQueryObject.addSelectAliasField(GestoreMessaggi.MESSAGGI,"TIPO","TipoMessaggio");
  4456.                 sqlQueryObject.addSelectAliasField(GestoreMessaggi.MESSAGGI,"ORA_REGISTRAZIONE","OraMessaggio");
  4457.                 sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI,"PROPRIETARIO");
  4458.                 sqlQueryObject.addSelectField(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"SERVIZIO_APPLICATIVO");
  4459.                 sqlQueryObject.addSelectField(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"INTEGRATION_MANAGER");
  4460.             }

  4462.             sqlQueryObject.setANDLogicOperator(true);
  4463.                         
  4464.             // join MSG_SERVIZI_APPLICATIVI con MESSAGGI
  4465.             sqlQueryObject.addWhereCondition(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO="+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO");

  4467.             if(tipoServizio!=null || servizio!=null || azione!=null){
  4468.                 // join REPOSITORY_BUSTE con MESSAGGI
  4469.                 if(!findMinDate) {
  4470.                     sqlQueryObject.addSelectAliasField(Costanti.REPOSITORY,"ID_MESSAGGIO","IdBustaRepositoryBuste");
  4471.                     sqlQueryObject.addSelectAliasField(Costanti.REPOSITORY,"TIPO","TipoBustaRepositoryBuste");
  4472.                     sqlQueryObject.addSelectAliasField(Costanti.REPOSITORY,"ORA_REGISTRAZIONE","OraRepositoryBuste"); // per risolvere ambiguita oracle con OraRegistrazione dei messaggi
  4473.                 }
  4474.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY+".ID_MESSAGGIO="+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO");
  4475.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY+".TIPO="+GestoreMessaggi.MESSAGGI+".TIPO");
  4476.             }

  4478.             //  Selezione messaggio del servizio applicativo
  4479.             sqlQueryObject.addWhereCondition(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO=?");
  4480.             sqlQueryObject.addWhereCondition(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".INTEGRATION_MANAGER=1");
  4481.             sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI+".TIPO=?");
  4482.             sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI+".PROPRIETARIO=?");
  4483.             if(!findMinDate) {
  4484.                 sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE>=?");
  4485.             }

  4487.             // Filtro busta
  4488.             if(tipoServizio!=null){
  4489.                 if(!findMinDate) {
  4490.                     sqlQueryObject.addSelectField(Costanti.REPOSITORY,"TIPO_SERVIZIO");
  4491.                 }
  4492.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY+".TIPO_SERVIZIO=?");
  4493.             }
  4494.             if(servizio!=null){
  4495.                 if(!findMinDate) {
  4496.                     sqlQueryObject.addSelectField(Costanti.REPOSITORY,"SERVIZIO");
  4497.                 }
  4498.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY+".SERVIZIO=?");
  4499.             }
  4500.             if(azione!=null){
  4501.                 if(!findMinDate) {
  4502.                     sqlQueryObject.addSelectField(Costanti.REPOSITORY,"AZIONE");
  4503.                 }
  4504.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY+".AZIONE=?");
  4505.             }

  4507.             if(!findMinDate) {
  4508.                 // Ordine risultato
  4509.                 sqlQueryObject.addOrderBy("OraMessaggio");
  4510.                 sqlQueryObject.addOrderBy("IdBustaMessaggio");
  4511.                 sqlQueryObject.setSortType(true);

  4513.                 // Limit
  4514.                 if(counter>=0)
  4515.                     sqlQueryObject.setLimit(counter);

  4517.                 // Offset
  4518.                 if(offset>=0)
  4519.                     sqlQueryObject.setOffset(offset);
  4520.             }

  4522.             queryString = sqlQueryObject.createSQLQuery();
  4523.         }
  4524.         return queryString;
  4525.     }
  4526.     
  4527.     private void setPreparedStatementGetAllMessagesId(PreparedStatement pstmt,
  4528.             String servizioApplicativo,
  4529.             String tipoServizio,String servizio,String azione,
  4530.             Timestamp minDate) throws Exception {
  4531.         pstmt.setString(1,servizioApplicativo);
  4532.         pstmt.setString(2,Costanti.INBOX);
  4533.         pstmt.setString(3,ConsegnaContenutiApplicativi.ID_MODULO);

  4535.         int indexPstmt = 4;
  4536.         if(minDate!=null) {
  4537.             pstmt.setTimestamp(indexPstmt,minDate);
  4538.             indexPstmt++;
  4539.         }
  4540.         if(tipoServizio!=null){
  4541.             pstmt.setString(indexPstmt,tipoServizio);
  4542.             indexPstmt++;
  4543.         }
  4544.         if(servizio!=null){
  4545.             pstmt.setString(indexPstmt,servizio);
  4546.             indexPstmt++;
  4547.         }
  4548.         if(azione!=null){
  4549.             pstmt.setString(indexPstmt,azione);
  4550.             indexPstmt++;
  4551.         }
  4552.     }








  4561.     /* ------------- ELIMINAZIONE DESTINATARIO MESSAGGI (SIL) -------------- */
  4562.     /**
  4563.      * Elimina dalla Tabella MSG_SERVIZI_APPLICATIVI l'entry che possiede l'ID del messaggio e il servizioApplicativo
  4564.      * passato come parametro.
  4565.      * Effettua poi un controllo sulla tabella per verificare che esistano altri servizi applicativi che sono
  4566.      * interessati al messaggio identificato dall'ID. Se ne esistono, il metodo termina.
  4567.      * Se non vi sono altri servizi applicativi, il metodo elimina dalla Tabella MESSAGGIO il messaggio che possiede l'ID,
  4568.      * ed inoltre effettua una deleteFromDB e deleteFromFileSystem del messaggio salvato precedentemente.
  4569.      *
  4570.      * @param servizioApplicativo ServizioApplicativo
  4571.      * @param riferimentoMessaggio Eventuale messaggio riferito
  4572.      * @deprecated utilizzare la versione non serializable
  4573.      */
  4574.     @Deprecated
  4575.     public void eliminaDestinatarioMessaggio_serializable(String servizioApplicativo,String riferimentoMessaggio)throws GestoreMessaggiException{
  4576.         this.eliminaDestinatarioMessaggio_serializable(servizioApplicativo,riferimentoMessaggio,Costanti.GESTIONE_SERIALIZABLE_ATTESA_ATTIVA,Costanti.GESTIONE_SERIALIZABLE_CHECK_INTERVAL);
  4577.     }

  4579.     /**
  4580.      * Elimina dalla Tabella MSG_SERVIZI_APPLICATIVI l'entry che possiede l'ID del messaggio e il servizioApplicativo
  4581.      * passato come parametro.
  4582.      * Effettua poi un controllo sulla tabella per verificare che esistano altri servizi applicativi che sono
  4583.      * interessati al messaggio identificato dall'ID. Se ne esistono, il metodo termina.
  4584.      * Se non vi sono altri servizi applicativi, il metodo elimina dalla Tabella MESSAGGIO il messaggio che possiede l'ID,
  4585.      * ed inoltre effettua una deleteFromDB e deleteFromFileSystem del messaggio salvato precedentemente.
  4586.      *
  4587.      * @param servizioApplicativo ServizioApplicativo
  4588.      * @param riferimentoMessaggio Eventuale messaggio riferito
  4589.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  4590.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  4591.      * @deprecated utilizzare la versione non serializable
  4592.      */
  4593.     @Deprecated
  4594.     public void eliminaDestinatarioMessaggio_serializable(String servizioApplicativo,String riferimentoMessaggio,
  4595.             long attesaAttiva,int checkInterval)throws GestoreMessaggiException{
  4596.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  4597.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  4598.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  4599.             Connection connectionDB = stateful.getConnectionDB();
  4600.             /*
  4601.       Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  4602.       che esecuzioni parallele non leggano dati inconsistenti.
  4603.       Con il livello SERIALIZABLE, se ritorna una eccezione, deve essere riprovato
  4604.              */
  4605.             // setAutoCommit e livello Isolamento
  4606.             int oldTransactionIsolation = -1;
  4607.             try{
  4608.                 oldTransactionIsolation = connectionDB.getTransactionIsolation();
  4609.                 connectionDB.setAutoCommit(false);
  4610.                 JDBCUtilities.setTransactionIsolationSerializable(this.propertiesReader.getDatabaseType(), connectionDB);
  4611.             } catch(Exception er) {
  4612.                 String errorMsg = "GESTORE_MESSAGGI, error  eliminaDestinatarioMessaggio (setIsolation)"+this.idBusta+"/"+servizioApplicativo+": "+er.getMessage();     
  4613.                 this.log.error(errorMsg,er);
  4614.                 throw new GestoreMessaggiException(errorMsg,er);
  4615.             }


  4618.             // ELIMINAZIONE DESTINATARIO
  4619.             boolean deleteDestinatarioOK = false;
  4620.             //int silDelete = -1;

  4622.             long scadenzaWhile = DateManager.getTimeMillis() + attesaAttiva;

  4624.             while(deleteDestinatarioOK==false && DateManager.getTimeMillis() < scadenzaWhile){

  4626.                 PreparedStatement pstmtDeleteSIL = null;
  4627.                 try{

  4629.                     // Costruzione Query
  4630.                     String query = "DELETE FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  4631.                     //log.debug("Query: "+query);
  4632.                     pstmtDeleteSIL=connectionDB.prepareStatement(query);
  4633.                     pstmtDeleteSIL.setString(1,this.idBusta);
  4634.                     pstmtDeleteSIL.setString(2,servizioApplicativo);
  4635.                     //silDelete = pstmtDeleteSIL.executeUpdate();
  4636.                     pstmtDeleteSIL.executeUpdate();
  4637.                     pstmtDeleteSIL.close();

  4639.                     // Chiusura Transazione
  4640.                     connectionDB.commit();
  4641.                     stateful.updateConnection(connectionDB);
  4642.                     if(this.isRichiesta) this.openspcoopstate.setStatoRichiesta(stateful);
  4643.                     else this.openspcoopstate.setStatoRisposta(stateful);
  4644.                     // Eliminazione Destinatario effettuata
  4645.                     deleteDestinatarioOK = true;

  4647.                 } catch(Exception e) {
  4648.                     //log.error("ERROR ELIMINAZIONE DESTINATARIO MESSAGGIO ["+e.getMessage()+"]");
  4649.                     try{
  4650.                         if( pstmtDeleteSIL != null  )
  4651.                             pstmtDeleteSIL.close();
  4652.                     } catch(Exception er) {
  4653.                         // close
  4654.                     }
  4655.                     try{
  4656.                         connectionDB.rollback();
  4657.                         stateful.updateConnection(connectionDB);
  4658.                         if(this.isRichiesta) this.openspcoopstate.setStatoRichiesta(stateful);
  4659.                         else this.openspcoopstate.setStatoRisposta(stateful);
  4660.                     } catch(Exception er) {
  4661.                         // ignore
  4662.                     }
  4663.                 }

  4665.                 if(deleteDestinatarioOK == false){
  4666.                     // Per aiutare ad evitare conflitti
  4667.                     try{
  4668.                         Utilities.sleep((getRandom()).nextInt(checkInterval)); // random da 0ms a checkIntervalms
  4669.                     }catch(Exception eRandom){
  4670.                         // ignore
  4671.                     }
  4672.                 }
  4673.             }


  4676.             // Se ho eliminato un sil 
  4677.             // (puo' darsi che accessi sincronizzati di Gop e ConsegneContenutiApplicativi faccino uno il lavoro per l'altro)
  4678.             //if(silDelete>0){


  4681.             // ELIMINAZIONE RIFERIMENTO MSG
  4682.             boolean deleteRiferimentoMsgOK = false;
  4683.             boolean eliminazioneRifCompleta = false;

  4685.             scadenzaWhile = DateManager.getTimeMillis() + attesaAttiva;

  4687.             while(deleteRiferimentoMsgOK==false && DateManager.getTimeMillis() < scadenzaWhile){

  4689.                 PreparedStatement pstmtUpdateMsg= null;
  4690.                 PreparedStatement pstmt = null;
  4691.                 ResultSet rs = null;
  4692.                 try{


  4695.                     // VERIFICA SE CI SONO ALTRI DESTINATARI
  4696.                     String query = "SELECT  * FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" WHERE ID_MESSAGGIO=? FOR UPDATE";
  4697.                     //log.debug("Query: "+query);
  4698.                     pstmt = connectionDB.prepareStatement(query);
  4699.                     pstmt.setString(1,this.idBusta);
  4700.                     rs = pstmt.executeQuery();
  4701.                     eliminazioneRifCompleta = !rs.next();

  4703.                     /* 
  4704.               if(eliminazioneRifCompleta==false){
  4705.               log.info("---------------------");
  4706.               log.info("-------ELIMINATO["+servizioApplicativo+"]--------------"); 
  4707.               log.info("------- ["+rs.getString("SERVIZIO_APPLICATIVO")+"] ---------");
  4708.               while(rs.next())
  4709.               log.info("------- ["+rs.getString("SERVIZIO_APPLICATIVO")+"] ---------");
  4710.               log.info("---------------------");
  4711.               }else{
  4712.               log.info("ELIMINAZIONE COMPLETA");
  4713.               }
  4714.                      */

  4716.                     rs.close();
  4717.                     pstmt.close();


  4720.                     // ELIMINAZIONE MESSAGGIO
  4721.                     if (eliminazioneRifCompleta) {      

  4723.                         // Imposto lo stato del messaggio ad 'eliminabile'
  4724.                         // Costruzione Query
  4725.                         StringBuilder queryUpdate = new StringBuilder();
  4726.                         queryUpdate.append("UPDATE ");
  4727.                         queryUpdate.append(GestoreMessaggi.MESSAGGI);
  4728.                         queryUpdate.append(" SET PROPRIETARIO=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  4729.                         pstmtUpdateMsg =  connectionDB.prepareStatement(queryUpdate.toString());
  4730.                         pstmtUpdateMsg.setString(1,TimerGestoreMessaggi.ID_MODULO);
  4731.                         pstmtUpdateMsg.setString(2,this.idBusta);
  4732.                         pstmtUpdateMsg.setString(3,Costanti.INBOX); // i messaggi con destinatari sono tutti di tipo 'INBOX'
  4733.                         pstmtUpdateMsg.execute();
  4734.                         pstmtUpdateMsg.close();

  4736.                         // Add Proprietario into table
  4737.                         this.addProprietarioIntoTable(Costanti.INBOX, this.idBusta, TimerGestoreMessaggi.ID_MODULO);

  4739.                     }
  4740.                     //else
  4741.                     //  log.info("ELIMINAZIONE PARZIALE");


  4744.                     // Chiusura Transazione
  4745.                     connectionDB.commit();
  4746.                     stateful.updateConnection(connectionDB);
  4747.                     if(this.isRichiesta) this.openspcoopstate.setStatoRichiesta(stateful);
  4748.                     else this.openspcoopstate.setStatoRisposta(stateful);

  4750.                     // Eliminazione Destinatario effettuata
  4751.                     deleteRiferimentoMsgOK = true;

  4753.                 } catch(Exception e) {
  4754.                     //log.error("ERROR ELIMINAZIONE DESTINATARIO MESSAGGIO ["+e.getMessage()+"]");
  4755.                     try{
  4756.                         if( pstmtUpdateMsg != null )
  4757.                             pstmtUpdateMsg.close();
  4758.                     } catch(Exception er) {
  4759.                         // close
  4760.                     }
  4761.                     try{
  4762.                         if( rs != null )
  4763.                             rs.close();
  4764.                     } catch(Exception er) {
  4765.                         // close
  4766.                     }
  4767.                     try{
  4768.                         if( pstmt != null )
  4769.                             pstmt.close();
  4770.                     } catch(Exception er) {
  4771.                         // close
  4772.                     }
  4773.                     try{
  4774.                         connectionDB.rollback();
  4775.                         stateful.updateConnection(connectionDB);
  4776.                         if(this.isRichiesta) this.openspcoopstate.setStatoRichiesta(stateful);
  4777.                         else this.openspcoopstate.setStatoRisposta(stateful);
  4778.                     } catch(Exception er) {
  4779.                         // ignore
  4780.                     }
  4781.                 }

  4783.                 if(deleteRiferimentoMsgOK == false){
  4784.                     // Per aiutare ad evitare conflitti
  4785.                     try{
  4786.                         Utilities.sleep((getRandom()).nextInt(checkInterval)); // random da 0ms a checkIntervalms
  4787.                     }catch(Exception eRandom){
  4788.                         // ignore
  4789.                     }
  4790.                 }

  4792.                 if(eliminazioneRifCompleta){
  4793.                     // Aggiornamento cache proprietario messaggio
  4794.                     this.addProprietariIntoCache_readFromTable("GestoreMessaggi", "eliminaDestinatarioMessaggio_serializable",riferimentoMessaggio,false);
  4795.                 }
  4796.             }
  4797.             //}

  4799.             // Ripristino Transazione
  4800.             try{
  4801.                 connectionDB.setTransactionIsolation(oldTransactionIsolation);
  4802.                 connectionDB.setAutoCommit(true);
  4803.                 stateful.updateConnection(connectionDB);
  4804.                 if(this.isRichiesta) this.openspcoopstate.setStatoRichiesta(stateful);
  4805.                 else this.openspcoopstate.setStatoRisposta(stateful);
  4806.             } catch(Exception er) {
  4807.                 String errorMsg = "GESTORE_MESSAGGI, error  eliminaDestinatarioMessaggio (ripristinoIsolation)"+this.idBusta+"/"+servizioApplicativo+": "+er.getMessage();      
  4808.                 this.log.error(errorMsg,er);
  4809.                 throw new GestoreMessaggiException(errorMsg,er);
  4810.             }
  4811.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  4812.             //TODO checkme NOP
  4813.         }else{
  4814.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  4815.         }
  4816.     }

  4818.     /**
  4819.      * Elimina dalla Tabella MSG_SERVIZI_APPLICATIVI l'entry che possiede l'ID del messaggio e il servizioApplicativo
  4820.      * passato come parametro.
  4821.      * Effettua poi un controllo sulla tabella per verificare che esistano altri servizi applicativi che sono
  4822.      * interessati al messaggio identificato dall'ID. Se ne esistono, il metodo termina.
  4823.      * Se non vi sono altri servizi applicativi, il metodo elimina dalla Tabella MESSAGGIO il messaggio che possiede l'ID,
  4824.      * ed inoltre effettua una deleteFromDB e deleteFromFileSystem del messaggio salvato precedentemente.
  4825.      *
  4826.      * @param servizioApplicativo ServizioApplicativo
  4827.      * @param riferimentoMessaggio Eventuale messaggio riferito
  4828.      */
  4829.     public void eliminaDestinatarioMessaggio(String servizioApplicativo, String riferimentoMessaggio)throws GestoreMessaggiException{
  4830.         eliminaDestinatarioMessaggio(servizioApplicativo, riferimentoMessaggio, null);
  4831.     }
  4832.     public void eliminaDestinatarioMessaggio(String servizioApplicativo, String riferimentoMessaggio, Date oraRegistrazione)throws GestoreMessaggiException{
  4833.         if(this.openspcoopstate instanceof OpenSPCoopStateful || this.oneWayVersione11) {
  4834.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  4835.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  4836.             Connection connectionDB = stateMSG.getConnectionDB();

  4838.             Timestamp leftValue = null;
  4839.             Timestamp rightValue = null;
  4840.             if(oraRegistrazione!=null) {
  4841.                 leftValue = new Timestamp(oraRegistrazione.getTime() - (1000*60*5));
  4842.                 rightValue = new Timestamp(oraRegistrazione.getTime() + (1000*60*5));
  4843.             }
  4844.             
  4845.             PreparedStatement pstmtDeleteSIL = null;
  4846.             try{

  4848.                 //this.log.debug("DELETE MSG_SERVIZI_APPLICATIVI WHERE ID_MESSAGGIO='"+this.idBusta+"' AND SERVIZIO_APPLICATIVO='"+servizioApplicativo+"'");

  4850.                 // Costruzione Query
  4851.                 String query = "DELETE FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" WHERE ";
  4852.                 if(oraRegistrazione!=null) {
  4853.                     query = query +"( ORA_REGISTRAZIONE BETWEEN ? AND ?) AND ";
  4854.                 }
  4855.                 query = query +" ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  4856.                 
  4857.                 //log.debug("Query: "+query);
  4858.                 pstmtDeleteSIL= connectionDB.prepareStatement(query);
  4859.                 int index = 1;
  4860.                 
  4861.                 if(oraRegistrazione!=null) {
  4862.                     pstmtDeleteSIL.setTimestamp(index++,leftValue);
  4863.                     pstmtDeleteSIL.setTimestamp(index++,rightValue);
  4864.                 }
  4865.                 
  4866.                 pstmtDeleteSIL.setString(index++,this.idBusta);
  4867.                 pstmtDeleteSIL.setString(index++,servizioApplicativo);

  4869.                 pstmtDeleteSIL.executeUpdate();
  4870.                 pstmtDeleteSIL.close();

  4872.             } catch(Exception e) {
  4873.                 try{
  4874.                     if( pstmtDeleteSIL != null  )
  4875.                         pstmtDeleteSIL.close();
  4876.                 } catch(Exception er) {
  4877.                     // close
  4878.                 }
  4879.                 String msgError = "ERROR ELIMINAZIONE DESTINATARIO MESSAGGIO: "+e.getMessage();
  4880.                 this.log.error(msgError,e);
  4881.                 throw new GestoreMessaggiException(msgError,e);
  4882.             }

  4884.             PreparedStatement pstmtUpdateMsg= null;
  4885.             PreparedStatement pstmt = null;
  4886.             ResultSet rs = null;
  4887.             try{


  4890.                 // VERIFICA SE CI SONO ALTRI DESTINATARI
  4891.                 String query = "SELECT  * FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" WHERE ";
  4892.                 if(oraRegistrazione!=null) {
  4893.                     query = query +"( ORA_REGISTRAZIONE BETWEEN ? AND ?) AND ";
  4894.                 }
  4895.                 query = query +"ID_MESSAGGIO=?";
  4896.                             
  4897.                 //log.debug("Query: "+query);
  4898.                 pstmt =  connectionDB.prepareStatement(query);
  4899.                 int index = 1;
  4900.                 
  4901.                 if(oraRegistrazione!=null) {
  4902.                     pstmt.setTimestamp(index++,leftValue);
  4903.                     pstmt.setTimestamp(index++,rightValue);
  4904.                 }
  4905.                 
  4906.                 pstmt.setString(index++,this.idBusta);
  4907.                 rs = pstmt.executeQuery();
  4908.                 boolean eliminazioneRifCompleta = !rs.next();

  4910.                 /*
  4911.           if(eliminazioneRifCompleta==false){
  4912.           log.info("---------------------");
  4913.           log.info("-------ELIMINATO["+servizioApplicativo+"]--------------"); 
  4914.           log.info("------- ["+rs.getString("SERVIZIO_APPLICATIVO")+"] ---------");
  4915.           while(rs.next())
  4916.           log.info("------- ["+rs.getString("SERVIZIO_APPLICATIVO")+"] ---------");
  4917.           log.info("---------------------");
  4918.           }else{
  4919.           log.info("ELIMINAZIONE COMPLETA");
  4920.           }
  4921.                  */

  4923.                 rs.close();
  4924.                 pstmt.close();


  4927.                 // ELIMINAZIONE MESSAGGIO
  4928.                 if (eliminazioneRifCompleta) {      

  4930.                     // Elimino utilizzo 

  4932.                     RepositoryBuste repositoryBuste= new RepositoryBuste(stateMSG, this.isRichiesta, this.protocolFactory);
  4933.                     repositoryBuste.eliminaUtilizzoPdDFromInBox(this.idBusta, oraRegistrazione);

  4935.                     if (this.oneWayVersione11) {
  4936.                         repositoryBuste.eliminaBustaStatelessFromInBox(this.idBusta, oraRegistrazione);
  4937.                     }

  4939.                     // Imposto lo stato del messaggio ad 'eliminabile'
  4940.                     // Costruzione Querya
  4941.                     StringBuilder queryUpdate = new StringBuilder();
  4942.                     queryUpdate.append("UPDATE ");
  4943.                     queryUpdate.append(GestoreMessaggi.MESSAGGI);
  4944.                     queryUpdate.append(" SET PROPRIETARIO=? WHERE ");
  4945.                     if(oraRegistrazione!=null) {
  4946.                         queryUpdate.append("(ORA_REGISTRAZIONE BETWEEN ? AND ?) AND ");
  4947.                     }
  4948.                     queryUpdate.append("ID_MESSAGGIO = ? AND TIPO=?");
  4949.                     
  4950.                     pstmtUpdateMsg = connectionDB.prepareStatement(queryUpdate.toString());
  4951.                     index = 1;
  4952.                     pstmtUpdateMsg.setString(index++,TimerGestoreMessaggi.ID_MODULO);
  4953.                     
  4954.                     if(oraRegistrazione!=null) {
  4955.                         pstmtUpdateMsg.setTimestamp(index++,leftValue);
  4956.                         pstmtUpdateMsg.setTimestamp(index++,rightValue);
  4957.                     }
  4958.                     
  4959.                     pstmtUpdateMsg.setString(index++,this.idBusta);
  4960.                     pstmtUpdateMsg.setString(index++,Costanti.INBOX); // i messaggi con destinatari sono tutti di tipo 'INBOX'

  4962.                     stateMSG.getPreparedStatement().put("UPDATE aggiornaProprietarioMessaggioOpenSPCoop "+this.tipo+"/"+this.idBusta,pstmtUpdateMsg);

  4964.                     // Add Proprietario into table
  4965.                     this.addProprietarioIntoTable(Costanti.INBOX, this.idBusta, TimerGestoreMessaggi.ID_MODULO);

  4967.                     // Commit
  4968.                     boolean oldValue = false;
  4969.                     if(this.oneWayVersione11){
  4970.                         oldValue = ((OpenSPCoopStateless)this.openspcoopstate).isUseConnection();
  4971.                         ((OpenSPCoopStateless)this.openspcoopstate).setUseConnection(true);
  4972.                     }
  4973.                     this.openspcoopstate.commit();
  4974.                     if(this.oneWayVersione11){
  4975.                         ((OpenSPCoopStateless)this.openspcoopstate).setUseConnection(oldValue);
  4976.                     }


  4979.                 }
  4980.                 //else
  4981.                 //  log.info("ELIMINAZIONE PARZIALE");


  4984.                 if(eliminazioneRifCompleta){
  4985.                     // Aggiornamento cache proprietario messaggio
  4986.                     this.addProprietariIntoCache_readFromTable("GestoreMessaggi", "eliminaDestinatarioMessaggio",riferimentoMessaggio,false);
  4987.                 }

  4989.                 if(this.isRichiesta) this.openspcoopstate.setStatoRichiesta(stateMSG);
  4990.                 else this.openspcoopstate.setStatoRisposta(stateMSG);


  4993.             } catch(Exception e) {
  4994.                 try{
  4995.                     if( pstmtUpdateMsg != null )
  4996.                         pstmtUpdateMsg.close();
  4997.                 } catch(Exception er) {
  4998.                     // close
  4999.                 }
  5000.                 try{
  5001.                     if( rs != null )
  5002.                         rs.close();
  5003.                 } catch(Exception er) {
  5004.                     // close
  5005.                 }
  5006.                 try{
  5007.                     if( pstmt != null )
  5008.                         pstmt.close();
  5009.                 } catch(Exception er) {
  5010.                     // close
  5011.                 }
  5012.                 String msgError = "ERROR ELIMINAZIONE DESTINATARIO MESSAGGIO, STEP 2: "+e.getMessage();
  5013.                 this.log.error(msgError,e);
  5014.                 throw new GestoreMessaggiException(msgError,e);
  5015.             }
  5016.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless && !this.oneWayVersione11){
  5017.             //NOP
  5018.         }else{
  5019.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  5020.         }

  5022.     }











  5034.     /* ------------- LETTURA MESSAGGI DA RICONSEGNARE -------------- */

  5036.     public static int abilitaSchedulingMessaggiDaRiconsegnareIntoBox(String servizioApplicativo, boolean checkEliminazioneLogica,
  5037.             Logger loggerSql, Connection connectionDB, boolean debug) throws GestoreMessaggiException{
  5038.         return _updateLockConsegnaMessaggiDaRiconsegnareIntoBox(servizioApplicativo, true, 
  5039.                 checkEliminazioneLogica,
  5040.                 loggerSql, connectionDB, debug);
  5041.     }
  5042.     public static int disabilitaSchedulingMessaggiDaRiconsegnareIntoBox(String servizioApplicativo, boolean checkEliminazioneLogica,
  5043.             Logger loggerSql, Connection connectionDB, boolean debug) throws GestoreMessaggiException{
  5044.         return _updateLockConsegnaMessaggiDaRiconsegnareIntoBox(servizioApplicativo, false, 
  5045.                 checkEliminazioneLogica,
  5046.                 loggerSql, connectionDB, debug);
  5047.     }
  5048.     private static int _updateLockConsegnaMessaggiDaRiconsegnareIntoBox(String servizioApplicativo, boolean abilitaScheduling, boolean checkEliminazioneLogica,
  5049.             Logger loggerSql, Connection connectionDB, boolean debug) throws GestoreMessaggiException{
  5050.     
  5051.         String idOperazione = abilitaScheduling ? "abilitaSchedulingNotificheAsincrone" : "disabilitaSchedulingNotificheAsincrone";
  5052.                 
  5053.         PreparedStatement pstmt = null;
  5054.         String updateString = null;
  5055.         try{ 
  5056.             
  5057.             String tipoDatabase = Configurazione.getSqlQueryObjectType();
  5058.             if(tipoDatabase==null) {
  5059.                 throw new GestoreMessaggiException("Funzionalità supportata solamente se viene definito il tipo di database");
  5060.             }
  5061.             
  5062.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  5063.             sqlQueryObject.addSelectField(MESSAGGI_COLUMN_ID_MESSAGGIO);
  5064.             sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  5065.             sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_PROPRIETARIO+"<>?");
  5066.             sqlQueryObject.setANDLogicOperator(true);
  5067.             
  5068.             ISQLQueryObject sqlQueryObjectMsgServiziApplicativi = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  5069.             sqlQueryObjectMsgServiziApplicativi.addUpdateTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5070.             sqlQueryObjectMsgServiziApplicativi.addUpdateField(MSG_SERVIZI_APPLICATIVI_COLUMN_LOCK_CONSEGNA, "?");
  5071.             sqlQueryObjectMsgServiziApplicativi.addWhereCondition(MSG_SERVIZI_APPLICATIVI_COLUMN_SERVIZIO_APPLICATIVO+"=?");
  5072.             if(checkEliminazioneLogica) {
  5073.                 sqlQueryObjectMsgServiziApplicativi.addWhereCondition(MSG_SERVIZI_APPLICATIVI_COLUMN_TIPO+"=?");
  5074.                 sqlQueryObjectMsgServiziApplicativi.addWhereINSelectSQLCondition(false, MSG_SERVIZI_APPLICATIVI_COLUMN_ID_MESSAGGIO, sqlQueryObject);
  5075.                     sqlQueryObjectMsgServiziApplicativi.setANDLogicOperator(true);
  5076.             }
  5077.             if(abilitaScheduling) {
  5078.                 sqlQueryObjectMsgServiziApplicativi.addWhereCondition(MSG_SERVIZI_APPLICATIVI_COLUMN_LOCK_CONSEGNA+"=?"); // precedentemente disabilitato
  5079.             }
  5080.             else {
  5081.                 sqlQueryObjectMsgServiziApplicativi.addWhereCondition(false,
  5082.                         MSG_SERVIZI_APPLICATIVI_COLUMN_LOCK_CONSEGNA+" is null",
  5083.                         MSG_SERVIZI_APPLICATIVI_COLUMN_LOCK_CONSEGNA+"<>?"); // gia' disabilitato
  5084.             }
  5085.             sqlQueryObjectMsgServiziApplicativi.setANDLogicOperator(true);
  5086.         
  5087.             updateString = sqlQueryObjectMsgServiziApplicativi.createSQLUpdate();
  5088.             
  5089.             pstmt = connectionDB.prepareStatement(updateString);
  5090.             
  5091.             int index = 1;
  5092.             List<Object> params = new ArrayList<>();
  5093.         
  5094.             if(abilitaScheduling) {
  5095.                 pstmt.setTimestamp(index++,null); 
  5096.                 params.add("null");
  5097.             }
  5098.             else {
  5099.                 pstmt.setTimestamp(index++,TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA); 
  5100.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA));
  5101.             }
  5102.                 
  5103.             pstmt.setString(index++,servizioApplicativo); params.add(servizioApplicativo);
  5104.             if(checkEliminazioneLogica) {
  5105.                 pstmt.setString(index++,Costanti.INBOX); params.add(Costanti.INBOX);
  5106.                 pstmt.setString(index++,TimerGestoreMessaggi.ID_MODULO); params.add(TimerGestoreMessaggi.ID_MODULO);
  5107.             }
  5108.             
  5109.             pstmt.setTimestamp(index++,TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA); 
  5110.             params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA));
  5111.             
  5112.             long startDateSQLCommand = DateManager.getTimeMillis();
  5113.             String comandoSql = null;
  5114.             if(debug) {
  5115.                 comandoSql = DBUtils.formatSQLString(updateString, params.toArray());
  5116.                 loggerSql.debug("[UPDATE] (Messaggi."+idOperazione+") ["+comandoSql+"] ...");
  5117.             }
  5118.             int result = pstmt.executeUpdate();
  5119.             long endDateSQLCommand = DateManager.getTimeMillis();
  5120.             long diffSQLCommand = endDateSQLCommand - startDateSQLCommand;
  5121.             if(debug) {
  5122.                 loggerSql.debug("[UPDATE] (Messaggi."+idOperazione+") ["+comandoSql+"] [row:"+result+"] effettuato in "+Utilities.convertSystemTimeIntoStringMillisecondi(diffSQLCommand, true));
  5123.             }
  5124.             
  5125.             return result;
  5126.         
  5127.         } catch(Exception e) {
  5128.             String errorMsg = "[GestoreMessaggi."+idOperazione+"] errore, queryString["+updateString+"]: "+e.getMessage();
  5129.             loggerSql.error(errorMsg,e);
  5130.             throw new GestoreMessaggiException(errorMsg,e);
  5131.         }finally {
  5132.             try{
  5133.                 if(pstmt != null)
  5134.                     pstmt.close();
  5135.             } catch(Exception er) { 
  5136.                 // close
  5137.             }
  5138.         }
  5139.     }
  5140.     
  5141.     public List<MessaggioServizioApplicativo> readMessaggiDaRiconsegnareIntoBoxByPriorita(int limit,
  5142.             boolean verificaPresenzaMessaggiDaRispedire, boolean calcolaDataMinimaMessaggiRispedire, Integer secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  5143.             Date riconsegna, int presaInConsegnaMaxLife, 
  5144.             boolean debug, RunnableLogger loggerSql,
  5145.             String coda, String priorita)throws GestoreMessaggiException{
  5146.         return  _readMessaggiDaRiconsegnareIntoBox(limit,
  5147.                 verificaPresenzaMessaggiDaRispedire, calcolaDataMinimaMessaggiRispedire, secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  5148.                 riconsegna, presaInConsegnaMaxLife, 
  5149.                 debug, loggerSql,
  5150.                 coda, priorita);
  5151.     }
  5152.     public List<MessaggioServizioApplicativo> readMessaggiDaRiconsegnareIntoBoxByServiziApplicativPrioritari(int limit,
  5153.             boolean verificaPresenzaMessaggiDaRispedire, boolean calcolaDataMinimaMessaggiRispedire, Integer secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  5154.             Date riconsegna, int presaInConsegnaMaxLife, 
  5155.             boolean debug, RunnableLogger loggerSql,
  5156.             String coda, String ... serviziApplicativiPrioritari)throws GestoreMessaggiException{
  5157.         return  _readMessaggiDaRiconsegnareIntoBox(limit,
  5158.                 verificaPresenzaMessaggiDaRispedire, calcolaDataMinimaMessaggiRispedire, secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  5159.                 riconsegna, presaInConsegnaMaxLife, 
  5160.                 debug, loggerSql,
  5161.                 coda, null,
  5162.                 serviziApplicativiPrioritari);
  5163.     }
  5164.     
  5165.     private List<MessaggioServizioApplicativo> _readMessaggiDaRiconsegnareIntoBox(int limit,
  5166.             boolean verificaPresenzaMessaggiDaRispedire, boolean calcolaDataMinimaMessaggiRispedire, Integer secondiAnzianitaPerIniziareSpedireNuovoMessaggio,
  5167.             Date riconsegna, int presaInConsegnaMaxLife, 
  5168.             boolean debug, RunnableLogger loggerSql,
  5169.             String coda, String priorita,
  5170.             String ... serviziApplicativiPrioritari)throws GestoreMessaggiException{

  5172.         boolean verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi = true;
  5173.         
  5174.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  5175.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta())
  5176.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  5177.             Connection connectionDB = stateful.getConnectionDB();

  5179.             List<MessaggioServizioApplicativo> idMsg = new ArrayList<MessaggioServizioApplicativo>();

  5181.             Date dataRilascioLock = new Date( DateManager.getTimeMillis() - this.propertiesReader.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife() );
  5182.             
  5183.             String tipo = Costanti.INBOX;
  5184.                         
  5185.             Date dataAttualeVerificaNow = DateManager.getDate();
  5186.             boolean checkOraLegale = OpenSPCoop2Properties.getInstance().isTimerConsegnaContenutiApplicativiSchedulingCheckPassaggioOraLegaleVersoOraSolare();
  5187.             boolean isMinutiMancantiPassaggioOraLegaleVersoOraSolare = false;
  5188.             if(checkOraLegale) {
  5189.                 isMinutiMancantiPassaggioOraLegaleVersoOraSolare = isMinutiMancantiPassaggioOraLegaleVersoOraSolare(debug, loggerSql, dataAttualeVerificaNow, 60); // devo verificare di non essere nella potenziale ora tornata indietro
  5190.             }
  5191.             
  5192.             if(debug) {
  5193.                 loggerSql.debug("[QUERY] Parametri ricerca (coda:"+coda+" priorita:"+priorita+"): verificaPresenzaMessaggiDaRispedire:"+verificaPresenzaMessaggiDaRispedire+" calcolaDataMinimaMessaggiRispedire:"+calcolaDataMinimaMessaggiRispedire+" isMinutiMancantiPassaggioOraLegaleVersoOraSolare:"+isMinutiMancantiPassaggioOraLegaleVersoOraSolare+"");
  5194.             }
  5195.             
  5196.             Timestamp dataMinima = null;
  5197.             if(verificaPresenzaMessaggiDaRispedire && calcolaDataMinimaMessaggiRispedire) {
  5198.                 PreparedStatement pstmt = null;
  5199.                 ResultSet rs = null;
  5200.                 String queryString = null;
  5201.                 try{ 

  5203.                     if(Configurazione.getSqlQueryObjectType()==null){
  5204.                         StringBuilder query = new StringBuilder();
  5205.                         query.append("SELECT min("+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE as minOraMess ");
  5206.                         
  5207.                         query.append(" FROM ");
  5208.                         query.append(GestoreMessaggi.MESSAGGI);
  5209.                         query.append(",");
  5210.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5211.                         
  5212.                         query.append(" WHERE ");
  5213.                         
  5214.                         if(secondiAnzianitaPerIniziareSpedireNuovoMessaggio!=null && secondiAnzianitaPerIniziareSpedireNuovoMessaggio>0) {
  5215.                             // Per non prendere immediatamente i messaggi in carico ed evitare problemi di serializzazione con le tracce, se ancora non è stata scritta
  5216.                             if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5217.                                 query.append("(");
  5218.                                 
  5219.                                 // controllo che non sia nell'intervallo tra now e i precedenti x secondi
  5220.                                 query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE<=? "); 
  5221.                                 
  5222.                                 query.append(" OR ");
  5223.                                 
  5224.                                 // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5225.                                 query.append("(");
  5226.                                 query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE>? "); 
  5227.                                 query.append(" AND ");
  5228.                                 query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE<? "); 
  5229.                                 query.append(")");
  5230.                                 
  5231.                                 query.append(")");
  5232.                                 
  5233.                                 query.append(" AND ");
  5234.                             }
  5235.                             else {
  5236.                                 query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE<=? ").append(" AND ");
  5237.                             }
  5238.                         }
  5239.                         
  5240.                         // join
  5241.                         query.append(" ");
  5242.                         query.append(GestoreMessaggi.MESSAGGI);
  5243.                         query.append(".ID_MESSAGGIO=");
  5244.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5245.                         query.append(".ID_MESSAGGIO AND ");
  5246.                         
  5247.                         query.append(" ").append(GestoreMessaggi.MESSAGGI).append(".TIPO=? AND ").
  5248.                               append(GestoreMessaggi.MESSAGGI).append(".PROPRIETARIO=? ");
  5249.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".TIPO_CONSEGNA=? ");
  5250.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ATTESA_ESITO=? ");
  5251.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".CODA=? ");
  5252.                         if(serviziApplicativiPrioritari!=null && serviziApplicativiPrioritari.length>0) {
  5253.                             query.append(" AND (");
  5254.                             if(serviziApplicativiPrioritari.length==1) {
  5255.                                 query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".SERVIZIO_APPLICATIVO=?");
  5256.                             }
  5257.                             else {
  5258.                                 query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".SERVIZIO_APPLICATIVO IN (");
  5259.                                 for (int i = 0; i < serviziApplicativiPrioritari.length; i++) {
  5260.                                     if(i>0) {
  5261.                                         query.append(",");
  5262.                                     }
  5263.                                     query.append(serviziApplicativiPrioritari[i]);
  5264.                                 }
  5265.                                 query.append(") ");
  5266.                             }
  5267.                             query.append(")");
  5268.                         }
  5269.                         else if(priorita!=null) {
  5270.                             query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".PRIORITA=? ");
  5271.                         }
  5272.                         
  5273.                         // per non intralciare con la "prima" registrazione (forse e' un controllo inutile)
  5274.                         query.append(" AND ")
  5275.                             .append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ERRORE_PROCESSAMENTO_COMPACT is not null ");
  5276.                         if(!verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi) {
  5277.                             // per non intralciare con la "prima" consegna
  5278.                             query.append(" AND ")
  5279.                                 .append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ERRORE_PROCESSAMENTO_COMPACT <> ? ");
  5280.                         }
  5281.                         
  5282.                         if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5283.                             query.append(" AND (");
  5284.                             
  5285.                             // data di rispedizione precedente ad adesso
  5286.                             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE<=? ");
  5287.                             
  5288.                             // data futura che combacia con l'ora di registrazione, la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5289.                             query.append(" OR (");
  5290.                             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE=").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ORA_REGISTRAZIONE");
  5291.                             query.append(" AND ");
  5292.                             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE<=? ");
  5293.                             query.append(") ");
  5294.                             
  5295.                             query.append(") ");
  5296.                         }
  5297.                         else {
  5298.                             query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE<=? ");
  5299.                         }
  5300.                         
  5301.                         query.append(" AND (").
  5302.                             append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".LOCK_CONSEGNA is null ").
  5303.                             append(" OR ").
  5304.                             append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".LOCK_CONSEGNA < ? ").
  5305.                             append(")");
  5306.                         
  5307.                         queryString = query.toString();
  5308.                     }else{

  5310.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  5311.                         sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI,"m");
  5312.                         sqlQueryObject.addFromTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"sa");

  5314.                         sqlQueryObject.addSelectMinField("m", "ORA_REGISTRAZIONE", "minOraMess");
  5315.                         
  5316.                         if(secondiAnzianitaPerIniziareSpedireNuovoMessaggio!=null && secondiAnzianitaPerIniziareSpedireNuovoMessaggio>0) {
  5317.                             // Per non prendere immediatamente i messaggi in carico ed evitare problemi di serializzazione con le tracce, se ancora non è stata scritta
  5318.                             if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5319.                                 sqlQueryObject.addWhereCondition(false, 
  5320.                                         "m.ORA_REGISTRAZIONE<=?", // controllo che non sia nell'intervallo tra now e i precedenti x secondi
  5321.                                         "(m.ORA_REGISTRAZIONE>? AND m.ORA_REGISTRAZIONE<?)" // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5322.                                         );
  5323.                             }
  5324.                             else {
  5325.                                 sqlQueryObject.addWhereCondition("m.ORA_REGISTRAZIONE<=?");
  5326.                             }
  5327.                         }
  5328.                         
  5329.                         // join
  5330.                         sqlQueryObject.addWhereCondition("m.ID_MESSAGGIO=sa.ID_MESSAGGIO");
  5331.                         
  5332.                         sqlQueryObject.addWhereCondition("m.TIPO=?");
  5333.                         sqlQueryObject.addWhereCondition("m.PROPRIETARIO=?");
  5334.                         sqlQueryObject.addWhereCondition("sa.TIPO_CONSEGNA=?");
  5335.                         sqlQueryObject.addWhereCondition("sa.ATTESA_ESITO=?");
  5336.                         sqlQueryObject.addWhereCondition("sa.CODA=?");
  5337.                         if(serviziApplicativiPrioritari!=null && serviziApplicativiPrioritari.length>0) {
  5338.                             if(serviziApplicativiPrioritari.length==1) {
  5339.                                 sqlQueryObject.addWhereCondition("sa.SERVIZIO_APPLICATIVO=?");
  5340.                             }
  5341.                             else {
  5342.                                 sqlQueryObject.addWhereINCondition("sa.SERVIZIO_APPLICATIVO", true, serviziApplicativiPrioritari);
  5343.                             }
  5344.                         }
  5345.                         else if(priorita!=null) {
  5346.                             sqlQueryObject.addWhereCondition("sa.PRIORITA=?");
  5347.                         }
  5348.                         
  5349.                         // per non intralciare con la "prima" registrazione (forse e' un controllo inutile)
  5350.                         sqlQueryObject.addWhereCondition("sa.ERRORE_PROCESSAMENTO_COMPACT is not null");
  5351.                         if(!verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi) {
  5352.                             // per non intralciare con la "prima" consegna
  5353.                             sqlQueryObject.addWhereCondition("sa.ERRORE_PROCESSAMENTO_COMPACT <> ?");
  5354.                         }
  5355.                         
  5356.                         if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5357.                             sqlQueryObject.addWhereCondition(false,
  5358.                                     // data di rispedizione precedente ad adesso
  5359.                                     "sa.RISPEDIZIONE<=?",
  5360.                                     // data futura che combacia con l'ora di registrazione, la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5361.                                     "(sa.RISPEDIZIONE=sa.ORA_REGISTRAZIONE  AND sa.RISPEDIZIONE<=?)"
  5362.                             );
  5363.                         }
  5364.                         else {
  5365.                             sqlQueryObject.addWhereCondition("sa.RISPEDIZIONE<=?");
  5366.                         }
  5367.                         
  5368.                         sqlQueryObject.addWhereCondition(false, "sa.LOCK_CONSEGNA is null", "sa.LOCK_CONSEGNA < ?");
  5369.                         
  5370.                         sqlQueryObject.setANDLogicOperator(true);
  5371.                         
  5372.                         queryString = sqlQueryObject.createSQLQuery();
  5373.                     }
  5374.                     
  5375.                     pstmt = connectionDB.prepareStatement(queryString);
  5376.                     int index = 1;
  5377.                     List<Object> params = new ArrayList<>();
  5378.                     
  5379.                     if(secondiAnzianitaPerIniziareSpedireNuovoMessaggio!=null && secondiAnzianitaPerIniziareSpedireNuovoMessaggio>0) {
  5380.                         if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5381.                             
  5382.                             // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora
  5383.                             long nowMillis = dataAttualeVerificaNow.getTime(); // uso il now calcolato per la variabile isMinutiMancantiPassaggioOraLegaleVersoOraSolare
  5384.                             
  5385.                             // controllo che non sia nell'intervallo tra now e i precedenti x secondi (ORA_REGISTRAZIONE<=?)
  5386.                             Timestamp anzianita = new Timestamp(nowMillis-(1000*secondiAnzianitaPerIniziareSpedireNuovoMessaggio.intValue()));
  5387.                             pstmt.setTimestamp(index++, anzianita);
  5388.                             params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(anzianita));
  5389.                             
  5390.                             // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera (ORA_REGISTRAZIONE>? AND ORA_REGISTRAZIONE<?)
  5391.                             Timestamp futuro = new Timestamp(nowMillis);
  5392.                             pstmt.setTimestamp(index++, futuro);
  5393.                             params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(futuro));
  5394.                             
  5395.                             Timestamp futuroPlusHour = new Timestamp(nowMillis+
  5396.                                     (1000*60*60)+ // un'ora
  5397.                                     (1000*60+5)); // aggiungo altri 5 minuti
  5398.                             pstmt.setTimestamp(index++, futuroPlusHour);
  5399.                             params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(futuroPlusHour));

  5401.                         }
  5402.                         else {
  5403.                             long nowMillis = DateManager.getTimeMillis();
  5404.                             // controllo che non sia nell'intervallo tra now e i precedenti x secondi
  5405.                             Timestamp anzianita = new Timestamp(nowMillis-(1000*secondiAnzianitaPerIniziareSpedireNuovoMessaggio.intValue()));
  5406.                             pstmt.setTimestamp(index++, anzianita);
  5407.                             params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(anzianita));
  5408.                         }
  5409.                     }
  5410.                     
  5411.                     pstmt.setString(index++,tipo); params.add(tipo);
  5412.                     pstmt.setString(index++,ConsegnaContenutiApplicativi.ID_MODULO); params.add(ConsegnaContenutiApplicativi.ID_MODULO);
  5413.                     pstmt.setString(index++,GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE); params.add(GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE);
  5414.                     pstmt.setInt(index++,CostantiDB.FALSE); params.add(CostantiDB.FALSE);
  5415.                     pstmt.setString(index++,coda); params.add(coda);
  5416.                     
  5417.                     if(serviziApplicativiPrioritari!=null && serviziApplicativiPrioritari.length>0) {
  5418.                         if(serviziApplicativiPrioritari.length==1) {
  5419.                             pstmt.setString(index++,serviziApplicativiPrioritari[0]);
  5420.                             params.add(serviziApplicativiPrioritari[0]);
  5421.                         }
  5422.                     }
  5423.                     else if(priorita!=null) {
  5424.                         pstmt.setString(index++,priorita);
  5425.                         params.add(priorita);
  5426.                     }
  5427.                     
  5428.                     if(!verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi) {
  5429.                         // per non intralciare con la "prima" consegna
  5430.                         pstmt.setString(index++, TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  5431.                         params.add(TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  5432.                     }
  5433.                     
  5434.                     // riconsegna
  5435.                     pstmt.setTimestamp(index++,new Timestamp(riconsegna.getTime()));
  5436.                     params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(riconsegna));
  5437.                     if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5438.                         Timestamp futuroPlusHour = new Timestamp(riconsegna.getTime()+
  5439.                                 (1000*60*60)+ // un'ora
  5440.                                 (1000*60+5)); // aggiungo altri 5 minuti
  5441.                         pstmt.setTimestamp(index++,new Timestamp(futuroPlusHour.getTime()));
  5442.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(futuroPlusHour));
  5443.                     }
  5444.                     
  5445.                     pstmt.setTimestamp(index++, new Timestamp(dataRilascioLock.getTime()));
  5446.                     params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(dataRilascioLock));

  5448.                     long startDateSQLCommand = DateManager.getTimeMillis();
  5449.                     String comandoSql = null;
  5450.                     if(debug) {
  5451.                         comandoSql = DBUtils.formatSQLString(queryString, params.toArray());
  5452.                         loggerSql.debug("[QUERY] (Messaggi.daRispedire.computeMinDate) ["+comandoSql+"] ...");
  5453.                     }
  5454.                     rs = pstmt.executeQuery();
  5455.                     long endDateSQLCommand = DateManager.getTimeMillis();
  5456.                     long diffSQLCommand = endDateSQLCommand - startDateSQLCommand;
  5457.                     if(debug) {
  5458.                         loggerSql.debug("[QUERY] (Messaggi.daRispedire.computeMinDate) ["+comandoSql+"] effettuata in "+Utilities.convertSystemTimeIntoStringMillisecondi(diffSQLCommand, true));
  5459.                     }
  5460.                     
  5461.                     if(rs.next()){
  5462.                         dataMinima = rs.getTimestamp("minOraMess");
  5463.                     }
  5464.                     rs.close(); rs = null;
  5465.                     pstmt.close(); pstmt=null;
  5466.                     
  5467.                     if(dataMinima==null) {
  5468.                         // non esistono messaggi; e' inutile fare la query successiva
  5469.                         loggerSql.debug("[QUERY] (Messaggi.daRispedire.computeMinDate) ["+comandoSql+"] dataMinima non trovata");
  5470.                         return idMsg;
  5471.                     }
  5472.                     
  5473.                     if(debug) {
  5474.                         loggerSql.debug("[QUERY] (Messaggi.daRispedire.computeMinDate) ["+comandoSql+"] dataMinimaTrovata: "+DateUtils.getSimpleDateFormatMs().format(dataMinima));
  5475.                     }
  5476.                     
  5477.                 } catch(Throwable e) {
  5478.                     String errorMsg = "[GestoreMessaggi.readMessaggiDaRiconsegnareIntoBox] errore durante il calcolo della data minima, queryString["+queryString+"] : "+e.getMessage();
  5479.                     try{
  5480.                         if(rs != null)
  5481.                             rs.close();
  5482.                     } catch(Exception er) {
  5483.                         // close
  5484.                     }
  5485.                     try{
  5486.                         if(pstmt != null)
  5487.                             pstmt.close();
  5488.                     } catch(Exception er) {
  5489.                         // close
  5490.                     }
  5491.                     loggerSql.error(errorMsg,e);
  5492.                     // Vado avanza senza data minima throw new GestoreMessaggiException(errorMsg,e);
  5493.                 }
  5494.             }
  5495.             
  5496.             PreparedStatement pstmtMsgDaSpedire = null;
  5497.             ResultSet rs = null;
  5498.             String queryString = null;
  5499.             try{   
  5500.                 
  5501.                 // Query per Ricerca messaggi eliminati (proprietario:EliminatoreMesaggi)
  5502.                 if(Configurazione.getSqlQueryObjectType()==null){
  5503.                     StringBuilder query = new StringBuilder();
  5504.                     query.append("SELECT "+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO as idmess, ");
  5505.                     query.append(" "+GestoreMessaggi.MESSAGGI+".id_transazione as idtransazione, ");
  5506.                     query.append(" "+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE as oramess, ");
  5507.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO as sa, ");
  5508.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SBUSTAMENTO_SOAP as sbSoap, ");
  5509.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SBUSTAMENTO_INFO_PROTOCOL as sbProtocol ");
  5510.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".NOME_PORTA as nomePorta ");
  5511.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".LOCK_CONSEGNA as saLock "); // non usare lock e' una parola riservata di oracle
  5512.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".CLUSTER_ID as saCluster "); // non usare cluster e' una parola riservata di oracle
  5513.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ATTESA_ESITO as attesa ");
  5514.                     
  5515.                     query.append(" FROM ");
  5516.                     query.append(GestoreMessaggi.MESSAGGI);
  5517.                     query.append(",");
  5518.                     query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5519.                     
  5520.                     query.append(" WHERE ");
  5521.                     
  5522.                     // Ottimizzazione per partizionamento
  5523.                     if(verificaPresenzaMessaggiDaRispedire) {
  5524.                         if(dataMinima!=null) {
  5525.                             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ORA_REGISTRAZIONE>=? ").append(" AND ");
  5526.                             query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE>=? ").append(" AND ");
  5527.                         }
  5528.                     }
  5529.                     else {
  5530.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ORA_REGISTRAZIONE>=? ").append(" AND ");
  5531.                         query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE>=? ").append(" AND ");
  5532.                     }
  5533.                     
  5534.                     if(secondiAnzianitaPerIniziareSpedireNuovoMessaggio!=null && secondiAnzianitaPerIniziareSpedireNuovoMessaggio>0) {
  5535.                         // Per non prendere immediatamente i messaggi in carico ed evitare problemi di serializzazione con le tracce, se ancora non è stata scritta
  5536.                         if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5537.                             query.append("(");
  5538.                             
  5539.                             // controllo che non sia nell'intervallo tra now e i precedenti x secondi
  5540.                             query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE<=? "); 
  5541.                             
  5542.                             query.append(" OR ");
  5543.                             
  5544.                             // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5545.                             query.append("(");
  5546.                             query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE>? "); 
  5547.                             query.append(" AND ");
  5548.                             query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE<? "); 
  5549.                             query.append(")");
  5550.                             
  5551.                             query.append(")");
  5552.                             
  5553.                             query.append(" AND ");
  5554.                         }
  5555.                         else {
  5556.                             query.append(GestoreMessaggi.MESSAGGI).append(".ORA_REGISTRAZIONE<=? ").append(" AND ");
  5557.                         }
  5558.                     }
  5559.                     
  5560.                     // join
  5561.                     query.append(" ");
  5562.                     query.append(GestoreMessaggi.MESSAGGI);
  5563.                     query.append(".ID_MESSAGGIO=");
  5564.                     query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5565.                     query.append(".ID_MESSAGGIO AND ");
  5566.                     
  5567.                     query.append(" ").append(GestoreMessaggi.MESSAGGI).append(".TIPO=? AND ").
  5568.                           append(GestoreMessaggi.MESSAGGI).append(".PROPRIETARIO=? ");
  5569.                     query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".TIPO_CONSEGNA=? ");
  5570.                     query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ATTESA_ESITO=? ");
  5571.                     query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".CODA=? ");
  5572.                     if(serviziApplicativiPrioritari!=null && serviziApplicativiPrioritari.length>0) {
  5573.                         query.append(" AND (");
  5574.                         if(serviziApplicativiPrioritari.length==1) {
  5575.                             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".SERVIZIO_APPLICATIVO=?");
  5576.                         }
  5577.                         else {
  5578.                             query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".SERVIZIO_APPLICATIVO IN (");
  5579.                             for (int i = 0; i < serviziApplicativiPrioritari.length; i++) {
  5580.                                 if(i>0) {
  5581.                                     query.append(",");
  5582.                                 }
  5583.                                 query.append(serviziApplicativiPrioritari[i]);
  5584.                             }
  5585.                             query.append(") ");
  5586.                         }
  5587.                         query.append(")");
  5588.                     }
  5589.                     else if(priorita!=null) {
  5590.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".PRIORITA=? ");
  5591.                     }
  5592.                     if(verificaPresenzaMessaggiDaRispedire) {
  5593.                         // per non intralciare con la "prima" registrazione (forse e' un controllo inutile)
  5594.                         query.append(" AND ").
  5595.                             append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ERRORE_PROCESSAMENTO_COMPACT is not null ");
  5596.                         if(!verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi) {
  5597.                             // per non intralciare con la "prima" consegna
  5598.                             query.append(" AND ").
  5599.                                 append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ERRORE_PROCESSAMENTO_COMPACT <> ? ");
  5600.                         }
  5601.                     }
  5602.                     else {
  5603.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ERRORE_PROCESSAMENTO_COMPACT = ? "); // prima consegna
  5604.                     }
  5605.                     
  5606.                     if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5607.                         query.append(" AND (");
  5608.                         
  5609.                         // data di rispedizione precedente ad adesso
  5610.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE<=? ");
  5611.                         
  5612.                         // data futura che combacia con l'ora di registrazione, la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5613.                         query.append(" OR (");
  5614.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE=").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".ORA_REGISTRAZIONE");
  5615.                         query.append(" AND ");
  5616.                         query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE<=? ");
  5617.                         query.append(") ");
  5618.                         
  5619.                         query.append(") ");
  5620.                     }
  5621.                     else {
  5622.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".RISPEDIZIONE<=? ");
  5623.                     }
  5624.                     
  5625.                     query.append(" AND (").
  5626.                         append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".LOCK_CONSEGNA is null ").
  5627.                         append(" OR ").
  5628.                         append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".LOCK_CONSEGNA < ? ").
  5629.                         append(")");
  5630.                     
  5631.                     queryString = query.toString();
  5632.                 }else{

  5634.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  5635.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI,"m");
  5636.                     sqlQueryObject.addFromTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"sa");
  5637.                     
  5638.                     sqlQueryObject.addSelectAliasField("m", "ID_MESSAGGIO", "idmess");
  5639.                     sqlQueryObject.addSelectAliasField("m", "id_transazione", "idtransazione");
  5640.                     sqlQueryObject.addSelectAliasField("m", "ORA_REGISTRAZIONE", "oramess");
  5641.                     sqlQueryObject.addSelectAliasField("sa", "SERVIZIO_APPLICATIVO", "sa");
  5642.                     sqlQueryObject.addSelectAliasField("sa", "SBUSTAMENTO_SOAP", "sbSoap");
  5643.                     sqlQueryObject.addSelectAliasField("sa", "SBUSTAMENTO_INFO_PROTOCOL", "sbProtocol");
  5644.                     sqlQueryObject.addSelectAliasField("sa", "NOME_PORTA", "nomePorta");
  5645.                     sqlQueryObject.addSelectAliasField("sa", "LOCK_CONSEGNA", "saLock"); // non usare lock e' una parola riservata di oracle
  5646.                     sqlQueryObject.addSelectAliasField("sa", "CLUSTER_ID", "saCluster"); // non usare cluster e' una parola riservata di oracle
  5647.                     sqlQueryObject.addSelectAliasField("sa", "ATTESA_ESITO", "attesa");
  5648.                     sqlQueryObject.addSelectAliasField("sa", "ID_MESSAGGIO", "saidmess");
  5649.                     sqlQueryObject.addSelectAliasField("sa", "TIPO_CONSEGNA", "satipocons");
  5650.                     sqlQueryObject.addSelectAliasField("sa", "ERRORE_PROCESSAMENTO_COMPACT", "saerrproccom");
  5651.                     sqlQueryObject.addSelectAliasField("sa", "RISPEDIZIONE", "sarisp");
  5652.                     sqlQueryObject.addSelectAliasField("sa", "CODA", "sacoda");
  5653.                     sqlQueryObject.addSelectAliasField("sa", "PRIORITA", "saprio");
  5654.                     sqlQueryObject.addSelectAliasField("m","ORA_REGISTRAZIONE", "oramsg");
  5655.                     sqlQueryObject.addSelectAliasField("m","PROPRIETARIO", "propmsg");
  5656.                     sqlQueryObject.addSelectAliasField("m","TIPO" , "tipomsg");
  5657.                     
  5658.                     // Ottimizzazione per partizionamento
  5659.                     if(verificaPresenzaMessaggiDaRispedire) {
  5660.                         if(dataMinima!=null) {
  5661.                             sqlQueryObject.addWhereCondition("m.ORA_REGISTRAZIONE>=?");
  5662.                             sqlQueryObject.addWhereCondition("sa.ORA_REGISTRAZIONE>=?");
  5663.                         }
  5664.                     }
  5665.                     else {
  5666.                         sqlQueryObject.addWhereCondition("m.ORA_REGISTRAZIONE>=?");
  5667.                         sqlQueryObject.addWhereCondition("sa.ORA_REGISTRAZIONE>=?");
  5668.                     }
  5669.                     
  5670.                     if(secondiAnzianitaPerIniziareSpedireNuovoMessaggio!=null && secondiAnzianitaPerIniziareSpedireNuovoMessaggio>0) {
  5671.                         // Per non prendere immediatamente i messaggi in carico ed evitare problemi di serializzazione con le tracce, se ancora non è stata scritta
  5672.                         if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5673.                             sqlQueryObject.addWhereCondition(false, 
  5674.                                     "m.ORA_REGISTRAZIONE<=?", // controllo che non sia nell'intervallo tra now e i precedenti x secondi
  5675.                                     "(m.ORA_REGISTRAZIONE>? AND m.ORA_REGISTRAZIONE<?)" // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5676.                                     );
  5677.                         }
  5678.                         else {
  5679.                             sqlQueryObject.addWhereCondition("m.ORA_REGISTRAZIONE<=?");
  5680.                         }
  5681.                     }
  5682.                     
  5683.                     // join
  5684.                     sqlQueryObject.addWhereCondition("m.ID_MESSAGGIO=sa.ID_MESSAGGIO");
  5685.                     
  5686.                     sqlQueryObject.addWhereCondition("m.TIPO=?");
  5687.                     sqlQueryObject.addWhereCondition("m.PROPRIETARIO=?");
  5688.                     sqlQueryObject.addWhereCondition("sa.TIPO_CONSEGNA=?");
  5689.                     sqlQueryObject.addWhereCondition("sa.ATTESA_ESITO=?");
  5690.                     sqlQueryObject.addWhereCondition("sa.CODA=?");
  5691.                     if(serviziApplicativiPrioritari!=null && serviziApplicativiPrioritari.length>0) {
  5692.                         if(serviziApplicativiPrioritari.length==1) {
  5693.                             sqlQueryObject.addWhereCondition("sa.SERVIZIO_APPLICATIVO=?");
  5694.                         }
  5695.                         else {
  5696.                             sqlQueryObject.addWhereINCondition("sa.SERVIZIO_APPLICATIVO", true, serviziApplicativiPrioritari);
  5697.                         }
  5698.                     }
  5699.                     else if(priorita!=null) {
  5700.                         sqlQueryObject.addWhereCondition("sa.PRIORITA=?");
  5701.                     }
  5702.                     if(verificaPresenzaMessaggiDaRispedire) {
  5703.                         // per non intralciare con la "prima" registrazione (forse e' un controllo inutile)
  5704.                         sqlQueryObject.addWhereCondition("sa.ERRORE_PROCESSAMENTO_COMPACT is not null");
  5705.                         if(!verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi) {
  5706.                             // per non intralciare con la "prima" consegna
  5707.                             sqlQueryObject.addWhereCondition("sa.ERRORE_PROCESSAMENTO_COMPACT <> ?");
  5708.                         }
  5709.                     }
  5710.                     else {
  5711.                         sqlQueryObject.addWhereCondition("sa.ERRORE_PROCESSAMENTO_COMPACT = ?"); // "prima" consegna
  5712.                     }
  5713.                     
  5714.                     if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5715.                         sqlQueryObject.addWhereCondition(false,
  5716.                                 // data di rispedizione precedente ad adesso
  5717.                                 "sa.RISPEDIZIONE<=?",
  5718.                                 // data futura che combacia con l'ora di registrazione, la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera
  5719.                                 "(sa.RISPEDIZIONE=sa.ORA_REGISTRAZIONE  AND sa.RISPEDIZIONE<=?)"
  5720.                         );
  5721.                     }
  5722.                     else {
  5723.                         sqlQueryObject.addWhereCondition("sa.RISPEDIZIONE<=?");
  5724.                     }
  5725.                     
  5726.                     sqlQueryObject.addWhereCondition(false, "sa.LOCK_CONSEGNA is null", "sa.LOCK_CONSEGNA < ?");
  5727.                     
  5728.                     sqlQueryObject.setANDLogicOperator(true);
  5729.                     sqlQueryObject.addOrderBy("oramsg");
  5730.                     sqlQueryObject.setSortType(true);
  5731.                     
  5732.                     sqlQueryObject.setLimit(limit);
  5733.                     queryString = sqlQueryObject.createSQLQuery();
  5734.                 }
  5735.                 //System.out.println("QUERY MESSAGGI ELIMINATI IS: ["+queryString+"]  1["+idModuloCleaner+"]  2["+tipo+"]");

  5737.                 //log.debug("Query: "+query);
  5738.                 pstmtMsgDaSpedire = connectionDB.prepareStatement(queryString);
  5739.                 int index = 1;
  5740.                 List<Object> params = new ArrayList<>();
  5741.                 
  5742.                 // Ottimizzazione per partizionamento
  5743.                 if(verificaPresenzaMessaggiDaRispedire) {
  5744.                     if(dataMinima!=null) {
  5745.                         pstmtMsgDaSpedire.setTimestamp(index++, dataMinima);
  5746.                         pstmtMsgDaSpedire.setTimestamp(index++, dataMinima);
  5747.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(dataMinima));
  5748.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(dataMinima));
  5749.                     }
  5750.                 }
  5751.                 else {
  5752.                     Timestamp now = new Timestamp(DateManager.getTimeMillis()-(1000*60*60*24)); // i messaggi presi in carico possono rimanere al massimo indietro di un giorno, senno rientrano in quelli da rispedire
  5753.                     pstmtMsgDaSpedire.setTimestamp(index++, now);
  5754.                     pstmtMsgDaSpedire.setTimestamp(index++, now);
  5755.                     params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(now));
  5756.                     params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(now));
  5757.                 }
  5758.                 
  5759.                 if(secondiAnzianitaPerIniziareSpedireNuovoMessaggio!=null && secondiAnzianitaPerIniziareSpedireNuovoMessaggio>0) {
  5760.                     if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5761.                         
  5762.                         // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora
  5763.                         long nowMillis = dataAttualeVerificaNow.getTime(); // uso il now calcolato per la variabile isMinutiMancantiPassaggioOraLegaleVersoOraSolare
  5764.                         
  5765.                         // controllo che non sia nell'intervallo tra now e i precedenti x secondi (ORA_REGISTRAZIONE<=?)
  5766.                         Timestamp anzianita = new Timestamp(nowMillis-(1000*secondiAnzianitaPerIniziareSpedireNuovoMessaggio.intValue()));
  5767.                         pstmtMsgDaSpedire.setTimestamp(index++, anzianita);
  5768.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(anzianita));
  5769.                         
  5770.                         // se è una data futura rispetto al now la prendo in considerazione essendo il problema dell'ora, comunque sempre nella solita partizione giornaliera (ORA_REGISTRAZIONE>? AND ORA_REGISTRAZIONE<?)
  5771.                         Timestamp futuro = new Timestamp(nowMillis);
  5772.                         pstmtMsgDaSpedire.setTimestamp(index++, futuro);
  5773.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(futuro));
  5774.                         
  5775.                         Timestamp futuroPlusHour = new Timestamp(nowMillis+
  5776.                                 (1000*60*60)+ // un'ora
  5777.                                 (1000*60+5)); // aggiungo altri 5 minuti
  5778.                         pstmtMsgDaSpedire.setTimestamp(index++, futuroPlusHour);
  5779.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(futuroPlusHour));

  5781.                     }
  5782.                     else {
  5783.                         Timestamp anzianita = new Timestamp(DateManager.getTimeMillis()-(1000*secondiAnzianitaPerIniziareSpedireNuovoMessaggio.intValue()));
  5784.                         pstmtMsgDaSpedire.setTimestamp(index++, anzianita);
  5785.                         params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(anzianita));
  5786.                     }
  5787.                 }
  5788.                 
  5789.                 pstmtMsgDaSpedire.setString(index++,tipo); params.add(tipo);
  5790.                 pstmtMsgDaSpedire.setString(index++,ConsegnaContenutiApplicativi.ID_MODULO); params.add(ConsegnaContenutiApplicativi.ID_MODULO);
  5791.                 pstmtMsgDaSpedire.setString(index++,GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE); params.add(GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE);
  5792.                 pstmtMsgDaSpedire.setInt(index++,CostantiDB.FALSE); params.add(CostantiDB.FALSE);
  5793.                 pstmtMsgDaSpedire.setString(index++,coda); params.add(coda);
  5794.                 
  5795.                 if(serviziApplicativiPrioritari!=null && serviziApplicativiPrioritari.length>0) {
  5796.                     if(serviziApplicativiPrioritari.length==1) {
  5797.                         pstmtMsgDaSpedire.setString(index++,serviziApplicativiPrioritari[0]);
  5798.                         params.add(serviziApplicativiPrioritari[0]);
  5799.                     }
  5800.                 }
  5801.                 else if(priorita!=null) {
  5802.                     pstmtMsgDaSpedire.setString(index++,priorita);
  5803.                     params.add(priorita);
  5804.                 }
  5805.                 
  5806.                 if(verificaPresenzaMessaggiDaRispedire) {
  5807.                     if(!verificaPresenzaMessaggiDaRispedire_consideraAncheNuoviMessaggi) {
  5808.                         // per non intralciare con la "prima" consegna
  5809.                         pstmtMsgDaSpedire.setString(index++, TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  5810.                         params.add(TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  5811.                     }
  5812.                 }
  5813.                 else {
  5814.                     pstmtMsgDaSpedire.setString(index++, TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  5815.                     params.add(TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  5816.                 }
  5817.                 
  5818.                 pstmtMsgDaSpedire.setTimestamp(index++,new Timestamp(riconsegna.getTime()));
  5819.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(riconsegna));
  5820.                 if(isMinutiMancantiPassaggioOraLegaleVersoOraSolare) {
  5821.                     Timestamp futuroPlusHour = new Timestamp(riconsegna.getTime()+
  5822.                             (1000*60*60)+ // un'ora
  5823.                             (1000*60+5)); // aggiungo altri 5 minuti
  5824.                     pstmtMsgDaSpedire.setTimestamp(index++,new Timestamp(futuroPlusHour.getTime()));
  5825.                     params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(futuroPlusHour));
  5826.                 }
  5827.                 
  5828.                 pstmtMsgDaSpedire.setTimestamp(index++, new Timestamp(dataRilascioLock.getTime()));
  5829.                 params.add(org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(dataRilascioLock));

  5831.                 long startDateSQLCommand = DateManager.getTimeMillis();
  5832.                 String comandoSql = null;
  5833.                 if(debug) {
  5834.                     comandoSql = DBUtils.formatSQLString(queryString, params.toArray());
  5835.                     loggerSql.debug("[QUERY] (Messaggi.daRispedire) ["+comandoSql+"] ...");
  5836.                 }
  5837.                 rs = pstmtMsgDaSpedire.executeQuery();
  5838.                 long endDateSQLCommand = DateManager.getTimeMillis();
  5839.                 long diffSQLCommand = endDateSQLCommand - startDateSQLCommand;
  5840.                 if(debug) {
  5841.                     loggerSql.debug("[QUERY] (Messaggi.daRispedire) ["+comandoSql+"] effettuata in "+Utilities.convertSystemTimeIntoStringMillisecondi(diffSQLCommand, true));
  5842.                 }
  5843.                 
  5844.                 int countLimit = 0;
  5845.                 while(rs.next()){
  5846.                     MessaggioServizioApplicativo msg = new MessaggioServizioApplicativo();
  5847.                     msg.setIdTransazione(rs.getString("idtransazione"));
  5848.                     msg.setIdMessaggio(rs.getString("idmess"));
  5849.                     msg.setServizioApplicativo(rs.getString("sa"));
  5850.                     int sbSoap = rs.getInt("sbSoap");
  5851.                     msg.setSbustamentoSoap(sbSoap==CostantiDB.TRUE);
  5852.                     int sbInfoProt = rs.getInt("sbProtocol");
  5853.                     msg.setSbustamentoInformazioniProtocollo(sbInfoProt==CostantiDB.TRUE);
  5854.                     msg.setNomePorta(rs.getString("nomePorta"));
  5855.                     
  5856.                     Timestamp oraRegistrazione = rs.getTimestamp("oramess");
  5857.                     msg.setOraRegistrazione(oraRegistrazione);
  5858.                     
  5859.                     Timestamp dataPresaInConsegna = rs.getTimestamp("saLock");
  5860.                     msg.setDataPresaInConsegna(dataPresaInConsegna);
  5861.                     msg.setClusterIdPresaInConsegna(rs.getString("saCluster"));
  5862.                     int attesaTransazioneCapostipite = rs.getInt("attesa");
  5863.                     msg.setAttesaEsitoTransazioneCapostipite(attesaTransazioneCapostipite==CostantiDB.TRUE);
  5864.                     
  5865.                     idMsg.add(msg);
  5866.                     // LIMIT Applicativo
  5867.                     if(Configurazione.getSqlQueryObjectType()==null){
  5868.                         countLimit++;
  5869.                         if(countLimit==limit)
  5870.                             break;
  5871.                     }
  5872.                     
  5873.                     //System.out.println("CHECK verificaPresenzaMessaggiDaRispedire="+verificaPresenzaMessaggiDaRispedire+" TROVATO ["+msg.getIdMessaggio()+"]");
  5874.                 }
  5875.                 rs.close(); rs = null;
  5876.                 pstmtMsgDaSpedire.close(); pstmtMsgDaSpedire=null;

  5878.                 if(debug) {
  5879.                     loggerSql.debug("[QUERY] (Messaggi.daRispedire) ["+comandoSql+"] trovati risultati: "+idMsg.size());
  5880.                 }
  5881.                                 
  5882.                 return idMsg;

  5884.             } catch(Exception e) {
  5885.                 String errorMsg = "[GestoreMessaggi.readMessaggiDaRiconsegnareIntoBox] errore, queryString["+queryString+"]: "+e.getMessage();
  5886.                 try{
  5887.                     if(rs != null)
  5888.                         rs.close();
  5889.                 } catch(Exception er) {
  5890.                     // close
  5891.                 }
  5892.                 try{
  5893.                     if(pstmtMsgDaSpedire != null)
  5894.                         pstmtMsgDaSpedire.close();
  5895.                 } catch(Exception er) {
  5896.                     // close
  5897.                 }
  5898.                 loggerSql.error(errorMsg,e);
  5899.                 throw new GestoreMessaggiException(errorMsg,e);
  5900.             }
  5901.             // else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  5902.             // NOP stateful only
  5903.         }else{
  5904.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  5905.         }

  5907.     }
  5908.     public static boolean isMinutiMancantiPassaggioOraLegaleVersoOraSolare(boolean debug, RunnableLogger loggerSql, Date data, int minutes) {
  5909.         try {
  5910.             String format = DaylightSavingUtils.getOffsetFormat();
  5911.             String dataString = DateUtils.getSimpleDateFormat(format).format(data);
  5912.             TimeTransitionType type = DaylightSavingUtils.getTimeChangePendingTodayWithoutOffset(dataString, format);
  5913.             if(type!=null && TimeTransitionType.FROM_DAYLIGHT_SAVING_TO_STANDARD_TIME.equals(type)) {
  5914.                 long m = DaylightSavingUtils.minutesUntilNextTransitionWithoutOffset(dataString, format);
  5915.                 boolean result = m>-1 && m<=minutes; // va bene anche 0 perchè rappresenta l'ultimo minuto 
  5916.                 if(debug) {
  5917.                     loggerSql.debug("(Messaggi.daRispedire) verifico data ["+dataString+"] minutes: "+m+"   Risultato: "+result);
  5918.                 }
  5919.                 return result;
  5920.             }
  5921.             return false;
  5922.         }catch(Throwable t) {
  5923.             loggerSql.error("Calcolo 'isMinutiMancantiPassaggioOraLegaleVersoOraSolare' fallito: "+t.getMessage(),t);
  5924.         }
  5925.         return false;
  5926.     }
  5927.     
  5928.     public MessaggioServizioApplicativo readInfoDestinatario(String applicativo, boolean debug, Logger log)throws GestoreMessaggiException{
  5929.         List<MessaggioServizioApplicativo> l = _readInfoDestinatari(debug, log, applicativo);
  5930.         if(l!=null && !l.isEmpty()) {
  5931.             if(l.size()==1) {
  5932.                 return l.get(0);
  5933.             }
  5934.             else {
  5935.                 throw new GestoreMessaggiException("More than one result ("+l.size()+")");
  5936.             }
  5937.         }
  5938.         return null;
  5939.     }
  5940.     public List<MessaggioServizioApplicativo> readInfoDestinatari(boolean debug, Logger log)throws GestoreMessaggiException{
  5941.         return _readInfoDestinatari(debug, log, null);
  5942.     }
  5943.     private List<MessaggioServizioApplicativo> _readInfoDestinatari(boolean debug, Logger log, String applicativo)throws GestoreMessaggiException{

  5945.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  5946.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta())
  5947.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  5948.             Connection connectionDB = stateful.getConnectionDB();

  5950.             List<MessaggioServizioApplicativo> idMsg = new ArrayList<MessaggioServizioApplicativo>();

  5952.             PreparedStatement pstmtMsg = null;
  5953.             ResultSet rs = null;
  5954.             String queryString = null;
  5955.             String tipo = null;
  5956.             try{   
  5957.                 // tipo
  5958.                 tipo = Costanti.INBOX;

  5960.                 // Query per Ricerca messaggi eliminati (proprietario:EliminatoreMesaggi)
  5961.                 if(Configurazione.getSqlQueryObjectType()==null){
  5962.                     StringBuilder query = new StringBuilder();
  5963.                     query.append("SELECT "+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO as idmess, ");
  5964.                     query.append(" "+GestoreMessaggi.MESSAGGI+".id_transazione as idtransazione, ");
  5965.                     query.append(" "+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE as oramess, ");
  5966.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO as sa, ");
  5967.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SBUSTAMENTO_SOAP as sbSoap, ");
  5968.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SBUSTAMENTO_INFO_PROTOCOL as sbProtocol ");
  5969.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".NOME_PORTA as nomePorta ");
  5970.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".LOCK_CONSEGNA as lock ");
  5971.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".CLUSTER_ID as cluster ");
  5972.                     query.append(" "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ATTESA_ESITO as attesa ");
  5973.                     
  5974.                     query.append(" FROM ");
  5975.                     query.append(GestoreMessaggi.MESSAGGI);
  5976.                     query.append(",");
  5977.                     query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5978.                     
  5979.                     query.append(" WHERE ");
  5980.                     
  5981.                     // join
  5982.                     query.append(" ");
  5983.                     query.append(GestoreMessaggi.MESSAGGI);
  5984.                     query.append(".ID_MESSAGGIO=");
  5985.                     query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  5986.                     query.append(".ID_MESSAGGIO AND ");
  5987.                     
  5988.                     query.append(" ").append(GestoreMessaggi.MESSAGGI).append(".ID_MESSAGGIO=? AND ");
  5989.                     query.append(" ").append(GestoreMessaggi.MESSAGGI).append(".TIPO=?");
  5990.                     if(applicativo!=null) {
  5991.                         query.append(" AND ").append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI).append(".SERVIZIO_APPLICATIVO=?");
  5992.                     }

  5994.                     queryString = query.toString();
  5995.                 }else{

  5997.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  5998.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI,"m");
  5999.                     sqlQueryObject.addFromTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI,"sa");
  6000.                     
  6001.                     sqlQueryObject.addSelectAliasField("m", "ID_MESSAGGIO", "idmess");
  6002.                     sqlQueryObject.addSelectAliasField("m", "ORA_REGISTRAZIONE", "oramess");
  6003.                     sqlQueryObject.addSelectAliasField("m", "id_transazione", "idtransazione");
  6004.                     sqlQueryObject.addSelectAliasField("sa", "SERVIZIO_APPLICATIVO", "sa");
  6005.                     sqlQueryObject.addSelectAliasField("sa", "SBUSTAMENTO_SOAP", "sbSoap");
  6006.                     sqlQueryObject.addSelectAliasField("sa", "SBUSTAMENTO_INFO_PROTOCOL", "sbProtocol");
  6007.                     sqlQueryObject.addSelectAliasField("sa", "NOME_PORTA", "nomePorta");
  6008.                     sqlQueryObject.addSelectAliasField("sa", "LOCK_CONSEGNA", "lock");
  6009.                     sqlQueryObject.addSelectAliasField("sa", "CLUSTER_ID", "cluster");
  6010.                     sqlQueryObject.addSelectAliasField("sa", "ATTESA_ESITO", "attesa");
  6011.                     sqlQueryObject.addSelectField("m","ORA_REGISTRAZIONE");
  6012.                     sqlQueryObject.addSelectField("m","PROPRIETARIO");
  6013.                     sqlQueryObject.addSelectField("m","TIPO");
  6014.                     
  6015.                     // join
  6016.                     sqlQueryObject.addWhereCondition("m.ID_MESSAGGIO=sa.ID_MESSAGGIO");
  6017.                     
  6018.                     sqlQueryObject.addWhereCondition("m.ID_MESSAGGIO=?");
  6019.                     sqlQueryObject.addWhereCondition("m.TIPO=?");
  6020.                     if(applicativo!=null) {
  6021.                         sqlQueryObject.addWhereCondition("sa.SERVIZIO_APPLICATIVO=?");
  6022.                     }
  6023.                     
  6024.                     sqlQueryObject.setANDLogicOperator(true);
  6025.                     
  6026.                     queryString = sqlQueryObject.createSQLQuery();
  6027.                 }
  6028.                 //System.out.println("QUERY MESSAGGI ELIMINATI IS: ["+queryString+"]  1["+idModuloCleaner+"]  2["+tipo+"]");

  6030.                 //log.debug("Query: "+query);
  6031.                 pstmtMsg = connectionDB.prepareStatement(queryString);
  6032.                 int index = 1;
  6033.                 pstmtMsg.setString(index++,this.idBusta);
  6034.                 pstmtMsg.setString(index++,tipo);
  6035.                 if(applicativo!=null) {
  6036.                     pstmtMsg.setString(index++,applicativo);
  6037.                 }
  6038.                 
  6039.                 String terzoArgomento = "";
  6040.                 if(applicativo!=null) {
  6041.                     terzoArgomento = " 3["+applicativo+"]";
  6042.                 }
  6043.                 
  6044.                 long startDateSQLCommand = DateManager.getTimeMillis();
  6045.                 if(debug)
  6046.                     log.debug("[QUERY] (Messaggi.readDestinatari) ["+queryString+"] 1["+this.idBusta+"] 2["+tipo+"]"+terzoArgomento+" ...");
  6047.                 rs = pstmtMsg.executeQuery();
  6048.                 long endDateSQLCommand = DateManager.getTimeMillis();
  6049.                 long diffSQLCommand = endDateSQLCommand - startDateSQLCommand;
  6050.                 if(debug)
  6051.                     log.debug("[QUERY] (Messaggi.readDestinatari) ["+queryString+"] 1["+this.idBusta+"] 2["+tipo+"]"+terzoArgomento+" effettuata in "+Utilities.convertSystemTimeIntoStringMillisecondi(diffSQLCommand, true));

  6053.                 while(rs.next()){
  6054.                     MessaggioServizioApplicativo msg = new MessaggioServizioApplicativo();
  6055.                     msg.setIdTransazione(rs.getString("idtransazione"));
  6056.                     msg.setIdMessaggio(rs.getString("idmess"));
  6057.                     msg.setServizioApplicativo(rs.getString("sa"));
  6058.                     int sbSoap = rs.getInt("sbSoap");
  6059.                     msg.setSbustamentoSoap(sbSoap==CostantiDB.TRUE);
  6060.                     int sbInfoProt = rs.getInt("sbProtocol");
  6061.                     msg.setSbustamentoInformazioniProtocollo(sbInfoProt==CostantiDB.TRUE);
  6062.                     msg.setNomePorta(rs.getString("nomePorta"));
  6063.                     
  6064.                     Timestamp oraRegistrazione = rs.getTimestamp("oramess");
  6065.                     msg.setOraRegistrazione(oraRegistrazione);
  6066.                     
  6067.                     Timestamp dataPresaInConsegna = rs.getTimestamp("lock");
  6068.                     msg.setDataPresaInConsegna(dataPresaInConsegna);
  6069.                     msg.setClusterIdPresaInConsegna(rs.getString("cluster"));
  6070.                     int attesaTransazioneCapostipite = rs.getInt("attesa");
  6071.                     msg.setAttesaEsitoTransazioneCapostipite(attesaTransazioneCapostipite==CostantiDB.TRUE);
  6072.                     
  6073.                     idMsg.add(msg);

  6075.                 }
  6076.                 rs.close();
  6077.                 pstmtMsg.close();

  6079.                 return idMsg;

  6081.             } catch(Exception e) {
  6082.                 String errorMsg = "[GestoreMessaggi.readDestinatari] errore, queryString["+queryString+"]: "+e.getMessage();
  6083.                 try{
  6084.                     if(rs != null)
  6085.                         rs.close();
  6086.                 } catch(Exception er) {
  6087.                     // close
  6088.                 }
  6089.                 try{
  6090.                     if(pstmtMsg != null)
  6091.                         pstmtMsg.close();
  6092.                 } catch(Exception er) {
  6093.                     // close
  6094.                 }
  6095.                 log.error(errorMsg,e);
  6096.                 throw new GestoreMessaggiException(errorMsg,e);
  6097.             }
  6098.             // else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  6099.             // NOP stateful only
  6100.         }else{
  6101.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  6102.         }

  6104.     }

  6106.     public void updateMessaggioPresaInCosegna(String servizioApplicativo, String clusterId,
  6107.             boolean debug, RunnableLogger loggerSql) throws GestoreMessaggiException {
  6108.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  6109.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  6110.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  6111.             Connection connectionDB = stateMSG.getConnectionDB();

  6113.             PreparedStatement pstmt = null;
  6114.             try{

  6116.                 Timestamp now = DateManager.getTimestamp();
  6117.                 
  6118.                 
  6119.                 // Costruzione Query Update
  6120.                 String query = "UPDATE "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" SET LOCK_CONSEGNA=?, CLUSTER_ID=? WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  6121.                 //log.debug("Query: "+query);
  6122.                 pstmt= connectionDB.prepareStatement(query);
  6123.                 int index = 1;
  6124.                 pstmt.setTimestamp(index++,now);
  6125.                 pstmt.setString(index++,clusterId);
  6126.                 pstmt.setString(index++,this.idBusta);
  6127.                 pstmt.setString(index++,servizioApplicativo);

  6129.                 int row = pstmt.executeUpdate();
  6130.                 if(debug) {
  6131.                     loggerSql.debug("(rows update: "+row+") UPDATE MSG_SERVIZI_APPLICATIVI SET LOCK_CONSEGNA='"+DateUtils.getSimpleDateFormatMs().format(now)+"', CLUSTER_ID='"+cluster_id+"' WHERE ID_MESSAGGIO='"+this.idBusta+"' AND SERVIZIO_APPLICATIVO='"+servizioApplicativo+"'");
  6132.                 }
  6133.                 
  6134.                 pstmt.close();

  6136.             } catch(Exception e) {
  6137.                 try{
  6138.                     if( pstmt != null  )
  6139.                         pstmt.close();
  6140.                 } catch(Exception er) {
  6141.                     // close
  6142.                 }
  6143.                 String msgError = "ERROR updateMessaggioPresaInCosegna: "+e.getMessage();
  6144.                 loggerSql.error(msgError,e);
  6145.                 throw new GestoreMessaggiException(msgError,e);
  6146.             }

  6148.         }else{
  6149.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  6150.         }
  6151.     }
  6152.     
  6153.     public void releaseMessaggioPresaInCosegna(String servizioApplicativo, String clusterId,
  6154.             boolean debug, RunnableLogger loggerSql) throws GestoreMessaggiException {
  6155.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  6156.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  6157.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  6158.             Connection connectionDB = stateMSG.getConnectionDB();

  6160.             PreparedStatement pstmt = null;
  6161.             try{

  6163.                 // Costruzione Query Update
  6164.                 String query = "UPDATE "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" SET LOCK_CONSEGNA=?, CLUSTER_ID=? WHERE ID_MESSAGGIO=? AND SERVIZIO_APPLICATIVO=?";
  6165.                 //log.debug("Query: "+query);
  6166.                 pstmt= connectionDB.prepareStatement(query);
  6167.                 int index = 1;
  6168.                 pstmt.setTimestamp(index++,null);
  6169.                 pstmt.setString(index++,null);
  6170.                 pstmt.setString(index++,this.idBusta);
  6171.                 pstmt.setString(index++,servizioApplicativo);

  6173.                 int row = pstmt.executeUpdate();
  6174.                 if(debug) {
  6175.                     loggerSql.debug("(rows update: "+row+") UPDATE MSG_SERVIZI_APPLICATIVI SET LOCK_CONSEGNA=null, CLUSTER_ID=null WHERE ID_MESSAGGIO='"+this.idBusta+"' AND SERVIZIO_APPLICATIVO='"+servizioApplicativo+"'");
  6176.                 }
  6177.                 
  6178.                 pstmt.close();

  6180.             } catch(Exception e) {
  6181.                 try{
  6182.                     if( pstmt != null  )
  6183.                         pstmt.close();
  6184.                 } catch(Exception er) {
  6185.                     // close
  6186.                 }
  6187.                 String msgError = "ERROR releaseMessaggioPresaInCosegna: "+e.getMessage();
  6188.                 loggerSql.error(msgError,e);
  6189.                 throw new GestoreMessaggiException(msgError,e);
  6190.             }

  6192.         }else{
  6193.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  6194.         }
  6195.     }
  6196.     
  6197.     public void releaseMessaggiPresaInCosegna(String queue, String clusterId,
  6198.             boolean debug, RunnableLogger loggerSql) throws GestoreMessaggiException {
  6199.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  6200.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  6201.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  6202.             Connection connectionDB = stateMSG.getConnectionDB();

  6204.             PreparedStatement pstmt = null;
  6205.             try{

  6207.                 // Costruzione Query Update
  6208.                 String condition = (clusterId==null || "".equals(clusterId)) ? "CLUSTER_ID is null" : " CLUSTER_ID=?";
  6209.                 String query = "UPDATE "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" SET LOCK_CONSEGNA=?, CLUSTER_ID=? WHERE "+condition+" AND CODA=? AND LOCK_CONSEGNA is not null AND LOCK_CONSEGNA<?";
  6210.                 //log.debug("Query: "+query);
  6211.                 pstmt= connectionDB.prepareStatement(query);
  6212.                 int index = 1;
  6213.                 pstmt.setTimestamp(index++,null);
  6214.                 pstmt.setString(index++,null);
  6215.                 if((clusterId!=null && !"".equals(clusterId))) {
  6216.                     pstmt.setString(index++,clusterId);
  6217.                 }
  6218.                 pstmt.setString(index++,queue);
  6219.                 pstmt.setTimestamp(index++, TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA);

  6221.                 int row = pstmt.executeUpdate();
  6222.                 if(debug) {
  6223.                     loggerSql.debug("(rows update: "+row+") (clusterID: "+clusterId+") UPDATE MSG_SERVIZI_APPLICATIVI SET LOCK_CONSEGNA=null, CLUSTER_ID=null WHERE "+
  6224.                             condition+" AND CODA="+queue+" AND LOCK_CONSEGNA is not null AND LOCK_CONSEGNA<"+
  6225.                             DateUtils.getSimpleDateFormatMs().format(TimerConsegnaContenutiApplicativiThread.LOCK_CONSEGNA_FUTURA));
  6226.                 }
  6227.                 
  6228.                 pstmt.close();

  6230.             } catch(Exception e) {
  6231.                 try{
  6232.                     if( pstmt != null  )
  6233.                         pstmt.close();
  6234.                 } catch(Exception er) {
  6235.                     // close
  6236.                 }
  6237.                 String msgError = "ERROR releaseMessaggioPresaInCosegna: "+e.getMessage();
  6238.                 loggerSql.error(msgError,e);
  6239.                 throw new GestoreMessaggiException(msgError,e);
  6240.             }

  6242.         }else{
  6243.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  6244.         }
  6245.     }

  6247.     public void releaseAttesaEsiti(boolean debug, Logger log) throws GestoreMessaggiException {
  6248.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  6249.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  6250.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  6251.             Connection connectionDB = stateMSG.getConnectionDB();

  6253.             PreparedStatement pstmt = null;
  6254.             try{

  6256.                 // Costruzione Query Update
  6257.                 String query = "UPDATE "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" SET ATTESA_ESITO=? WHERE ID_MESSAGGIO=?";
  6258.                 //log.debug("Query: "+query);
  6259.                 pstmt= connectionDB.prepareStatement(query);
  6260.                 int index = 1;
  6261.                 pstmt.setInt(index++,CostantiDB.FALSE);
  6262.                 pstmt.setString(index++,this.idBusta);

  6264.                 int row = pstmt.executeUpdate();
  6265.                 if(debug) {
  6266.                     log.debug("(rows update: "+row+") UPDATE MSG_SERVIZI_APPLICATIVI SET ATTESA_ESITO="+CostantiDB.FALSE+" WHERE ID_MESSAGGIO='"+this.idBusta+"'");
  6267.                 }
  6268.                 
  6269.                 pstmt.close();

  6271.             } catch(Exception e) {
  6272.                 try{
  6273.                     if( pstmt != null  )
  6274.                         pstmt.close();
  6275.                 } catch(Exception er) {
  6276.                     // close
  6277.                 }
  6278.                 String msgError = "ERROR releaseMessaggioPresaInCosegna: "+e.getMessage();
  6279.                 log.error(msgError,e);
  6280.                 throw new GestoreMessaggiException(msgError,e);
  6281.             }

  6283.         }else{
  6284.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  6285.         }
  6286.     }
  6287.     



  6291.     
  6292.     
  6293.     /* ------------- UTILITY PER LETTURA MESSAGGI DA ELIMINARE -------------- */
  6294.     
  6295.     public static Date getOraRegistrazioneMassima(Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws GestoreMessaggiException{
  6296.         return _getOraRegistrazione(false, connectionDB , tipoDatabase, logQuery, logger);
  6297.     }
  6298.     public static Date getOraRegistrazioneMinima(Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws GestoreMessaggiException{
  6299.         return _getOraRegistrazione(true, connectionDB , tipoDatabase, logQuery, logger);
  6300.     }
  6301.     private static Date _getOraRegistrazione(boolean min, Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws GestoreMessaggiException{
  6302.     
  6303.         PreparedStatement pstmt = null;
  6304.         ResultSet rs = null;
  6305.         String queryString = null;
  6306.         try{    
  6307.         
  6308.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6309.             if(min) {
  6310.                 sqlQueryObject.addSelectMinField(MESSAGGI_COLUMN_ORA_REGISTRAZIONE, "check_data");
  6311.             }
  6312.             else {
  6313.                 sqlQueryObject.addSelectMaxField(MESSAGGI_COLUMN_ORA_REGISTRAZIONE, "check_data");
  6314.             }
  6315.             sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  6316.             sqlQueryObject.setANDLogicOperator(true);
  6317.             queryString = sqlQueryObject.createSQLQuery();
  6318.             if(logQuery) {
  6319.                 logger.debug("Esecuzione query ["+queryString+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6320.             }
  6321.             
  6322.             pstmt = connectionDB.prepareStatement(queryString);
  6323.             rs = pstmt.executeQuery();
  6324.             
  6325.             if(logQuery) {
  6326.                 logger.debug("Esecuzione query ["+queryString+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata");
  6327.             }
  6328.             
  6329.             if(rs.next()) {
  6330.                 return rs.getTimestamp("check_data");
  6331.             }
  6332.             return null;
  6333.         
  6334.         } catch(Exception e) {
  6335.             String errorMsg = "[GestoreMessaggi.getOraRegistrazione] errore, queryString["+queryString+"]: "+e.getMessage();
  6336.             throw new GestoreMessaggiException(errorMsg,e);
  6337.         }
  6338.         finally {
  6339.             try{
  6340.                 if(rs != null)
  6341.                     rs.close();
  6342.             } catch(Exception er) {
  6343.                 // close
  6344.             }
  6345.             try{
  6346.                 if(pstmt != null)
  6347.                     pstmt.close();
  6348.             } catch(Exception er) {
  6349.                 // close
  6350.             }
  6351.         }
  6352.     }
  6353.     
  6354.     public static int countMessaggiInutiliIntoInBox(Connection connectionDB , String tipoDatabase, 
  6355.             boolean logQuery, Logger logger,
  6356.             Date leftDate, Date rightDate) throws GestoreMessaggiException{
  6357.         return _countMessaggiIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, null);
  6358.     }
  6359.     public static int countMessaggiInutiliIntoOutBox(Connection connectionDB , String tipoDatabase, 
  6360.             boolean logQuery, Logger logger,
  6361.             Date leftDate, Date rightDate) throws GestoreMessaggiException{
  6362.         return _countMessaggiIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, null);
  6363.     }
  6364.     public static int countMessaggiScadutiIntoInBox(Connection connectionDB , String tipoDatabase, 
  6365.             boolean logQuery, Logger logger,
  6366.             Date leftDate, Date rightDate,
  6367.             long scadenzaMsg) throws GestoreMessaggiException{
  6368.         return _countMessaggiIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, scadenzaMsg);
  6369.     }
  6370.     public static int countMessaggiScadutiIntoOutBox(Connection connectionDB , String tipoDatabase, 
  6371.             boolean logQuery, Logger logger,
  6372.             Date leftDate, Date rightDate,
  6373.             long scadenzaMsg) throws GestoreMessaggiException{
  6374.         return _countMessaggiIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, scadenzaMsg);
  6375.     }
  6376.     private static int _countMessaggiIntoBox(boolean searchIntoInbox, Connection connectionDB , String tipoDatabase, 
  6377.             boolean logQuery, Logger logger,
  6378.             Date leftDate, Date rightDate,
  6379.             Long scadenzaMsg) throws GestoreMessaggiException{
  6380.         
  6381.         String tipo = null; 
  6382.         if(searchIntoInbox)
  6383.             tipo = Costanti.INBOX;
  6384.         else
  6385.             tipo = Costanti.OUTBOX;
  6386.         
  6387.         String idModuloCleaner = TimerGestoreMessaggi.ID_MODULO;
  6388.         
  6389.         PreparedStatement pstmt = null;
  6390.         ResultSet rs = null;
  6391.         String queryString = null;
  6392.         try{    
  6393.         
  6394.             // Query per Ricerca messaggi scaduti
  6395.             // Algoritmo:
  6396.             //    if( (now-timeout) > oraRegistrazione )
  6397.             //       msgScaduto
  6398.             java.sql.Timestamp scandenzaT = null;
  6399.             if(scadenzaMsg!=null) {
  6400.                 long scadenza = DateManager.getTimeMillis() - (scadenzaMsg * 60 * 1000);
  6401.                 scandenzaT = new java.sql.Timestamp(scadenza);
  6402.             }
  6403.             
  6404.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6405.             sqlQueryObject.addSelectCountField("totale_msg");
  6406.             sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  6407.             if(leftDate!=null) {
  6408.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_ORA_REGISTRAZIONE+">=?");
  6409.             }
  6410.             if(rightDate!=null) {
  6411.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_ORA_REGISTRAZIONE+"<=?");
  6412.             }
  6413.             if(scadenzaMsg!=null) {
  6414.                 sqlQueryObject.addWhereCondition("? > "+MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  6415.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6416.             }
  6417.             else {
  6418.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6419.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_PROPRIETARIO+"=?");
  6420.             }
  6421.             sqlQueryObject.setANDLogicOperator(true);
  6422.             queryString = sqlQueryObject.createSQLQuery();

  6424.             pstmt = connectionDB.prepareStatement(queryString);
  6425.             int index = 1;
  6426.             List<Object> objects = new ArrayList<>();
  6427.             if(leftDate!=null) {
  6428.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  6429.                 pstmt.setTimestamp(index++, leftDateT);
  6430.                 if(logQuery) {
  6431.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDateT));
  6432.                 }
  6433.             }
  6434.             if(rightDate!=null) {
  6435.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  6436.                 pstmt.setTimestamp(index++, rightDateT);
  6437.                 if(logQuery) {
  6438.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDateT));
  6439.                 }
  6440.             }
  6441.             if(scadenzaMsg!=null) {
  6442.                 pstmt.setTimestamp(index++,scandenzaT);
  6443.                 if(logQuery) {
  6444.                     objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  6445.                 }
  6446.                 
  6447.                 pstmt.setString(index++,tipo);
  6448.                 if(logQuery) {
  6449.                     objects.add(tipo);
  6450.                 }
  6451.             }
  6452.             else {
  6453.                 pstmt.setString(index++,tipo);
  6454.                 if(logQuery) {
  6455.                     objects.add(tipo);
  6456.                 }
  6457.                 pstmt.setString(index++,idModuloCleaner);
  6458.                 if(logQuery) {
  6459.                     objects.add(idModuloCleaner);
  6460.                 }
  6461.             }
  6462.             
  6463.             String query = null;
  6464.             if(logQuery) {
  6465.                 query = DBUtils.formatSQLString(queryString, objects.toArray());
  6466.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6467.             }
  6468.             rs = pstmt.executeQuery();
  6469.             
  6470.             int res = 0;
  6471.             if(rs.next()) {
  6472.                 res = rs.getInt("totale_msg");
  6473.             }
  6474.             
  6475.             if(logQuery) {
  6476.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; trovati "+res+" risultati");
  6477.             }
  6478.             
  6479.             return res;
  6480.         
  6481.         } catch(Exception e) {
  6482.             String errorMsg = "[GestoreMessaggi.countMessaggiIntoBox] errore, queryString["+queryString+"]: "+e.getMessage();
  6483.             throw new GestoreMessaggiException(errorMsg,e);
  6484.         }
  6485.         finally {
  6486.             try{
  6487.                 if(rs != null)
  6488.                     rs.close();
  6489.             } catch(Exception er) {
  6490.                 // close
  6491.             }
  6492.             try{
  6493.                 if(pstmt != null)
  6494.                     pstmt.close();
  6495.             } catch(Exception er) {
  6496.                 // close
  6497.             }
  6498.         }
  6499.     }
  6500.     
  6501.     public static SortedMap<Integer> deleteMessaggiInutiliIntoInBox(Connection connectionDB , String tipoDatabase, 
  6502.             boolean logQuery, Logger logger,
  6503.             Date leftDate, Date rightDate, IGestoreRepository repository) throws GestoreMessaggiException{
  6504.         return _deleteMessaggiIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, null, repository);
  6505.     }
  6506.     public static SortedMap<Integer> deleteMessaggiInutiliIntoOutBox(Connection connectionDB , String tipoDatabase, 
  6507.             boolean logQuery, Logger logger,
  6508.             Date leftDate, Date rightDate, IGestoreRepository repository) throws GestoreMessaggiException{
  6509.         return _deleteMessaggiIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, null, repository);
  6510.     }
  6511.     public static SortedMap<Integer> deleteMessaggiScadutiIntoInBox(Connection connectionDB , String tipoDatabase, 
  6512.             boolean logQuery, Logger logger,
  6513.             Date leftDate, Date rightDate,
  6514.             long scadenzaMsg, IGestoreRepository repository) throws GestoreMessaggiException{
  6515.         return _deleteMessaggiIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, scadenzaMsg, repository);
  6516.     }
  6517.     public static SortedMap<Integer> deleteMessaggiScadutiIntoOutBox(Connection connectionDB , String tipoDatabase, 
  6518.             boolean logQuery, Logger logger,
  6519.             Date leftDate, Date rightDate,
  6520.             long scadenzaMsg, IGestoreRepository repository) throws GestoreMessaggiException{
  6521.         return _deleteMessaggiIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, leftDate, rightDate, scadenzaMsg, repository);
  6522.     }
  6523.     private static SortedMap<Integer> _deleteMessaggiIntoBox(boolean searchIntoInbox, Connection connectionDB , String tipoDatabase, 
  6524.             boolean logQuery, Logger logger,
  6525.             Date leftDate, Date rightDate,
  6526.             Long scadenzaMsg, IGestoreRepository repository) throws GestoreMessaggiException{
  6527.         
  6528.         SortedMap<Integer> mapTabelleRigheEliminate = new SortedMap<Integer>();
  6529.         
  6530.         String tipo = null; 
  6531.         if(searchIntoInbox)
  6532.             tipo = Costanti.INBOX;
  6533.         else
  6534.             tipo = Costanti.OUTBOX;
  6535.         
  6536.         String idModuloCleaner = TimerGestoreMessaggi.ID_MODULO;
  6537.         
  6538.         PreparedStatement pstmt = null;
  6539.         String deleteString = null;
  6540.         try{    
  6541.         
  6542.             // Query per Ricerca messaggi scaduti
  6543.             // Algoritmo:
  6544.             //    if( (now-timeout) > oraRegistrazione )
  6545.             //       msgScaduto
  6546.             java.sql.Timestamp scandenzaT = null;
  6547.             if(scadenzaMsg!=null) {
  6548.                 long scadenza = DateManager.getTimeMillis() - (scadenzaMsg * 60 * 1000);
  6549.                 scandenzaT = new java.sql.Timestamp(scadenza);
  6550.             }
  6551.             
  6552.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6553.             sqlQueryObject.addSelectField(MESSAGGI_COLUMN_ID_MESSAGGIO);
  6554.             sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  6555.             if(leftDate!=null) {
  6556.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_ORA_REGISTRAZIONE+">=?");
  6557.             }
  6558.             if(rightDate!=null) {
  6559.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_ORA_REGISTRAZIONE+"<=?");
  6560.             }
  6561.             if(scadenzaMsg!=null) {
  6562.                 sqlQueryObject.addWhereCondition("? > "+MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  6563.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6564.             }
  6565.             else {
  6566.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6567.                 sqlQueryObject.addWhereCondition(MESSAGGI_COLUMN_PROPRIETARIO+"=?");
  6568.             }
  6569.             sqlQueryObject.setANDLogicOperator(true);
  6570.             
  6571.             
  6572.             // **** Prima prova ad eliminare eventuali SIL rimasti appesi al messaggio, se il messaggio e' di tipo INBOX ****
  6573.             if(searchIntoInbox){
  6574.                 
  6575.                 ISQLQueryObject sqlQueryObjectMsgServiziApplicativi = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6576.                 sqlQueryObjectMsgServiziApplicativi.addDeleteTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  6577.                 sqlQueryObjectMsgServiziApplicativi.addWhereINSelectSQLCondition(false, MSG_SERVIZI_APPLICATIVI_COLUMN_ID_MESSAGGIO, sqlQueryObject);
  6578.                 sqlQueryObjectMsgServiziApplicativi.setANDLogicOperator(true);
  6579.                 
  6580.                 deleteString = sqlQueryObjectMsgServiziApplicativi.createSQLDelete();
  6581.                 pstmt = connectionDB.prepareStatement(deleteString);
  6582.                 int index = 1;
  6583.                 List<Object> objects = new ArrayList<>();
  6584.                 if(leftDate!=null) {
  6585.                     java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  6586.                     pstmt.setTimestamp(index++, leftDateT);
  6587.                     if(logQuery) {
  6588.                         objects.add(DateUtils.getSimpleDateFormatMs().format(leftDate));
  6589.                     }
  6590.                 }
  6591.                 if(rightDate!=null) {
  6592.                     java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  6593.                     pstmt.setTimestamp(index++, rightDateT);
  6594.                     if(logQuery) {
  6595.                         objects.add(DateUtils.getSimpleDateFormatMs().format(rightDate));
  6596.                     }
  6597.                 }
  6598.                 if(scadenzaMsg!=null) {
  6599.                     pstmt.setTimestamp(index++,scandenzaT);
  6600.                     if(logQuery) {
  6601.                         objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  6602.                     }
  6603.                     
  6604.                     pstmt.setString(index++,tipo);
  6605.                     if(logQuery) {
  6606.                         objects.add(tipo);
  6607.                     }
  6608.                 }
  6609.                 else {
  6610.                     pstmt.setString(index++,tipo);
  6611.                     if(logQuery) {
  6612.                         objects.add(tipo);
  6613.                     }
  6614.                     pstmt.setString(index++,idModuloCleaner);
  6615.                     if(logQuery) {
  6616.                         objects.add(idModuloCleaner);
  6617.                     }
  6618.                 }
  6619.                 
  6620.                 String query = null;
  6621.                 if(logQuery) {
  6622.                     query = DBUtils.formatSQLString(deleteString, objects.toArray());
  6623.                     logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6624.                 }
  6625.                 int result = pstmt.executeUpdate();
  6626.                 pstmt.close();
  6627.                 pstmt = null;
  6628.                 
  6629.                 if(logQuery) {
  6630.                     logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  6631.                 }
  6632.                 mapTabelleRigheEliminate.add(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI, result);
  6633.             }
  6634.             
  6635.             
  6636.             // **** Prova poi ad eliminare il messaggio su DB ****
  6637.             
  6638.             ISQLQueryObject sqlQueryObjectDefinizioneMessaggi = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6639.             sqlQueryObjectDefinizioneMessaggi.addDeleteTable(GestoreMessaggi.DEFINIZIONE_MESSAGGI);
  6640.             sqlQueryObjectDefinizioneMessaggi.addWhereCondition(DEFINIZIONE_MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6641.             sqlQueryObjectDefinizioneMessaggi.addWhereINSelectSQLCondition(false, DEFINIZIONE_MESSAGGI_COLUMN_ID_MESSAGGIO, sqlQueryObject);
  6642.             sqlQueryObjectDefinizioneMessaggi.setANDLogicOperator(true);
  6643.             
  6644.             deleteString = sqlQueryObjectDefinizioneMessaggi.createSQLDelete();
  6645.             pstmt = connectionDB.prepareStatement(deleteString);
  6646.             int index = 1;
  6647.             List<Object> objects = new ArrayList<>();
  6648.             pstmt.setString(index++,tipo);
  6649.             if(logQuery) {
  6650.                 objects.add(tipo);
  6651.             }
  6652.             if(leftDate!=null) {
  6653.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  6654.                 pstmt.setTimestamp(index++, leftDateT);
  6655.                 if(logQuery) {
  6656.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDate));
  6657.                 }
  6658.             }
  6659.             if(rightDate!=null) {
  6660.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  6661.                 pstmt.setTimestamp(index++, rightDateT);
  6662.                 if(logQuery) {
  6663.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDate));
  6664.                 }
  6665.             }
  6666.             if(scadenzaMsg!=null) {
  6667.                 pstmt.setTimestamp(index++,scandenzaT);
  6668.                 if(logQuery) {
  6669.                     objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  6670.                 }
  6671.                 
  6672.                 pstmt.setString(index++,tipo);
  6673.                 if(logQuery) {
  6674.                     objects.add(tipo);
  6675.                 }
  6676.             }
  6677.             else {
  6678.                 pstmt.setString(index++,tipo);
  6679.                 if(logQuery) {
  6680.                     objects.add(tipo);
  6681.                 }
  6682.                 pstmt.setString(index++,idModuloCleaner);
  6683.                 if(logQuery) {
  6684.                     objects.add(idModuloCleaner);
  6685.                 }
  6686.             }
  6687.             
  6688.             String query = null;
  6689.             if(logQuery) {
  6690.                 query = DBUtils.formatSQLString(deleteString, objects.toArray());
  6691.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6692.             }
  6693.             int result = pstmt.executeUpdate();
  6694.             pstmt.close();
  6695.             pstmt = null;
  6696.             
  6697.             if(logQuery) {
  6698.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  6699.             }
  6700.             mapTabelleRigheEliminate.add(GestoreMessaggi.DEFINIZIONE_MESSAGGI, result);
  6701.             
  6702.             
  6703.             
  6704.             if(repository!=null) {
  6705.                 
  6706.                 // **** Eliminazione buste (non possiedono l'accesso da history o l'accesso da profilo) ****
  6707.                 
  6708.                 
  6709.                 // lista 
  6710.                 ISQLQueryObject sqlQueryObjectRepositoryBusteJoin = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6711.                 sqlQueryObjectRepositoryBusteJoin.addSelectField(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY_COLUMN_ID_MESSAGGIO);
  6712.                 sqlQueryObjectRepositoryBusteJoin.addFromTable(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY);
  6713.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  6714.                 sqlQueryObjectRepositoryBusteJoin.addWhereINSelectSQLCondition(false, org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY_COLUMN_ID_MESSAGGIO, sqlQueryObject);
  6715.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(false, repository.createSQLCondition_enableOnlyPdd(), repository.createSQLCondition_disabledAll());
  6716.                 sqlQueryObjectRepositoryBusteJoin.setANDLogicOperator(true);
  6717.                 
  6718.                 _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  6719.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_RISCONTRI, 
  6720.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_RISCONTRI_COLUMN_TIPO_MESSAGGIO, 
  6721.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_RISCONTRI_COLUMN_ID_MESSAGGIO,
  6722.                         tipo, leftDate, rightDate, scandenzaT, idModuloCleaner, sqlQueryObjectRepositoryBusteJoin,
  6723.                         mapTabelleRigheEliminate);
  6724.                 
  6725.                 _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  6726.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_TRASMISSIONI, 
  6727.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_TRASMISSIONI_COLUMN_TIPO_MESSAGGIO, 
  6728.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_TRASMISSIONI_COLUMN_ID_MESSAGGIO,
  6729.                         tipo, leftDate, rightDate, scandenzaT, idModuloCleaner, sqlQueryObjectRepositoryBusteJoin,
  6730.                         mapTabelleRigheEliminate);
  6731.                 
  6732.                 _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  6733.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_ECCEZIONI, 
  6734.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_ECCEZIONI_COLUMN_TIPO_MESSAGGIO, 
  6735.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_ECCEZIONI_COLUMN_ID_MESSAGGIO,
  6736.                         tipo, leftDate, rightDate, scandenzaT, idModuloCleaner, sqlQueryObjectRepositoryBusteJoin,
  6737.                         mapTabelleRigheEliminate);
  6738.                 
  6739.                 _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  6740.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_EXT_INFO, 
  6741.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_EXT_INFO_COLUMN_TIPO_MESSAGGIO, 
  6742.                         org.openspcoop2.protocol.engine.constants.Costanti.LISTA_EXT_INFO_COLUMN_ID_MESSAGGIO,
  6743.                         tipo, leftDate, rightDate, scandenzaT, idModuloCleaner, sqlQueryObjectRepositoryBusteJoin,
  6744.                         mapTabelleRigheEliminate);
  6745.                 
  6746.                 _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  6747.                         org.openspcoop2.protocol.engine.constants.Costanti.PROFILO_ASINCRONO, 
  6748.                         org.openspcoop2.protocol.engine.constants.Costanti.PROFILO_ASINCRONO_COLUMN_TIPO_MESSAGGIO, 
  6749.                         org.openspcoop2.protocol.engine.constants.Costanti.PROFILO_ASINCRONO_COLUMN_ID_MESSAGGIO,
  6750.                         tipo, leftDate, rightDate, scandenzaT, idModuloCleaner, sqlQueryObjectRepositoryBusteJoin,
  6751.                         mapTabelleRigheEliminate);
  6752.                 
  6753.                 if(!searchIntoInbox){
  6754.                     _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  6755.                             org.openspcoop2.protocol.engine.constants.Costanti.RISCONTRI_DA_RICEVERE, 
  6756.                             null, 
  6757.                             org.openspcoop2.protocol.engine.constants.Costanti.RISCONTRI_COLUMN_ID_MESSAGGIO,
  6758.                             tipo, leftDate, rightDate, scandenzaT, idModuloCleaner, sqlQueryObjectRepositoryBusteJoin,
  6759.                             mapTabelleRigheEliminate);
  6760.                 }
  6761.                 
  6762.                 
  6763.                 // Eliminazione busta reale
  6764.                 
  6765.                 ISQLQueryObject sqlQueryObjectRepositoryBuste = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6766.                 sqlQueryObjectRepositoryBuste.addDeleteTable(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY);
  6767.                 sqlQueryObjectRepositoryBuste.addWhereCondition(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  6768.                 sqlQueryObjectRepositoryBuste.addWhereINSelectSQLCondition(false, org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY_COLUMN_ID_MESSAGGIO, sqlQueryObject);
  6769.                 sqlQueryObjectRepositoryBuste.addWhereCondition(false, repository.createSQLCondition_enableOnlyPdd(), repository.createSQLCondition_disabledAll());
  6770.                 sqlQueryObjectRepositoryBuste.setANDLogicOperator(true);
  6771.                 
  6772.                 deleteString = sqlQueryObjectRepositoryBuste.createSQLDelete();
  6773.                 pstmt = connectionDB.prepareStatement(deleteString);
  6774.                 index = 1;
  6775.                 objects = new ArrayList<>();
  6776.                 pstmt.setString(index++,tipo);
  6777.                 if(logQuery) {
  6778.                     objects.add(tipo);
  6779.                 }
  6780.                 if(leftDate!=null) {
  6781.                     java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  6782.                     pstmt.setTimestamp(index++, leftDateT);
  6783.                     if(logQuery) {
  6784.                         objects.add(DateUtils.getSimpleDateFormatMs().format(leftDate));
  6785.                     }
  6786.                 }
  6787.                 if(rightDate!=null) {
  6788.                     java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  6789.                     pstmt.setTimestamp(index++, rightDateT);
  6790.                     if(logQuery) {
  6791.                         objects.add(DateUtils.getSimpleDateFormatMs().format(rightDate));
  6792.                     }
  6793.                 }
  6794.                 if(scadenzaMsg!=null) {
  6795.                     pstmt.setTimestamp(index++,scandenzaT);
  6796.                     if(logQuery) {
  6797.                         objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  6798.                     }
  6799.                     
  6800.                     pstmt.setString(index++,tipo);
  6801.                     if(logQuery) {
  6802.                         objects.add(tipo);
  6803.                     }
  6804.                 }
  6805.                 else {
  6806.                     pstmt.setString(index++,tipo);
  6807.                     if(logQuery) {
  6808.                         objects.add(tipo);
  6809.                     }
  6810.                     pstmt.setString(index++,idModuloCleaner);
  6811.                     if(logQuery) {
  6812.                         objects.add(idModuloCleaner);
  6813.                     }
  6814.                 }
  6815.                 
  6816.                 query = null;
  6817.                 if(logQuery) {
  6818.                     query = DBUtils.formatSQLString(deleteString, objects.toArray());
  6819.                     logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6820.                 }
  6821.                 result = pstmt.executeUpdate();
  6822.                 pstmt.close();
  6823.                 pstmt = null;
  6824.                 
  6825.                 if(logQuery) {
  6826.                     logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  6827.                 }
  6828.                 mapTabelleRigheEliminate.add(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY, result);
  6829.             }
  6830.             
  6831.             
  6832.             
  6833.             
  6834.             // **** Eliminazione finale ****
  6835.             
  6836.             ISQLQueryObject sqlQueryObjectMessaggi = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6837.             sqlQueryObjectMessaggi.addDeleteTable(GestoreMessaggi.MESSAGGI);
  6838.             if(leftDate!=null) {
  6839.                 sqlQueryObjectMessaggi.addWhereCondition(MESSAGGI_COLUMN_ORA_REGISTRAZIONE+">=?");
  6840.             }
  6841.             if(rightDate!=null) {
  6842.                 sqlQueryObjectMessaggi.addWhereCondition(MESSAGGI_COLUMN_ORA_REGISTRAZIONE+"<=?");
  6843.             }
  6844.             if(scadenzaMsg!=null) {
  6845.                 sqlQueryObjectMessaggi.addWhereCondition("? > "+MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  6846.                 sqlQueryObjectMessaggi.addWhereCondition(MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6847.             }
  6848.             else {
  6849.                 sqlQueryObjectMessaggi.addWhereCondition(MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  6850.                 sqlQueryObjectMessaggi.addWhereCondition(MESSAGGI_COLUMN_PROPRIETARIO+"=?");
  6851.             }
  6852.             sqlQueryObjectMessaggi.setANDLogicOperator(true);
  6853.             
  6854.             deleteString = sqlQueryObjectMessaggi.createSQLDelete();
  6855.             pstmt = connectionDB.prepareStatement(deleteString);
  6856.             index = 1;
  6857.             objects = new ArrayList<>();
  6858.             if(leftDate!=null) {
  6859.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  6860.                 pstmt.setTimestamp(index++, leftDateT);
  6861.                 if(logQuery) {
  6862.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDate));
  6863.                 }
  6864.             }
  6865.             if(rightDate!=null) {
  6866.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  6867.                 pstmt.setTimestamp(index++, rightDateT);
  6868.                 if(logQuery) {
  6869.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDate));
  6870.                 }
  6871.             }
  6872.             if(scadenzaMsg!=null) {
  6873.                 pstmt.setTimestamp(index++,scandenzaT);
  6874.                 if(logQuery) {
  6875.                     objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  6876.                 }
  6877.                 
  6878.                 pstmt.setString(index++,tipo);
  6879.                 if(logQuery) {
  6880.                     objects.add(tipo);
  6881.                 }
  6882.             }
  6883.             else {
  6884.                 pstmt.setString(index++,tipo);
  6885.                 if(logQuery) {
  6886.                     objects.add(tipo);
  6887.                 }
  6888.                 pstmt.setString(index++,idModuloCleaner);
  6889.                 if(logQuery) {
  6890.                     objects.add(idModuloCleaner);
  6891.                 }
  6892.             }
  6893.             
  6894.             query = null;
  6895.             if(logQuery) {
  6896.                 query = DBUtils.formatSQLString(deleteString, objects.toArray());
  6897.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6898.             }
  6899.             result = pstmt.executeUpdate();
  6900.             pstmt.close();
  6901.             pstmt = null;
  6902.             
  6903.             if(logQuery) {
  6904.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  6905.             }
  6906.             mapTabelleRigheEliminate.add(GestoreMessaggi.MESSAGGI, result);
  6907.             
  6908.             
  6909.             
  6910.             return mapTabelleRigheEliminate;
  6911.         
  6912.         } catch(Exception e) {
  6913.             String errorMsg = "[GestoreMessaggi.deleteMessaggiIntoBox] errore, deleteString["+deleteString+"]: "+e.getMessage();
  6914.             throw new GestoreMessaggiException(errorMsg,e);
  6915.         } finally {
  6916.             try{
  6917.                 if(pstmt != null)
  6918.                     pstmt.close();
  6919.             } catch(Exception er) { 
  6920.                 // close
  6921.             }
  6922.         }
  6923.     }
  6924.     
  6925.     
  6926.     private static void _deleteListaRepositoryBuste(String tipoDatabase, Connection connectionDB, boolean logQuery, Logger logger,
  6927.             String nomeTabella, String nomeColonnaTipoMessaggio, String nomeColonnaIdMessaggio,
  6928.             String tipo, Date leftDate, Date rightDate, Timestamp scandenzaT, String idModuloCleaner, ISQLQueryObject sqlQueryObjectRepositoryBusteJoin,
  6929.             SortedMap<Integer> mapTabelleRigheEliminate) throws Exception {
  6930.         
  6931.         // Eliminazione busta reale
  6932.         
  6933.         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  6934.         sqlQueryObject.addDeleteTable(nomeTabella);
  6935.         if(nomeColonnaTipoMessaggio!=null) {
  6936.             sqlQueryObject.addWhereCondition(nomeColonnaTipoMessaggio+"=?");
  6937.         }
  6938.         sqlQueryObject.addWhereINSelectSQLCondition(false, nomeColonnaIdMessaggio, sqlQueryObjectRepositoryBusteJoin);
  6939.         sqlQueryObject.setANDLogicOperator(true);
  6940.         
  6941.         String deleteString = sqlQueryObject.createSQLDelete();
  6942.         PreparedStatement pstmt = null;
  6943.         try{    
  6944.             pstmt = connectionDB.prepareStatement(deleteString);
  6945.             int index = 1;
  6946.             List<Object> objects = new ArrayList<>();
  6947.             if(nomeColonnaTipoMessaggio!=null) {
  6948.                 pstmt.setString(index++,tipo);
  6949.                 if(logQuery) {
  6950.                     objects.add(tipo);
  6951.                 }
  6952.             }
  6953.             pstmt.setString(index++,tipo); // due volte per via della ricerca ciclica
  6954.             if(logQuery) {
  6955.                 objects.add(tipo);
  6956.             }
  6957.             if(leftDate!=null) {
  6958.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  6959.                 pstmt.setTimestamp(index++, leftDateT);
  6960.                 if(logQuery) {
  6961.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDate));
  6962.                 }
  6963.             }
  6964.             if(rightDate!=null) {
  6965.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  6966.                 pstmt.setTimestamp(index++, rightDateT);
  6967.                 if(logQuery) {
  6968.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDate));
  6969.                 }
  6970.             }
  6971.             if(scandenzaT!=null) {
  6972.                 pstmt.setTimestamp(index++,scandenzaT);
  6973.                 if(logQuery) {
  6974.                     objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  6975.                 }
  6976.                 
  6977.                 pstmt.setString(index++,tipo);
  6978.                 if(logQuery) {
  6979.                     objects.add(tipo);
  6980.                 }
  6981.             }
  6982.             else {
  6983.                 pstmt.setString(index++,tipo);
  6984.                 if(logQuery) {
  6985.                     objects.add(tipo);
  6986.                 }
  6987.                 pstmt.setString(index++,idModuloCleaner);
  6988.                 if(logQuery) {
  6989.                     objects.add(idModuloCleaner);
  6990.                 }
  6991.             }
  6992.             
  6993.             String query = null;
  6994.             if(logQuery) {
  6995.                 query = DBUtils.formatSQLString(deleteString, objects.toArray());
  6996.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  6997.             }
  6998.             int result = pstmt.executeUpdate();
  6999.             pstmt.close();
  7000.             pstmt = null;
  7001.             
  7002.             if(logQuery) {
  7003.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  7004.             }
  7005.             mapTabelleRigheEliminate.add(nomeTabella, result);
  7006.         } finally {
  7007.             try{
  7008.                 if(pstmt != null)
  7009.                     pstmt.close();
  7010.             } catch(Exception er) { 
  7011.                 // close
  7012.             }
  7013.         }
  7014.     }
  7015.     
  7016.     
  7017.     



  7021.     /* ------------- LETTURA MESSAGGI DA ELIMINARE -------------- */

  7023.     /**
  7024.      * Cerca nella tabella MESSAGGI le entry che possiedono come proprietario l'ID del modulo utilizzato per l'eliminazione.
  7025.      * Ritorna un array di Stringhe contenenti l'ID di messaggi presenti nella cartella INBOX 
  7026.      * che possiedono come proprietario l'ID 
  7027.      * del modulo utilizzato per l'eliminazione (parametro idModuloCleaner)
  7028.      *
  7029.      * @param idModuloCleaner ID del modulo utilizzato per l'eliminazione
  7030.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7031.      * 
  7032.      */
  7033.     public List<String> readMessaggiInutiliIntoInbox(String idModuloCleaner,int limit,boolean logQuery, boolean orderBy,
  7034.             Date data)throws GestoreMessaggiException{
  7035.         return this.readMessaggiInutiliIntoBox(true,idModuloCleaner,limit,logQuery,orderBy,data);
  7036.     }
  7037.     /**
  7038.      * Cerca nella tabella MESSAGGI le entry che possiedono come proprietario l'ID del modulo utilizzato per l'eliminazione.
  7039.      * Ritorna un array di Stringhe contenenti l'ID di messaggi presenti nella cartella OUTBOX 
  7040.      * che possiedono come proprietario l'ID 
  7041.      * del modulo utilizzato per l'eliminazione (parametro idModuloCleaner)
  7042.      *
  7043.      * @param idModuloCleaner ID del modulo utilizzato per l'eliminazione
  7044.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7045.      * 
  7046.      */
  7047.     public List<String> readMessaggiInutiliIntoOutbox(String idModuloCleaner,int limit,boolean logQuery, boolean orderBy,
  7048.             Date data)throws GestoreMessaggiException{
  7049.         return this.readMessaggiInutiliIntoBox(false,idModuloCleaner,limit,logQuery,orderBy,data);
  7050.     }

  7052.     /**
  7053.      * Cerca nella tabella MESSAGGI le entry che possiedono come proprietario l'ID del modulo utilizzato per l'eliminazione.
  7054.      * Ritorna un array di Stringhe contenenti l'ID di messaggi presenti nella cartella INBOX (se searchIntoInbox=true)
  7055.      * o nella cartella OUTBOX (se searchIntoInbox=false) che possiedono come proprietario l'ID 
  7056.      * del modulo utilizzato per l'eliminazione (parametro idModuloCleaner)
  7057.      *
  7058.      * @param searchIntoInbox Cerca nella cartella INBOX (se true) o nella cartella OUTBOX (se false)
  7059.      * @param idModuloCleaner ID del modulo utilizzato per l'eliminazione
  7060.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7061.      * 
  7062.      */
  7063.     private List<String> readMessaggiInutiliIntoBox(boolean searchIntoInbox,
  7064.             String idModuloCleaner,int limit,boolean logQuery, boolean orderBy,
  7065.             Date data)throws GestoreMessaggiException{
  7066.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  7067.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  7068.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;          
  7069.             Connection connectionDB = stateful.getConnectionDB();

  7071.             List<String> idMsg = new ArrayList<>();

  7073.             PreparedStatement pstmtMsgEliminati = null;
  7074.             ResultSet rs = null;
  7075.             String queryString = null;
  7076.             try{    
  7077.                 // tipo
  7078.                 String tipo = null; 
  7079.                 if(searchIntoInbox)
  7080.                     tipo = Costanti.INBOX;
  7081.                 else
  7082.                     tipo = Costanti.OUTBOX;

  7084.                 // Query per Ricerca messaggi eliminati (proprietario:EliminatoreMesaggi)
  7085.                 if(Configurazione.getSqlQueryObjectType()==null){
  7086.                     StringBuilder query = new StringBuilder();
  7087.                     query.append("SELECT ").append(GestoreMessaggi.MESSAGGI_COLUMN_ID_MESSAGGIO).append(" FROM ");
  7088.                     query.append(GestoreMessaggi.MESSAGGI);
  7089.                     query.append(" WHERE ").append(GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO).append("=? AND ").append(GestoreMessaggi.MESSAGGI_COLUMN_PROPRIETARIO).append("=? ");
  7090.                     if(data!=null) {
  7091.                         query.append(" AND ").append(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE).append("<=?");
  7092.                     }
  7093.                     queryString = query.toString();
  7094.                 }else{
  7095.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  7096.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_ID_MESSAGGIO);
  7097.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  7098.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_PROPRIETARIO);
  7099.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO);
  7100.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  7101.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  7102.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI_COLUMN_PROPRIETARIO+"=?");
  7103.                     if(data!=null) {
  7104.                         sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE+"<=?");
  7105.                     }
  7106.                     sqlQueryObject.setANDLogicOperator(true);
  7107.                     if(orderBy){
  7108.                         sqlQueryObject.addOrderBy(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  7109.                         sqlQueryObject.setSortType(true);
  7110.                     }
  7111.                     sqlQueryObject.setLimit(limit);
  7112.                     queryString = sqlQueryObject.createSQLQuery();
  7113.                 }
  7114.                 //System.out.println("QUERY MESSAGGI ELIMINATI IS: ["+queryString+"]  1["+idModuloCleaner+"]  2["+tipo+"]");

  7116.                 //log.debug("Query: "+query);
  7117.                 pstmtMsgEliminati = connectionDB.prepareStatement(queryString);
  7118.                 pstmtMsgEliminati.setString(1,tipo);
  7119.                 pstmtMsgEliminati.setString(2,idModuloCleaner);
  7120.                 java.sql.Timestamp nowT = null;
  7121.                 if(data!=null) {
  7122.                     nowT = new java.sql.Timestamp(data.getTime());
  7123.                     pstmtMsgEliminati.setTimestamp(3,nowT);
  7124.                 }

  7126.                 long startDateSQLCommand = DateManager.getTimeMillis();
  7127.                 if(logQuery)
  7128.                     this.log.debug("[QUERY] (Messaggi.eliminatiLogicamente) ["+queryString+"] 1["+tipo+"] 2["+idModuloCleaner+"] 3["+nowT+"] ...");
  7129.                 rs = pstmtMsgEliminati.executeQuery();
  7130.                 long endDateSQLCommand = DateManager.getTimeMillis();
  7131.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  7132.                 if(logQuery)
  7133.                     this.log.debug("[QUERY] (Messaggi.eliminatiLogicamente) ["+queryString+"] 1["+tipo+"] 2["+idModuloCleaner+"] 3["+nowT+"] effettuata in "+secondSQLCommand+" secondi");

  7135.                 int countLimit = 0;
  7136.                 while(rs.next()){
  7137.                     idMsg.add(rs.getString("ID_MESSAGGIO"));
  7138.                     // LIMIT Applicativo
  7139.                     if(Configurazione.getSqlQueryObjectType()==null){
  7140.                         countLimit++;
  7141.                         if(countLimit==limit)
  7142.                             break;
  7143.                     }
  7144.                 }
  7145.                 rs.close();
  7146.                 pstmtMsgEliminati.close();

  7148.                 return idMsg;

  7150.             } catch(Exception e) {
  7151.                 String errorMsg = "[GestoreMessaggi.readMessaggiInutiliIntoBox] errore, queryString["+queryString+"]: "+e.getMessage();
  7152.                 try{
  7153.                     if(rs != null)
  7154.                         rs.close();
  7155.                 } catch(Exception er) {
  7156.                     // close
  7157.                 }
  7158.                 try{
  7159.                     if(pstmtMsgEliminati != null)
  7160.                         pstmtMsgEliminati.close();
  7161.                 } catch(Exception er) {
  7162.                     // close
  7163.                 }
  7164.                 this.log.error(errorMsg,e);
  7165.                 throw new GestoreMessaggiException(errorMsg,e);
  7166.             }
  7167.             // else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  7168.             // NOP stateful only
  7169.         }else{
  7170.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  7171.         }
  7172.     }






  7179.     /**
  7180.      * Cerca nella tabella MESSAGGI i messaggi che sono nelle cartelle da un intervallo di tempo definito da: <var>timeout<var>
  7181.      *
  7182.      * @param scadenzaMsg Intervallo di scadenza dei messaggi
  7183.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7184.      * 
  7185.      */
  7186.     public List<String> readMessaggiScadutiIntoInbox(long scadenzaMsg,int limit,boolean logQuery, boolean orderBy, Date data)throws GestoreMessaggiException{
  7187.         return this.readMessaggiScadutiIntoBox(true,scadenzaMsg,limit,logQuery,orderBy,data);
  7188.     }
  7189.     /**
  7190.      * Cerca nella tabella MESSAGGI i messaggi che sono nelle cartelle da un intervallo di tempo definito da: <var>timeout<var>
  7191.      *
  7192.      * @param scadenzaMsg Intervallo di scadenza dei messaggi
  7193.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7194.      * 
  7195.      */
  7196.     public List<String> readMessaggiScadutiIntoOutbox(long scadenzaMsg,int limit,boolean logQuery, boolean orderBy, Date data)throws GestoreMessaggiException{
  7197.         return this.readMessaggiScadutiIntoBox(false,scadenzaMsg,limit,logQuery,orderBy,data);
  7198.     }

  7200.     /**
  7201.      * Cerca nella tabella MESSAGGI i messaggi che sono nelle cartelle da un intervallo di tempo definito da: <var>timeout<var>
  7202.      *
  7203.      * @param searchIntoInbox Cerca nella cartella INBOX (se true) o nella cartella OUTBOX (se false)
  7204.      * @param scadenzaMsg Intervallo di scadenza dei messaggi
  7205.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7206.      * 
  7207.      */
  7208.     private List<String> readMessaggiScadutiIntoBox(boolean searchIntoInbox,long scadenzaMsg,int limit,boolean logQuery, boolean orderBy, Date data)throws GestoreMessaggiException{
  7209.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  7210.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  7211.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  7213.             Connection connectionDB = stateful.getConnectionDB();
  7214.             List<String> idMsg = new ArrayList<>();

  7216.             PreparedStatement pstmtMsgScaduti = null;
  7217.             ResultSet rs = null;
  7218.             String queryString = null;
  7219.             try{    
  7220.                 // tipo
  7221.                 String tipo = null; 
  7222.                 if(searchIntoInbox)
  7223.                     tipo = Costanti.INBOX;
  7224.                 else
  7225.                     tipo = Costanti.OUTBOX;

  7227.                 // Query per Ricerca messaggi scaduti
  7228.                 // Algoritmo:
  7229.                 //    if( (now-timeout) > oraRegistrazione )
  7230.                 //       msgScaduto
  7231.                 long scadenza = DateManager.getTimeMillis() - (scadenzaMsg * 60 * 1000);
  7232.                 java.sql.Timestamp scandenzaT = new java.sql.Timestamp(scadenza);

  7234.                 // Query per Ricerca messaggi eliminati (proprietario:EliminatoreMesaggi)
  7235.                 if(Configurazione.getSqlQueryObjectType()==null){
  7236.                     StringBuilder query = new StringBuilder();
  7237.                     query.append("SELECT ").append(GestoreMessaggi.MESSAGGI_COLUMN_ID_MESSAGGIO).append(" FROM ");
  7238.                     query.append(GestoreMessaggi.MESSAGGI);
  7239.                     query.append(" WHERE ? > ").append(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE).append(" AND ").append(GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO).append("=?");
  7240.                     if(data!=null) {
  7241.                         query.append(" AND ").append(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE).append("<=?");
  7242.                     }
  7243.                     queryString = query.toString();
  7244.                 }else{
  7245.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  7246.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_ID_MESSAGGIO);
  7247.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  7248.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO);
  7249.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  7250.                     sqlQueryObject.addWhereCondition("? > "+GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  7251.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?");
  7252.                     if(data!=null) {
  7253.                         sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE+"<=?");
  7254.                     }
  7255.                     sqlQueryObject.setANDLogicOperator(true);
  7256.                     if(orderBy){
  7257.                         sqlQueryObject.addOrderBy(GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE);
  7258.                         sqlQueryObject.setSortType(true);
  7259.                     }
  7260.                     sqlQueryObject.setLimit(limit);
  7261.                     queryString = sqlQueryObject.createSQLQuery();
  7262.                 }
  7263.                 //System.out.println("QUERY MESSAGGI SCADUTI IS: ["+queryString+"] ["+scandenzaT+"] ["+tipo+"]");

  7265.                 pstmtMsgScaduti = connectionDB.prepareStatement(queryString);
  7266.                 pstmtMsgScaduti.setTimestamp(1,scandenzaT);
  7267.                 pstmtMsgScaduti.setString(2,tipo);
  7268.                 java.sql.Timestamp nowT = null;
  7269.                 if(data!=null) {
  7270.                     nowT = new java.sql.Timestamp(data.getTime());
  7271.                     pstmtMsgScaduti.setTimestamp(3,nowT);
  7272.                 }

  7274.                 long startDateSQLCommand = DateManager.getTimeMillis();
  7275.                 if(logQuery)
  7276.                     this.log.debug("[QUERY] (Messaggi.scaduti) ["+queryString+"] 1["+scandenzaT+"] 2["+tipo+"] 3["+nowT+"]...");
  7277.                 rs = pstmtMsgScaduti.executeQuery();
  7278.                 long endDateSQLCommand = DateManager.getTimeMillis();
  7279.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  7280.                 if(logQuery)
  7281.                     this.log.debug("[QUERY] (Messaggi.scaduti) ["+queryString+"] 1["+scandenzaT+"] 2["+tipo+"] 3["+nowT+"] effettuata in "+secondSQLCommand+" secondi");

  7283.                 int countLimit = 0;
  7284.                 while(rs.next()){
  7285.                     idMsg.add(rs.getString("ID_MESSAGGIO"));
  7286.                     // LIMIT Applicativo
  7287.                     if(Configurazione.getSqlQueryObjectType()==null){
  7288.                         countLimit++;
  7289.                         if(countLimit==limit)
  7290.                             break;
  7291.                     }
  7292.                 }
  7293.                 rs.close();
  7294.                 pstmtMsgScaduti.close();

  7296.                 return idMsg;

  7298.             } catch(Exception e) {
  7299.                 String errorMsg = "[GestoreMessaggi.readMessaggiScadutiIntoBox] errore, queryString["+queryString+"]: "+e.getMessage();
  7300.                 try{
  7301.                     if(rs != null)
  7302.                         rs.close();
  7303.                 } catch(Exception er) {
  7304.                     // close
  7305.                 }
  7306.                 try{
  7307.                     if(pstmtMsgScaduti != null)
  7308.                         pstmtMsgScaduti.close();
  7309.                 } catch(Exception er) {
  7310.                     // close
  7311.                 }
  7312.                 this.log.error(errorMsg,e);
  7313.                 throw new GestoreMessaggiException(errorMsg,e);
  7314.             }
  7315.         } // else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  7316.         // NOP stateful only
  7317.         else{
  7318.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  7319.         }
  7320.     }








  7329.     public boolean existsServiziApplicativiDestinatariMessaggio()throws GestoreMessaggiException{

  7331.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  7332.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  7333.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  7335.             Connection connectionDB = stateful.getConnectionDB();
  7336.             PreparedStatement pstmtExistsAnotherServiziApplicativi = null;
  7337.             ResultSet rs = null;
  7338.             String queryString = null;
  7339.             try{    
  7340.                 StringBuilder query = new StringBuilder();
  7341.                 query.append("SELECT SERVIZIO_APPLICATIVO FROM ");
  7342.                 query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  7343.                 query.append(" WHERE ID_MESSAGGIO=?");
  7344.                 queryString = query.toString();

  7346.                 pstmtExistsAnotherServiziApplicativi =  connectionDB.prepareStatement(queryString);
  7347.                 pstmtExistsAnotherServiziApplicativi.setString(1,this.idBusta);
  7348.                 rs = pstmtExistsAnotherServiziApplicativi.executeQuery();
  7349.                 boolean risultato = rs.next();
  7350.                 rs.close();
  7351.                 pstmtExistsAnotherServiziApplicativi.close();

  7353.                 return risultato;

  7355.             } catch(Exception e) {
  7356.                 String errorMsg = "[GestoreMessaggi.existsServiziApplicativiDestinatariMessaggio] errore, queryString["+queryString+"]: "+e.getMessage();
  7357.                 try{
  7358.                     if(rs != null)
  7359.                         rs.close();
  7360.                 } catch(Exception er) {
  7361.                     // close
  7362.                 }
  7363.                 try{
  7364.                     if(pstmtExistsAnotherServiziApplicativi != null)
  7365.                         pstmtExistsAnotherServiziApplicativi.close();
  7366.                 } catch(Exception er) {
  7367.                     // close
  7368.                 }
  7369.                 this.log.error(errorMsg,e);
  7370.                 throw new GestoreMessaggiException(errorMsg,e);
  7371.             }   
  7372.         }// else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  7373.         // NOP stateful only
  7374.         else{
  7375.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  7376.         }
  7377.     }

  7379.     /**
  7380.      * Cerca nella tabella MESSAGGI i messaggi destinati al servizio RicezioneContenutiApplicativi che sono stati registrati dopo lo scadere
  7381.      * del timeout per il servizio. Ritorna l'idBusta+'@'+nomeServizioApplicativo dove il servizio applicativo e' di tipo connectionReply
  7382.      *
  7383.      * @param timeout Intervallo di timeout del servizio
  7384.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7385.      * 
  7386.      */
  7387.     public List<String> readMsgForRicezioneContenutiApplicativiNonGestiti(long timeout,int limit,boolean logQuery, boolean orderBy)throws GestoreMessaggiException{
  7388.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  7389.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  7390.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  7391.             Connection connectionDB = stateful.getConnectionDB();

  7393.             List<String> idMsg = new ArrayList<>();

  7395.             PreparedStatement pstmtMsgScaduti = null;
  7396.             ResultSet rs = null;
  7397.             String queryString = null;
  7398.             try{    
  7399.                 // Query per Ricerca messaggi scaduti
  7400.                 // Algoritmo:
  7401.                 //    if( (now-timeout) > oraRegistrazione )
  7402.                 //       msgScaduto
  7403.                 long scadenza = DateManager.getTimeMillis() - (timeout);
  7404.                 java.sql.Timestamp scandenzaT = new java.sql.Timestamp(scadenza);
  7405.                 //System.out.println("TIMEOUT RICEZIONE CONTENUTI APPLICATIVI["+scandenzaT+"]");

  7407.                 // Query per Ricerca messaggi eliminati (proprietario:EliminatoreMesaggi)
  7408.                 if(Configurazione.getSqlQueryObjectType()==null){
  7409.                     StringBuilder query = new StringBuilder();
  7410.                     query.append("SELECT "+GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO as identificativoBusta,"+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".SERVIZIO_APPLICATIVO FROM ");
  7411.                     query.append(GestoreMessaggi.MESSAGGI);
  7412.                     query.append(",");
  7413.                     query.append(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  7414.                     query.append(" WHERE ? > "+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE AND "
  7415.                             +GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG IS NOT NULL AND "
  7416.                             +GestoreMessaggi.MESSAGGI+".TIPO=? AND " +
  7417.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".TIPO_CONSEGNA=? AND "+
  7418.                             GestoreMessaggi.MESSAGGI+".PROPRIETARIO LIKE '"+RicezioneContenutiApplicativi.ID_MODULO+"%' AND "+
  7419.                             GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".INTEGRATION_MANAGER=? AND "+
  7420.                             GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO="+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO ");
  7421.                     queryString = query.toString();
  7422.                 }else{
  7423.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  7424.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  7425.                     sqlQueryObject.addFromTable(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI);
  7426.                     sqlQueryObject.addSelectAliasField(GestoreMessaggi.MESSAGGI,"ID_MESSAGGIO","identificativoBusta");
  7427.                     sqlQueryObject.addSelectField("SERVIZIO_APPLICATIVO");
  7428.                     sqlQueryObject.addSelectField(GestoreMessaggi.MESSAGGI,"ORA_REGISTRAZIONE");
  7429.                     sqlQueryObject.addSelectField("RIFERIMENTO_MSG");
  7430.                     sqlQueryObject.addSelectAliasField(GestoreMessaggi.MESSAGGI,"TIPO","TipoMessaggio");
  7431.                     sqlQueryObject.addSelectField("TIPO_CONSEGNA");
  7432.                     sqlQueryObject.addSelectField("PROPRIETARIO");
  7433.                     sqlQueryObject.addSelectField("INTEGRATION_MANAGER");
  7434.                     sqlQueryObject.addWhereCondition("? > "+GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE");
  7435.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG IS NOT NULL");
  7436.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI+".TIPO=?");
  7437.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".TIPO_CONSEGNA=?");
  7438.                     sqlQueryObject.addWhereLikeCondition(GestoreMessaggi.MESSAGGI+".PROPRIETARIO", RicezioneContenutiApplicativi.ID_MODULO,true,true);
  7439.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".INTEGRATION_MANAGER=?");
  7440.                     sqlQueryObject.addWhereCondition(GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO="+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+".ID_MESSAGGIO");
  7441.                     sqlQueryObject.setANDLogicOperator(true);
  7442.                     if(orderBy){
  7443.                         sqlQueryObject.addOrderBy(GestoreMessaggi.MESSAGGI+".ORA_REGISTRAZIONE");
  7444.                         sqlQueryObject.setSortType(true);
  7445.                     }
  7446.                     sqlQueryObject.setLimit(limit);
  7447.                     queryString = sqlQueryObject.createSQLQuery();
  7448.                 }
  7449.                 //System.out.println("QUERY MESSAGGI SCADUTI RICEZIONE CONTENUTI APPLICATIVI IS: ["+queryString+"] 1["+scandenzaT+"] 2["+Costanti.INBOX+"] 3["+"ConnectionReply"+"] 4["+0+"]");

  7451.                 pstmtMsgScaduti =  connectionDB.prepareStatement(queryString);
  7452.                 pstmtMsgScaduti.setTimestamp(1,scandenzaT);
  7453.                 pstmtMsgScaduti.setString(2,Costanti.INBOX);
  7454.                 pstmtMsgScaduti.setString(3,"ConnectionReply");
  7455.                 pstmtMsgScaduti.setLong(4,0);

  7457.                 long startDateSQLCommand = DateManager.getTimeMillis();
  7458.                 if(logQuery)
  7459.                     this.log.debug("[QUERY] (Messaggi.scadutiPerRicezioneContenutiApplicativi) ["+queryString+"] 1["+scandenzaT+"] 2["+Costanti.INBOX+"] 3["+"ConnectionReply"+"] 4["+0+"]...");
  7460.                 rs = pstmtMsgScaduti.executeQuery();
  7461.                 long endDateSQLCommand = DateManager.getTimeMillis();
  7462.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  7463.                 if(logQuery)
  7464.                     this.log.debug("[QUERY] Messaggi.scadutiPerRicezioneContenutiApplicativi) ["+queryString+"] 1["+scandenzaT+"] 2["+Costanti.INBOX+"] 3["+"ConnectionReply"+"] 4["+0+"] effettuata in "+secondSQLCommand+" secondi");

  7466.                 int countLimit = 0;
  7467.                 while(rs.next()){
  7468.                     idMsg.add(rs.getString("identificativoBusta")+"@"+rs.getString("SERVIZIO_APPLICATIVO"));
  7469.                     // LIMIT Applicativo
  7470.                     if(Configurazione.getSqlQueryObjectType()==null){
  7471.                         countLimit++;
  7472.                         if(countLimit==limit)
  7473.                             break;
  7474.                     }
  7475.                 }
  7476.                 rs.close();
  7477.                 pstmtMsgScaduti.close();

  7479.                 return idMsg;

  7481.             } catch(Exception e) {
  7482.                 String errorMsg = "[GestoreMessaggi.readMsgForRicezioneContenutiApplicativiNonGestiti] errore, queryString["+queryString+"]: "+e.getMessage();
  7483.                 try{
  7484.                     if(rs != null)
  7485.                         rs.close();
  7486.                 } catch(Exception er) {
  7487.                     // close
  7488.                 }
  7489.                 try{
  7490.                     if(pstmtMsgScaduti != null)
  7491.                         pstmtMsgScaduti.close();
  7492.                 } catch(Exception er) {
  7493.                     // close
  7494.                 }
  7495.                 this.log.error(errorMsg,e);
  7496.                 throw new GestoreMessaggiException(errorMsg,e);
  7497.             }   //else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  7498.             //CHECKME stateful only
  7499.         }else{
  7500.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  7501.         }
  7502.     }

  7504.     /**
  7505.      * Cerca nella tabella MESSAGGI i messaggi destinati al servizio RicezioneBuste che sono stati registrati dopo lo scadere
  7506.      * del timeout per il servizio. Ritorna l'idBusta
  7507.      *
  7508.      * @param timeout Intervallo di timeout del servizio
  7509.      * @return Nel caso l'operazione ha successo ritorna un List di stringhe, altrimenti null
  7510.      * 
  7511.      */
  7512.     public List<String> readMsgForRicezioneBusteNonGestiti(long timeout,int limit,boolean logQuery, boolean orderBy)throws GestoreMessaggiException{
  7513.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  7514.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  7515.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  7517.             Connection connectionDB = stateful.getConnectionDB();

  7519.             List<String> idMsg = new ArrayList<>();

  7521.             PreparedStatement pstmtMsgScaduti = null;
  7522.             ResultSet rs = null;
  7523.             String queryString = null;
  7524.             try{    
  7525.                 // Query per Ricerca messaggi scaduti
  7526.                 // Algoritmo:
  7527.                 //    if( (now-timeout) > oraRegistrazione )
  7528.                 //       msgScaduto
  7529.                 long scadenza = DateManager.getTimeMillis() - (timeout);
  7530.                 java.sql.Timestamp scandenzaT = new java.sql.Timestamp(scadenza);
  7531.                 //System.out.println("TIMEOUT RICEZIONE BUSTE["+scandenzaT+"]");

  7533.                 // Query per Ricerca messaggi eliminati 
  7534.                 if(Configurazione.getSqlQueryObjectType()==null){
  7535.                     StringBuilder query = new StringBuilder();
  7536.                     query.append("SELECT ID_MESSAGGIO FROM ");
  7537.                     query.append(GestoreMessaggi.MESSAGGI);
  7538.                     query.append(" WHERE ? > ORA_REGISTRAZIONE AND "+
  7539.                             "RIFERIMENTO_MSG IS NOT NULL AND TIPO=? AND PROPRIETARIO LIKE '"+RicezioneBuste.ID_MODULO+"%'" );
  7540.                     queryString = query.toString();
  7541.                 }else{
  7542.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  7543.                     sqlQueryObject.addSelectField("ID_MESSAGGIO");
  7544.                     sqlQueryObject.addSelectField("RIFERIMENTO_MSG");
  7545.                     sqlQueryObject.addSelectField("TIPO");
  7546.                     sqlQueryObject.addSelectField("PROPRIETARIO");
  7547.                     sqlQueryObject.addSelectField("ORA_REGISTRAZIONE");
  7548.                     sqlQueryObject.addFromTable(GestoreMessaggi.MESSAGGI);
  7549.                     sqlQueryObject.addWhereCondition("? > ORA_REGISTRAZIONE");
  7550.                     sqlQueryObject.addWhereCondition("RIFERIMENTO_MSG IS NOT NULL");
  7551.                     sqlQueryObject.addWhereCondition("TIPO=?");
  7552.                     sqlQueryObject.addWhereLikeCondition("PROPRIETARIO", RicezioneBuste.ID_MODULO,true,true);
  7553.                     sqlQueryObject.setANDLogicOperator(true);
  7554.                     if(orderBy){
  7555.                         sqlQueryObject.addOrderBy("ORA_REGISTRAZIONE");
  7556.                         sqlQueryObject.setSortType(true);
  7557.                     }
  7558.                     sqlQueryObject.setLimit(limit);
  7559.                     queryString = sqlQueryObject.createSQLQuery();
  7560.                 }
  7561.                 //System.out.println("QUERY MESSAGGI SCADUTI RICEZIONE BUSTE IS: ["+queryString+"] 1["+scandenzaT+"] 2["+Costanti.OUTBOX+"]");

  7563.                 pstmtMsgScaduti = connectionDB.prepareStatement(queryString);
  7564.                 pstmtMsgScaduti.setTimestamp(1,scandenzaT);
  7565.                 pstmtMsgScaduti.setString(2,Costanti.OUTBOX);

  7567.                 long startDateSQLCommand = DateManager.getTimeMillis();
  7568.                 if(logQuery)
  7569.                     this.log.debug("[QUERY] (Messaggi.scadutiPerRicezioneBuste) ["+queryString+"] 1["+scandenzaT+"] 2["+Costanti.OUTBOX+"]...");
  7570.                 rs = pstmtMsgScaduti.executeQuery();
  7571.                 long endDateSQLCommand = DateManager.getTimeMillis();
  7572.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  7573.                 if(logQuery)
  7574.                     this.log.debug("[QUERY] Messaggi.scadutiPerRicezioneBuste) ["+queryString+"] 1["+scandenzaT+"] 2["+Costanti.OUTBOX+"] effettuata in "+secondSQLCommand+" secondi");


  7577.                 int countLimit = 0;
  7578.                 while(rs.next()){
  7579.                     idMsg.add(rs.getString("ID_MESSAGGIO"));
  7580.                     // LIMIT Applicativo
  7581.                     if(Configurazione.getSqlQueryObjectType()==null){
  7582.                         countLimit++;
  7583.                         if(countLimit==limit)
  7584.                             break;
  7585.                     }
  7586.                 }
  7587.                 rs.close();
  7588.                 pstmtMsgScaduti.close();

  7590.                 return idMsg;

  7592.             } catch(Exception e) {
  7593.                 String errorMsg = "[GestoreMessaggi.readMsgForRicezioneBusteNonGestiti] errore, queryString["+queryString+"]: "+e.getMessage();
  7594.                 try{
  7595.                     if(rs != null)
  7596.                         rs.close();
  7597.                 } catch(Exception er) {
  7598.                     // close
  7599.                 }
  7600.                 try{
  7601.                     if(pstmtMsgScaduti != null)
  7602.                         pstmtMsgScaduti.close();
  7603.                 } catch(Exception er) {
  7604.                     // close
  7605.                 }
  7606.                 this.log.error(errorMsg,e);
  7607.                 throw new GestoreMessaggiException(errorMsg,e);
  7608.             }   
  7609.         }//else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  7610.         //CHECKME stateful only
  7611.         else{
  7612.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  7613.         }
  7614.     }
















  7631.     /**
  7632.      * Ritorna le buste salvate scadute o inutilizzate (tutti gli accessi uguale a 0) nella INBOX
  7633.      *
  7634.      * @return List di stringhe contenenti gli ID delle buste scadute e/o inutilizzate con il tipo passato come parametro.
  7635.      * @throws GestoreMessaggiException 
  7636.      * 
  7637.      */
  7638.     public List<String> readBusteNonRiferiteDaMessaggiFromInBox(int limit,boolean logQuery,boolean forceIndex,boolean orderBy) throws ProtocolException, GestoreMessaggiException{
  7639.         return this.readBusteNonRiferiteDaMessaggi(Costanti.INBOX,limit,logQuery,forceIndex,orderBy);
  7640.     }

  7642.     /**
  7643.      * Ritorna le buste salvate scadute o inutilizzate (tutti gli accessi uguale a 0) nella OUTBOX
  7644.      *
  7645.      * @return List di stringhe contenenti gli ID delle buste scadute e/o inutilizzate con il tipo passato come parametro.
  7646.      * @throws GestoreMessaggiException 
  7647.      * 
  7648.      */
  7649.     public List<String> readBusteNonRiferiteDaMessaggiFromOutBox(int limit,boolean logQuery,boolean forceIndex,boolean orderBy) throws ProtocolException, GestoreMessaggiException{
  7650.         return this.readBusteNonRiferiteDaMessaggi(Costanti.OUTBOX,limit,logQuery,forceIndex,orderBy);
  7651.     }

  7653.     private List<String> readBusteNonRiferiteDaMessaggi(String tipoBusta,int limit,boolean logQuery,boolean forceIndex,boolean orderBy) throws ProtocolException, GestoreMessaggiException{

  7655.         List<String> idBuste = new ArrayList<>();
  7656.         int pdd = 0;
  7657.         int profilo = 0;
  7658.         int pddProfilo = 0;
  7659.         this._engine_ReadBusteNonRiferiteDaMessaggi(tipoBusta, limit, logQuery, forceIndex, orderBy, true, false, idBuste);
  7660.         pdd = idBuste.size();
  7661.         if(idBuste.size()<limit){
  7662.             this._engine_ReadBusteNonRiferiteDaMessaggi(tipoBusta, limit, logQuery, forceIndex, orderBy, false, true, idBuste);
  7663.             profilo = idBuste.size() - pdd;
  7664.         }
  7665.         if(idBuste.size()<limit){
  7666.             this._engine_ReadBusteNonRiferiteDaMessaggi(tipoBusta, limit, logQuery, forceIndex, orderBy, true, true, idBuste);
  7667.             pddProfilo = idBuste.size() - pdd - profilo;
  7668.         }
  7669.         if(logQuery){
  7670.             this.log.debug("["+tipoBusta+"] Trovati messaggi cosi suddivisi pdd["+pdd+"] profilo["+profilo+"] pddAndProfilo["+pddProfilo+"]");
  7671.         }
  7672.         return idBuste;

  7674.     }


  7677.     /**
  7678.      * Ritorna le buste salvate scadute o inutilizzate (tutti gli accessi uguale a 0)
  7679.      *
  7680.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta  
  7681.      * @return List di stringhe contenenti gli ID delle buste scadute e/o inutilizzate con il tipo passato come parametro.
  7682.      * @throws GestoreMessaggiException 
  7683.      * 
  7684.      */
  7685.     private void _engine_ReadBusteNonRiferiteDaMessaggi(String tipoBusta,int limit,boolean logQuery,boolean forceIndex,boolean orderBy,
  7686.             boolean pdd, boolean profilo,List<String> idBuste) throws ProtocolException, GestoreMessaggiException{
  7687.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  7688.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  7689.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;
  7690.             Connection connectionDB = stateful.getConnectionDB();
  7691.             PreparedStatement pstmt = null;
  7692.             ResultSet rs = null;
  7693.             String queryString = null;
  7694.             try{    

  7696.                 String tipoRovesciato = null;
  7697.                 if(Costanti.INBOX.equals(tipoBusta))
  7698.                     tipoRovesciato = Costanti.OUTBOX;
  7699.                 else
  7700.                     tipoRovesciato = Costanti.INBOX;

  7702.                 IGestoreRepository gestoreRepositoryBuste = Configurazione.getGestoreRepositoryBuste();

  7704.                 // Selezioni i messaggi in RepositoryBuste dove l'idBusta non e' associato 
  7705.                 //   -- ad un messaggio con stesso tipo e identificativo
  7706.                 //   -- ad un messaggio che possiede il riferimento msg come l'id della busta e con tipo invertito
  7707.                 // e (dove Pdd=1 o Profilo=1: questo controllo serve per non fare andare in loopback il timer fino a che la busta non e' davvero eliminata 
  7708.                 //                            (possiede tutti gli accessi a 0))
  7709.                 // e dove la busta non e' utilizzata per il profilo Asincrono 

  7711.                 // Gli identificativi ritornati devono essere utilizzati per effettuare il rollback SOLO di pdd e profilo
  7712.                 // NOTA: non serve fare il rollback dell'history tanto se rimane solo quello, quando la busta e' scaduta viene eliminata.

  7714.                 if(Configurazione.getSqlQueryObjectType()==null){
  7715.                     StringBuilder query = new StringBuilder();
  7716.                     query.append("SELECT ");
  7717.                     if(forceIndex){
  7718.                         query.append("/*+ index("+Costanti.REPOSITORY+" "+Costanti.REPOSITORY_INDEX_TIPO_SEARCH+") */");
  7719.                     }
  7720.                     query.append(" ID_MESSAGGIO FROM ");
  7721.                     query.append(Costanti.REPOSITORY);
  7722.                     query.append(" WHERE ");

  7724.                     // tipo
  7725.                     query.append(" TIPO=? AND ");

  7727.                     // pdd=1 OR profilo=1
  7728.                     if(pdd && profilo){
  7729.                         query.append(gestoreRepositoryBuste.createSQLCondition_enableOnlyPddAndProfilo());
  7730.                     }
  7731.                     else if(pdd){
  7732.                         query.append(gestoreRepositoryBuste.createSQLCondition_enableOnlyPdd());
  7733.                     }
  7734.                     else if(profilo){ 
  7735.                         query.append(gestoreRepositoryBuste.createSQLCondition_enableOnlyProfilo());
  7736.                     }
  7737.                     else{
  7738.                         throw new Exception("Utilizzo errato del metodo, almeno una indicazione tra pdd e profilo deve essere fornita");
  7739.                     }
  7740.                     query.append(" AND ");

  7742.                     //                  query.append("( ");
  7743.                     //                  query.append(gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(true));
  7744.                     //                  query.append(" OR ");
  7745.                     //                  query.append(gestoreRepositoryBuste.createSQLCondition_PdD(true));
  7746.                     //                  query.append(" ) AND ");

  7748.                     // asincrono non utilizzato per profilo asincrono
  7749.                     query.append("(");
  7750.                     query.append("  NOT EXISTS (");
  7751.                     query.append("  SELECT * FROM ");
  7752.                     query.append(Costanti.PROFILO_ASINCRONO);
  7753.                     query.append("  WHERE ");
  7754.                     query.append("    ( ");
  7755.                     query.append(Costanti.PROFILO_ASINCRONO+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO AND ");
  7756.                     query.append(Costanti.PROFILO_ASINCRONO+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7757.                     query.append("    ) ");
  7758.                     query.append("  )");
  7759.                     query.append(") AND ");

  7761.                     // messaggi
  7762.                     query.append("(");
  7763.                     query.append(" NOT EXISTS (");
  7764.                     query.append(" SELECT * FROM ");
  7765.                     query.append(GestoreMessaggi.MESSAGGI);
  7766.                     query.append(" WHERE ");
  7767.                     query.append("( ");
  7768.                     // Messaggi.idBusta
  7769.                     query.append(GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO AND ");
  7770.                     query.append(GestoreMessaggi.MESSAGGI+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7771.                     query.append(" ) OR ( ");
  7772.                     // RiferimentoMessaggi
  7773.                     query.append(GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG="+Costanti.REPOSITORY+".ID_MESSAGGIO AND ");
  7774.                     query.append(GestoreMessaggi.MESSAGGI+".TIPO=?");
  7775.                     query.append(" ) ");
  7776.                     query.append(")");
  7777.                     query.append(")");

  7779.                     queryString = query.toString();
  7780.                 }else{
  7781.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  7782.                     if(forceIndex){
  7783.                         sqlQueryObject.addSelectForceIndex(Costanti.REPOSITORY, Costanti.REPOSITORY_INDEX_TIPO_SEARCH);
  7784.                     }
  7785.                     sqlQueryObject.addSelectField("ID_MESSAGGIO");
  7786.                     sqlQueryObject.addSelectField("TIPO");
  7787.                     sqlQueryObject.addSelectField(gestoreRepositoryBuste.createSQLFields());
  7788.                     sqlQueryObject.addSelectField("ORA_REGISTRAZIONE");
  7789.                     sqlQueryObject.addFromTable(Costanti.REPOSITORY);

  7791.                     // tipo
  7792.                     sqlQueryObject.addWhereCondition("TIPO=?");

  7794.                     // pdd=1 OR profilo=1
  7795.                     if(pdd && profilo){
  7796.                         sqlQueryObject.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_enableOnlyPddAndProfilo());
  7797.                     }
  7798.                     else if(pdd){
  7799.                         sqlQueryObject.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_enableOnlyPdd());
  7800.                     }
  7801.                     else if(profilo){ 
  7802.                         sqlQueryObject.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_enableOnlyProfilo());
  7803.                     }
  7804.                     else{
  7805.                         throw new Exception("Utilizzo errato del metodo, almeno una indicazione tra pdd e profilo deve essere fornita");
  7806.                     }
  7807.                     //                  sqlQueryObject.addWhereCondition(false,
  7808.                     //                          gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(true),
  7809.                     //                          gestoreRepositoryBuste.createSQLCondition_PdD(true));

  7811.                     // asincrono non utilizzato per profilo asincrono
  7812.                     ISQLQueryObject sqlQueryObjectAsincronoNotExists = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());   
  7813.                     sqlQueryObjectAsincronoNotExists.addFromTable(Costanti.PROFILO_ASINCRONO);
  7814.                     sqlQueryObjectAsincronoNotExists.addWhereCondition(true, Costanti.PROFILO_ASINCRONO+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO",
  7815.                             Costanti.PROFILO_ASINCRONO+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7816.                     sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectAsincronoNotExists);

  7818.                     // Messaggi
  7819.                     ISQLQueryObject sqlQueryObjectMessaggiNotExists = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());    
  7820.                     sqlQueryObjectMessaggiNotExists.addFromTable(GestoreMessaggi.MESSAGGI);
  7821.                     sqlQueryObjectMessaggiNotExists.addWhereCondition(true, GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO",
  7822.                             GestoreMessaggi.MESSAGGI+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7823.                     sqlQueryObjectMessaggiNotExists.addWhereCondition(true, GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG="+Costanti.REPOSITORY+".ID_MESSAGGIO",
  7824.                             GestoreMessaggi.MESSAGGI+".TIPO=?");
  7825.                     sqlQueryObjectMessaggiNotExists.setANDLogicOperator(false);

  7827.                     sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectMessaggiNotExists);
  7828.                     sqlQueryObject.setANDLogicOperator(true);
  7829.                     if(orderBy){
  7830.                         sqlQueryObject.addOrderBy("ORA_REGISTRAZIONE");
  7831.                         sqlQueryObject.setSortType(true);
  7832.                     }
  7833.                     sqlQueryObject.setLimit(limit);
  7834.                     queryString = sqlQueryObject.createSQLQuery();
  7835.                 }

  7837.                 //System.out.println("STRING QUERY REPOSITORY1 ["+queryString+"] 1["+tipoBusta+"] 2["+tipoRovesciato+"]...");
  7838.                 pstmt = connectionDB.prepareStatement(queryString);
  7839.                 pstmt.setString(1,tipoBusta);
  7840.                 pstmt.setString(2,tipoRovesciato);

  7842.                 long startDateSQLCommand = DateManager.getTimeMillis();
  7843.                 if(logQuery)
  7844.                     this.log.debug("[QUERY] (Messaggi.busteNonRiferite) ["+queryString+"] 1["+tipoBusta+"] 2["+tipoRovesciato+"]...");
  7845.                 rs = pstmt.executeQuery();
  7846.                 long endDateSQLCommand = DateManager.getTimeMillis();
  7847.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  7848.                 if(logQuery)
  7849.                     this.log.debug("[QUERY] (Messaggi.busteNonRiferite) ["+queryString+"] 1["+tipoBusta+"] 2["+tipoRovesciato+"] effettuata in "+secondSQLCommand+" secondi");

  7851.                 int countLimit = 0;
  7852.                 //System.out.println("STRING QUERY REPOSITORY1 ["+queryString+"] 1["+tipoBusta+"] 2["+tipoRovesciato+"] effettuata");
  7853.                 while(rs.next()){
  7854.                     String id = rs.getString("ID_MESSAGGIO");
  7855.                     if(idBuste.contains(id)==false){
  7856.                         idBuste.add(id);
  7857.                         //System.out.println("TROVATO ["+rs.getString("ID_MESSAGGIO")+"]");
  7858.                         // LIMIT Applicativo
  7859.                         if(Configurazione.getSqlQueryObjectType()==null){
  7860.                             countLimit++;
  7861.                             if(countLimit==limit)
  7862.                                 break;
  7863.                         }
  7864.                     }
  7865.                 }
  7866.                 rs.close();
  7867.                 pstmt.close();



  7871.                 // Selezioni i messaggi in RepositoryBuste dove l'idBusta non e' associato 
  7872.                 //   -- ad un messaggio con stesso tipo e identificativo
  7873.                 //   -- ad un messaggio che possiede il riferimento msg come l'id della busta e con tipo invertito
  7874.                 // e (dove Pdd=1 o Profilo=1: questo controllo serve per non fare andare in loopback il timer fino a che la busta non e' davvero eliminata 
  7875.                 //                            (possiede tutti gli accessi a 0))
  7876.                 // e dove la busta e' utilizzata per il profilo Asincrono con pdd=1 o profilo=1 pero' e' scaduta
  7877.                 // Gli identificativi ritornati devono essere utilizzati per effettuare il rollback SOLO di pdd e profilo
  7878.                 // NOTA: non serve fare il rollback dell'history tanto se rimane solo quello, quando la busta e' scaduta viene eliminata.

  7880.                 if(Configurazione.getSqlQueryObjectType()==null){
  7881.                     StringBuilder query = new StringBuilder();
  7882.                     query.append("SELECT ");
  7883.                     if(forceIndex){
  7884.                         query.append("/*+ index("+Costanti.REPOSITORY+" "+Costanti.REPOSITORY_INDEX_TIPO_SEARCH+") */");
  7885.                     }
  7886.                     query.append(" ID_MESSAGGIO FROM ");
  7887.                     query.append(Costanti.REPOSITORY);
  7888.                     query.append(" WHERE ");

  7890.                     // tipo
  7891.                     query.append(" TIPO=? AND ");

  7893.                     // pdd=1 OR profilo=1
  7894.                     if(pdd && profilo){
  7895.                         query.append(gestoreRepositoryBuste.createSQLCondition_enableOnlyPddAndProfilo());
  7896.                     }
  7897.                     else if(pdd){
  7898.                         query.append(gestoreRepositoryBuste.createSQLCondition_enableOnlyPdd());
  7899.                     }
  7900.                     else if(profilo){ 
  7901.                         query.append(gestoreRepositoryBuste.createSQLCondition_enableOnlyProfilo());
  7902.                     }
  7903.                     else{
  7904.                         throw new Exception("Utilizzo errato del metodo, almeno una indicazione tra pdd e profilo deve essere fornita");
  7905.                     }
  7906.                     query.append(" AND ");
  7907.                     //                  query.append("( ");
  7908.                     //                  query.append(gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(true));
  7909.                     //                  query.append(" OR ");
  7910.                     //                  query.append(gestoreRepositoryBuste.createSQLCondition_PdD(true));
  7911.                     //                  query.append(" ) AND ");

  7913.                     // asincrono  utilizzato per profilo asincrono ma scaduto
  7914.                     query.append("(");
  7915.                     query.append("  EXISTS (");
  7916.                     query.append("  SELECT * FROM ");
  7917.                     query.append(Costanti.PROFILO_ASINCRONO);
  7918.                     query.append("  WHERE ");
  7919.                     query.append("    ( ");
  7920.                     query.append(Costanti.PROFILO_ASINCRONO+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO AND ");
  7921.                     query.append(Costanti.PROFILO_ASINCRONO+".TIPO="+Costanti.REPOSITORY+".TIPO AND ");
  7922.                     query.append(Costanti.REPOSITORY+".SCADENZA_BUSTA < ?");
  7923.                     query.append("    ) ");
  7924.                     query.append("  )");
  7925.                     query.append(") AND ");

  7927.                     // messaggi
  7928.                     query.append("(");
  7929.                     query.append(" NOT EXISTS (");
  7930.                     query.append(" SELECT * FROM ");
  7931.                     query.append(GestoreMessaggi.MESSAGGI);
  7932.                     query.append(" WHERE ");
  7933.                     query.append("( ");
  7934.                     // Messaggi.idBusta
  7935.                     query.append(GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO AND ");
  7936.                     query.append(GestoreMessaggi.MESSAGGI+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7937.                     query.append(" ) OR ( ");
  7938.                     // RiferimentoMessaggi
  7939.                     query.append(GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG="+Costanti.REPOSITORY+".ID_MESSAGGIO AND ");
  7940.                     query.append(GestoreMessaggi.MESSAGGI+".TIPO=?");
  7941.                     query.append(" ) ");
  7942.                     query.append(")");
  7943.                     query.append(")");

  7945.                     queryString = query.toString();
  7946.                 }else{
  7947.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType()); 
  7948.                     if(forceIndex){
  7949.                         sqlQueryObject.addSelectForceIndex(Costanti.REPOSITORY, Costanti.REPOSITORY_INDEX_TIPO_SEARCH);
  7950.                     }
  7951.                     sqlQueryObject.addSelectField("ID_MESSAGGIO");
  7952.                     sqlQueryObject.addSelectField("TIPO");
  7953.                     sqlQueryObject.addSelectField(gestoreRepositoryBuste.createSQLFields());
  7954.                     sqlQueryObject.addSelectField("ORA_REGISTRAZIONE");
  7955.                     sqlQueryObject.addFromTable(Costanti.REPOSITORY);

  7957.                     // tipo
  7958.                     sqlQueryObject.addWhereCondition("TIPO=?");

  7960.                     // pdd=1 OR profilo=1
  7961.                     if(pdd && profilo){
  7962.                         sqlQueryObject.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_enableOnlyPddAndProfilo());
  7963.                     }
  7964.                     else if(pdd){
  7965.                         sqlQueryObject.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_enableOnlyPdd());
  7966.                     }
  7967.                     else if(profilo){ 
  7968.                         sqlQueryObject.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_enableOnlyProfilo());
  7969.                     }
  7970.                     else{
  7971.                         throw new Exception("Utilizzo errato del metodo, almeno una indicazione tra pdd e profilo deve essere fornita");
  7972.                     }
  7973.                     //                  sqlQueryObject.addWhereCondition(false,
  7974.                     //                          gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(true),
  7975.                     //                          gestoreRepositoryBuste.createSQLCondition_PdD(true));

  7977.                     // asincrono utilizzato per profilo asincrono ma scaduto
  7978.                     ISQLQueryObject sqlQueryObjectAsincronoExists = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());  
  7979.                     sqlQueryObjectAsincronoExists.addFromTable(Costanti.PROFILO_ASINCRONO);
  7980.                     sqlQueryObjectAsincronoExists.addWhereCondition(Costanti.PROFILO_ASINCRONO+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO");
  7981.                     sqlQueryObjectAsincronoExists.addWhereCondition(Costanti.PROFILO_ASINCRONO+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7982.                     sqlQueryObjectAsincronoExists.addWhereCondition(Costanti.REPOSITORY+".SCADENZA_BUSTA < ?");
  7983.                     sqlQueryObjectAsincronoExists.setANDLogicOperator(true);
  7984.                     sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectAsincronoExists);

  7986.                     // Messaggi
  7987.                     ISQLQueryObject sqlQueryObjectMessaggiNotExists = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());    
  7988.                     sqlQueryObjectMessaggiNotExists.addFromTable(GestoreMessaggi.MESSAGGI);
  7989.                     sqlQueryObjectMessaggiNotExists.addWhereCondition(true, GestoreMessaggi.MESSAGGI+".ID_MESSAGGIO="+Costanti.REPOSITORY+".ID_MESSAGGIO",
  7990.                             GestoreMessaggi.MESSAGGI+".TIPO="+Costanti.REPOSITORY+".TIPO");
  7991.                     sqlQueryObjectMessaggiNotExists.addWhereCondition(true, GestoreMessaggi.MESSAGGI+".RIFERIMENTO_MSG="+Costanti.REPOSITORY+".ID_MESSAGGIO",
  7992.                             GestoreMessaggi.MESSAGGI+".TIPO=?");
  7993.                     sqlQueryObjectMessaggiNotExists.setANDLogicOperator(false);

  7995.                     sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectMessaggiNotExists);
  7996.                     sqlQueryObject.setANDLogicOperator(true);
  7997.                     if(orderBy){
  7998.                         sqlQueryObject.addOrderBy("ORA_REGISTRAZIONE");
  7999.                         sqlQueryObject.setSortType(true);
  8000.                     }
  8001.                     sqlQueryObject.setLimit(limit);
  8002.                     queryString = sqlQueryObject.createSQLQuery();
  8003.                 }

  8005.                 Timestamp now = DateManager.getTimestamp();
  8006.                 //System.out.println("STRING QUERY REPOSITORY2 ["+queryString+"] 1["+now+"] 2["+tipoBusta+"] 3["+tipoRovesciato+"] ...");
  8007.                 pstmt = connectionDB.prepareStatement(queryString);
  8008.                 pstmt.setString(1,tipoBusta);
  8009.                 pstmt.setTimestamp(2,now);
  8010.                 pstmt.setString(3,tipoRovesciato);

  8012.                 startDateSQLCommand = DateManager.getTimeMillis();
  8013.                 if(logQuery)
  8014.                     this.log.debug("[QUERY] (Messaggi.busteNonRiferite_asincrono) ["+queryString+"] 1["+tipoBusta+"] 2["+now+"] 3["+tipoRovesciato+"]...");
  8015.                 rs = pstmt.executeQuery();
  8016.                 endDateSQLCommand = DateManager.getTimeMillis();
  8017.                 secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  8018.                 if(logQuery)
  8019.                     this.log.debug("[QUERY] (Messaggi.busteNonRiferite_asincrono) ["+queryString+"] 1["+tipoBusta+"] 2["+now+"] 3["+tipoRovesciato+"] effettuata in "+secondSQLCommand+" secondi");

  8021.                 countLimit = 0;
  8022.                 //System.out.println("STRING QUERY REPOSITORY2 ["+queryString+"] 1["+now+"] 2["+tipoBusta+"] 3["+tipoRovesciato+"] effettuata");
  8023.                 while(rs.next()){
  8024.                     String id = rs.getString("ID_MESSAGGIO");
  8025.                     if(idBuste.contains(id)==false){
  8026.                         idBuste.add(id);
  8027.                         //System.out.println("TROVATO ["+rs.getString("ID_MESSAGGIO")+"]");
  8028.                         // LIMIT Applicativo
  8029.                         if(Configurazione.getSqlQueryObjectType()==null){
  8030.                             countLimit++;
  8031.                             if(countLimit==limit)
  8032.                                 break;
  8033.                         }
  8034.                     }
  8035.                 }
  8036.                 rs.close();
  8037.                 pstmt.close();

  8039.             } catch(Exception e) {
  8040.                 String errorMsg = "[RepositoryBuste.getBusteDaEliminare] errore, queryString["+queryString+"]: "+e.getMessage();
  8041.                 this.log.error(errorMsg,e);
  8042.                 try{
  8043.                     if(rs != null)
  8044.                         rs.close();
  8045.                 } catch(Exception er) {
  8046.                     // Eccezione SQL.
  8047.                 }
  8048.                 try{
  8049.                     if(pstmt != null)
  8050.                         pstmt.close();
  8051.                 } catch(Exception er) {
  8052.                     // Eccezione SQL.
  8053.                 }
  8054.                 throw new ProtocolException(errorMsg,e);
  8055.             }
  8056.         }//else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  8057.         //CHECKME stateful only
  8058.         else{
  8059.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  8060.         }
  8061.     }


















  8080.     /* ------------- ELIMINAZIONE MESSAGGI -------------- */
  8081.     public void logicDeleteMessage()throws GestoreMessaggiException{
  8082.         this.aggiornaProprietarioMessaggio_engine(TimerGestoreMessaggi.ID_MODULO, false, true);
  8083.     }

  8085.     /*
  8086.      * !!! NOTA IL PROBLEMA DESCRITTO DI SEGUITO E' STATO RISOLTO UTILIZZANDO UN ALTRA SOLUZIONE descritta nel metodo deleteMessageByOraRegistrazione !!
  8087.      * 
  8088.      * Fix problem:
  8089.      * I servizi RicezioneBuste e RicezioneContenutiApplicativi ed i Moduli InoltroBuste e InoltroRisposte, quando ricevono un messaggio controllano 
  8090.      * se tale messaggio risulta gia' presente nella base dati.
  8091.      * In particolare va fatta attenzione quando viene rilevata la presenza di tale messaggio con proprietario 'GestoreMessaggi' che rappresenta l'eliminazione logica.
  8092.      * 
  8093.      * Prima della gestione tramite lock poteva succedere che:
  8094.      * - t1 il timer GestoreMessaggi raccoglie le liste dei messaggi da eliminare tra cui l'id ID_A
  8095.      * - t2 il servizio es. RicezioneBuste rileva che l'id ID_A risulta esistente nella base dati con con proprietario 'GestoreMessaggi' e forza l'eliminazione fisica.
  8096.      * - t3 il servizio es. RicezioneBuste continua poi il processamento registrando nuovamente il messaggio con proprietario il modulo successivo, ad es. Sbustamento.
  8097.      * - t4 il servizio es. RicezioneBuste finisce correttamente l'elaborazione del messaggio, magari con presa in carico, avendolo consegnato alla coda ConsegnaContenutiApplicativi.
  8098.      * - t5 il timer GestoreMessaggi al tempo t5 processa effettivamente il messaggio con tale id ID_A e lo elimina. Ma questa eliminazione e' ERRATA poiche il proprietario e' cambiato,
  8099.      *      Tale id era pero' stato identificato al tempo t1.
  8100.      * - t6 Il Modulo ConsegnaContenutiApplicativi viene attivato dal MDB, ma non trovando info su tale ID_A termina subito e quindi non effettua la consegna.
  8101.      * 
  8102.      * Con la gestione tramite lock il bug viene superato.
  8103.      * 
  8104.      * Il Timer GestoreMessaggi acquisisce il lock prima di identificare i messaggi da eliminare.
  8105.      * Il Servizio puntuale, es. RicezioneBuste, acquisisce il lock quando rileva un msg con proprietario 'GestoreMessaggi' (eliminato logicamente) dovendo effettuare una eliminazione fisica forzata per poter proseguire con l'elaborazione.
  8106.      * In questa maniera:
  8107.      * - se il lock viene preso prima dal Timer, questo lo elimina effettivamente. 
  8108.      *   Quando poi il lock viene preso dal servizio puntuale, l'eliminazione non apportera' modifiche effettive sulla basedati (gia eliminato dal timer).
  8109.      *   Pero' poi quando il servizio puntuale ne registra una nuova copia, questo non subira' cancellazioni poiche' il timer ha gia finito l'elaborazione.
  8110.      * - se il lock viene preso prima dal servizio puntuale,  questo lo elimina effettivamente e poi ne creera' eventualmente una nuova versione.
  8111.      *   Quando il lock viene preso dal Timer, tale messaggio non viene rilevato o perche' non esiste proprio sulla base dati o perche' possiede un proprietario diverso da GestoreMessaggi.
  8112.      *
  8113.      * La gestione viene ampliata anche per quanto concerne il repository delle buste.
  8114.      * Il Timer di GestoreRepositoryBuste lo stesso acquisira' il lock prima di esaminare se ci sono buste da eliminare.
  8115.      * Rimane aperta la possibilita' di avere una inconsistenza nei punti (RicezioneBuste,RicezioneContenutiApplicativi) 
  8116.      * in cui deve essere registrato il repository delle buste poiche' viene effettuato il seguente codice:
  8117.      * if(busta.exists)
  8118.      *     busta.update
  8119.      * else
  8120.      *         busta.create
  8121.      * Quindi potrebbe succedere in un caso limite che quando si appresta ad effettuare l'update il timer elimina la busta e il mittente ottiene un errore.
  8122.      * Per risolvere questo problema andrebbe messo in lock anche nel codice sopra riportato, pero' questo comporta un blocco su tutto quel punto.
  8123.      * Comunque anche se avviene questo caso limite, non si ha inconsistenze del database ma solo un errore ritornato al mittente. 
  8124.      * Il lock viene allora utilizzato SOLO se si ha un errore in update. Viene replicato il codice di update stavolta dentro il lock.
  8125.      *  
  8126.      **/

  8128.     /**
  8129.      * Elimina il messaggio gestito da OpenSPCoop. 
  8130.      *
  8131.      * Deprecated: using deleteMessageByOraRegistrazione
  8132.      */
  8133.     @Deprecated
  8134.     public void deleteMessageWithLock(String causa, long attesaAttivaLock, int checkIntervalLock) throws GestoreMessaggiException{
  8135.         _deleteMessageWithLock(causa, attesaAttivaLock, checkIntervalLock);
  8136.     }
  8137.     public void _deleteMessageWithLock(String causa, long attesaAttivaLock, int checkIntervalLock) throws GestoreMessaggiException{
  8138.         Connection connectionDB = null;
  8139.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || (this.oneWayVersione11)) {
  8140.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  8141.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  8142.             connectionDB = stateMSG.getConnectionDB();
  8143.         }
  8144.         
  8145.         Semaphore semaphoreDB = null;
  8146.         TimerLock timerLock = null;
  8147.         try {
  8148.             timerLock = new TimerLock(TipoLock._getLockGestioneRepositoryMessaggi());
  8149.         }catch(Exception e){
  8150.             throw new GestoreMessaggiException(e.getMessage(),e);
  8151.         }
  8152.         try{
  8153.             
  8154.             try{
  8155.                 semaphoreDB = this.getSemaphoreByInstance(timerLock.getIdLock());
  8156.             }catch(Exception e){
  8157.                 throw new GestoreMessaggiException(e.getMessage(),e);
  8158.             }
  8159.             
  8160.             try{
  8161.                 GestoreMessaggi.acquireLock(semaphoreDB, connectionDB, timerLock, 
  8162.                         this.msgDiag, causa, attesaAttivaLock, checkIntervalLock);
  8163.             }
  8164.             catch(Exception e){
  8165.                 throw new GestoreMessaggiException(e.getMessage(),e);
  8166.             }

  8168.             deleteMessage(null);

  8170.         }finally{
  8171.             try{
  8172.                 GestoreMessaggi.releaseLock(semaphoreDB, connectionDB, timerLock,
  8173.                         this.msgDiag, causa);
  8174.             }catch(Exception e){
  8175.                 // ignore
  8176.             }
  8177.         }
  8178.     }
  8179.     /**
  8180.      * Elimina il messaggio gestito da OpenSPCoop. 
  8181.      *
  8182.      * Deprecated: using deleteMessageByOraRegistrazione
  8183.      */
  8184.     @Deprecated
  8185.     public void deleteMessageWithoutLock() throws GestoreMessaggiException{
  8186.         _deleteMessageWithoutLock();
  8187.     }
  8188.     public void _deleteMessageWithoutLock() throws GestoreMessaggiException{
  8189.         deleteMessage(null);
  8190.     }
  8191.     
  8192.     /*
  8193.      * Fix problem:
  8194.      * I servizi RicezioneBuste e RicezioneContenutiApplicativi ed i Moduli InoltroBuste e InoltroRisposte, quando ricevono un messaggio controllano 
  8195.      * se tale messaggio risulta gia' presente nella base dati.
  8196.      * In particolare va fatta attenzione quando viene rilevata la presenza di tale messaggio con proprietario 'GestoreMessaggi' che rappresenta l'eliminazione logica.
  8197.      * 
  8198.      * Prima della gestione tramite lock poteva succedere che:
  8199.      * - t1 il timer GestoreMessaggi raccoglie le liste dei messaggi da eliminare tra cui l'id ID_A
  8200.      * - t2 il servizio es. RicezioneBuste rileva che l'id ID_A risulta esistente nella base dati con con proprietario 'GestoreMessaggi' e forza l'eliminazione fisica.
  8201.      * - t3 il servizio es. RicezioneBuste continua poi il processamento registrando nuovamente il messaggio con proprietario il modulo successivo, ad es. Sbustamento.
  8202.      * - t4 il servizio es. RicezioneBuste finisce correttamente l'elaborazione del messaggio, magari con presa in carico, avendolo consegnato alla coda ConsegnaContenutiApplicativi.
  8203.      * - t5 il timer GestoreMessaggi al tempo t5 processa effettivamente il messaggio con tale id ID_A e lo elimina. Ma questa eliminazione e' ERRATA poiche il proprietario e' cambiato,
  8204.      *      Tale id era pero' stato identificato al tempo t1.
  8205.      * - t6 Il Modulo ConsegnaContenutiApplicativi viene attivato dal MDB, ma non trovando info su tale ID_A termina subito e quindi non effettua la consegna.
  8206.      * 
  8207.      * Con la gestione tramite data il bug viene superato.
  8208.      * 
  8209.      * Il Timer GestoreMessaggi quando avvia l'esecuzione mantiene la DATA_CHECK e acquisisce i messaggi da eliminare la cui ora di registrazione è inferiore alla DATA_CHECK.
  8210.      * Inoltre ogni delete di un messaggio avviene con le istruzioni su ogni tabella che verificano che l'ora di registrazione sia inferiore a DATA_CHECK.
  8211.      * Il Servizio puntuale, es. RicezioneBuste, quando rileva un msg con proprietario 'GestoreMessaggi' (eliminato logicamente) deve effettuare una eliminazione fisica forzata per poter proseguire con l'elaborazione.
  8212.      * In questa maniera:
  8213.      * - se il messaggio rientra nella lista presa prima dal Timer, questo lo elimina effettivamente. 
  8214.      *   Quando poi la "cpu" torna al servizio puntuale, l'eliminazione non apportera' modifiche effettive sulla basedati (gia eliminato dal timer).
  8215.      *   Pero' poi quando il servizio puntuale ne registra una nuova copia, questo non subira' cancellazioni poiche' le eliminazioni del timer verificano che l'ora di registrazione sia inferiore a DATA_CHECK,
  8216.      *   e invece la nuova copia avrà una ora di registrazione successiva.
  8217.      * - se il lock viene preso prima dal servizio puntuale,  questo lo elimina effettivamente e poi ne creera' eventualmente una nuova versione.
  8218.      *   Quando il Timer si attiva, tale messaggio non viene rilevato o perche' non esiste proprio sulla base dati o perche' possiede un proprietario diverso da GestoreMessaggi.
  8219.      *
  8220.      * La gestione viene ampliata anche per quanto concerne il repository delle buste.
  8221.      * Il Timer di GestoreRepositoryBuste lo stesso mantiene una sua DATA_CHECK prima di esaminare se ci sono buste da eliminare.
  8222.      * Inoltre ogni delete di una busta avviene con le istruzioni su ogni tabella che verificano che la data di registrazione sia inferiore a DATA_CHECK.
  8223.      * Rimane aperta la possibilita' di avere una inconsistenza nei punti (RicezioneBuste,RicezioneContenutiApplicativi) 
  8224.      * in cui deve essere registrato il repository delle buste poiche' viene effettuato il seguente codice:
  8225.      * if(busta.exists)
  8226.      *     busta.update
  8227.      * else
  8228.      *     busta.create
  8229.      * Quindi potrebbe succedere in un caso limite che quando si appresta ad effettuare l'update il timer elimina la busta e il mittente ottiene un errore.
  8230.      * Per risolvere questo problema andrebbe utilizzata la soluzione con lock deprecata e descritta in deleteMessageWithLock anche nel codice sopra riportato, pero' questo comporta un blocco su tutto quel punto.
  8231.      * Comunque anche se avviene questo caso limite, non si ha inconsistenze del database ma solo un errore ritornato al mittente. 
  8232.      *  
  8233.      **/
  8234.     public void deleteMessageByOraRegistrazione(Date data) throws GestoreMessaggiException{
  8235.         deleteMessage(data);
  8236.     }
  8237.     public void deleteMessageByNow() throws GestoreMessaggiException{
  8238.         deleteMessage(DateManager.getDate());
  8239.     }
  8240.     
  8241.     private void deleteMessage(Date data)throws GestoreMessaggiException{
  8242.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || (this.oneWayVersione11)) {
  8243.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  8244.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  8245.             Connection connectionDB = stateMSG.getConnectionDB();
  8246.             PreparedStatement pstmtDeleteSIL= null;
  8247.             PreparedStatement pstmtDeleteMSG= null;
  8248.             try{

  8250.                 //this.log.debug("DELETE  ID_MESSAGGIO='"+this.idBusta+"' AND TIPO='"+this.tipo+"'");
  8251.                 java.sql.Timestamp nowT = null;
  8252.                 if(data!=null) {
  8253.                     nowT = new java.sql.Timestamp(data.getTime());
  8254.                 }

  8256.                 // Prima prova ad eliminare eventuali SIL rimasti appesi al messaggio, se il messaggio e' di tipo INBOX
  8257.                 if(Costanti.INBOX.equals(this.tipo)){
  8258.                     String query = "DELETE FROM "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI+" WHERE "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI_COLUMN_ID_MESSAGGIO+"=?";
  8259.                     if(data!=null) {
  8260.                         query = query + " AND "+GestoreMessaggi.MSG_SERVIZI_APPLICATIVI_COLUMN_ORA_REGISTRAZIONE+"<=?";
  8261.                     }
  8262.                     //log.debug("Query: "+query);
  8263.                     pstmtDeleteSIL= connectionDB.prepareStatement(query);
  8264.                     pstmtDeleteSIL.setString(1,this.idBusta);
  8265.                     if(data!=null) {
  8266.                         pstmtDeleteSIL.setTimestamp(2, nowT);
  8267.                     }
  8268.                     pstmtDeleteSIL.execute();
  8269.                     pstmtDeleteSIL.close();
  8270.                 }

  8272.                 // Prova poi ad eliminare il messaggio su FileSystem/DB
  8273.                 SavedMessage msgDelete = new SavedMessage(this.idBusta, this.openspcoopstate ,this.tipo,this.workDir,GestoreMessaggi.adapter,this.log); 
  8274.                 msgDelete.delete(this.isRichiesta,this.oneWayVersione11, nowT);

  8276.                 // Elimino il messaggio
  8277.                 String query = "DELETE FROM "+GestoreMessaggi.MESSAGGI+" WHERE "+GestoreMessaggi.MESSAGGI_COLUMN_ID_MESSAGGIO+"=? AND "+GestoreMessaggi.MESSAGGI_COLUMN_TIPO_MESSAGGIO+"=?";
  8278.                 if(data!=null) {
  8279.                     query = query + " AND "+GestoreMessaggi.MESSAGGI_COLUMN_ORA_REGISTRAZIONE+"<=?";
  8280.                 }
  8281.                 //log.debug("Query: "+query);
  8282.                 pstmtDeleteMSG= connectionDB.prepareStatement(query);
  8283.                 pstmtDeleteMSG.setString(1,this.idBusta);
  8284.                 pstmtDeleteMSG.setString(2,this.tipo);
  8285.                 if(data!=null) {
  8286.                     pstmtDeleteMSG.setTimestamp(3, nowT);
  8287.                 }
  8288.                 pstmtDeleteMSG.execute();
  8289.                 pstmtDeleteMSG.close();

  8291.                 // Elimino dalla cache
  8292.                 GestoreMessaggi.deleteFromCache_Proprietario(TimerGestoreMessaggi.ID_MODULO,this.tipo, this.idBusta);

  8294.             } catch(Exception e) {
  8295.                 String errorMsg = "GESTORE_MESSAGGI, error deleteMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  8296.                 try{
  8297.                     if(pstmtDeleteMSG != null)
  8298.                         pstmtDeleteMSG.close();
  8299.                 } catch(Exception er) {
  8300.                     // close
  8301.                 }
  8302.                 try{
  8303.                     if(pstmtDeleteSIL != null)
  8304.                         pstmtDeleteSIL.close();
  8305.                 } catch(Exception er) {
  8306.                     // close
  8307.                 }
  8308.                 this.log.error(errorMsg,e);
  8309.                 throw new GestoreMessaggiException(errorMsg,e);
  8310.             }   
  8311.         }else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  8312.             //CHECKME NOP
  8313.         }else{
  8314.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  8315.         }

  8317.     }

  8319.     /**
  8320.      * Elimina il messaggio gestito da OpenSPCoop dal fileSystem. 
  8321.      *
  8322.      * 
  8323.      */
  8324.     public void deleteMessageFromFileSystem(){
  8325.         SavedMessage msgDelete = null;
  8326.         try{
  8327.             //this.log.debug("DELETE FILE SYSTEM ID_MESSAGGIO='"+this.idBusta+"' AND TIPO='"+this.tipo+"'");
  8328.             msgDelete = new SavedMessage(this.idBusta, this.openspcoopstate ,this.tipo,this.workDir,GestoreMessaggi.adapter,this.log); 
  8329.             msgDelete.deleteMessageFromFileSystem();
  8330.         }catch(Exception e){
  8331.             String errorMsg = "GESTORE_MESSAGGI, error deleteMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();      
  8332.             this.log.error(errorMsg,e);
  8333.         }
  8334.     }


  8337.     /**
  8338.      * Effettua una validazione sui riscontri del messaggio, e dopodiche' lo elimina.
  8339.      *
  8340.      * 
  8341.      */
  8342.     public void validateAndDeleteMsgOneWayRiscontrato() throws GestoreMessaggiException,ProtocolException{

  8344.         StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  8345.                 : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  8347.         // Validazione riscontro
  8348.         Riscontri gestoreRiscontri = null;

  8350.         // Commit JDBC
  8351.         try{
  8352.             gestoreRiscontri = new Riscontri(stateMSG);
  8353.             gestoreRiscontri.validazioneRiscontroRicevuto(this.idBusta);

  8355.             // Aggiorno proprietario
  8356.             this.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);

  8358.             this.openspcoopstate.commit();

  8360.         }catch (Exception e) {  
  8361.             String errorMsg = "GESTORE_MESSAGGI, error validateAndDeleteMsgRiscontrato "+this.tipo+"/"+this.idBusta+": "+e.getMessage();        
  8362.             this.log.error(errorMsg,e);
  8363.             throw new GestoreMessaggiException(errorMsg,e);
  8364.         }

  8366.         // Aggiornamento cache proprietario messaggio
  8367.         this.addProprietariIntoCache_readFromTable("GestoreMessaggi", "validateAndDeleteMsgOneWayRiscontrato",null,false);
  8368.     }




  8373.     /**
  8374.      * Effettua una validazione di una ricevuta asincrona, e dopodiche' elimina la richiesta.
  8375.      *
  8376.      * @param bustaRicevuta Busta della ricevuta
  8377.      * 
  8378.      */
  8379.     public void validateAndDeleteMsgAsincronoRiscontrato(Busta bustaRicevuta) throws GestoreMessaggiException,ProtocolException{

  8381.         StateMessage state = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  8382.                 : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;

  8384.         // Validazione ricevuta
  8385.         ProfiloDiCollaborazione profiloCollaborazione = null;

  8387.         // Commit JDBC
  8388.         try{
  8389.             profiloCollaborazione = new ProfiloDiCollaborazione(state,this.protocolFactory);
  8390.             profiloCollaborazione.asincrono_valdazioneRicevuta(bustaRicevuta);

  8392.             // Aggiorno proprietario
  8393.             this.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);

  8395.             this.openspcoopstate.commit();

  8397.         }catch (Exception e) {  
  8398.             String errorMsg = "GESTORE_MESSAGGI, error validateAndDeleteMsgRiscontrato "+this.tipo+"/"+this.idBusta+": "+e.getMessage();        

  8400.             this.log.error(errorMsg,e);
  8401.             throw new GestoreMessaggiException(errorMsg,e);
  8402.         }

  8404.         // Aggiornamento cache proprietario messaggio
  8405.         this.addProprietariIntoCache_readFromTable("GestoreMessaggi", "validateAndDeleteMsgAsincronoRiscontrato",null,false);

  8407.     }







  8415.     /**
  8416.      * Elimina un messaggio dall'engine di OpenSPCoop. 
  8417.      *
  8418.      * 
  8419.      */
  8420.     public boolean forcedDeleteMessage(RequestInfo requestInfo) throws GestoreMessaggiException{

  8422.         if(this.openspcoopstate instanceof OpenSPCoopStateful) {
  8423.             StatefulMessage stateful = (this.isRichiesta) ? ((StatefulMessage)this.openspcoopstate.getStatoRichiesta()) 
  8424.                     : ((StatefulMessage)this.openspcoopstate.getStatoRisposta()) ;

  8426.             RollbackRepositoryBuste rollbackMessaggio = null;
  8427.             RollbackRepositoryBuste rollbackRepository = null;
  8428.             try{    
  8429.                 //this.log.debug("FORCED DELETE  ID_MESSAGGIO='"+this.idBusta+"' AND TIPO='"+this.tipo+"'");

  8431.                 if(this.existsMessage_noCache()==false)
  8432.                     return false;
  8433.                 // Clean Rollback + JMS
  8434.                 String rifMsg = this.getRiferimentoMessaggio();
  8435.                 JMSReceiver receiverJMS = null;
  8436.                 if(CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.propertiesReader.getNodeReceiver())){
  8437.                     String idT = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, this.pddContext);
  8438.                     String protocol = null;
  8439.                     if(this.protocolFactory!=null)
  8440.                         protocol = this.protocolFactory.getProtocol();
  8441.                     receiverJMS = new JMSReceiver(this.propertiesReader.getIdentitaPortaDefault(protocol, requestInfo),"ForcedDeleteMessage",this.propertiesReader.singleConnectionNodeReceiver(),this.log,idT);
  8442.                 }
  8443.                 if(Costanti.INBOX.equals(this.tipo)){
  8444.                     //  rollback messaggio (eventuale profilo + accesso_pdd)
  8445.                     rollbackMessaggio = new RollbackRepositoryBuste(this.idBusta, stateful,this.oneWayVersione11);
  8446.                     rollbackMessaggio.rollbackBustaIntoInBox();
  8447.                     if(rifMsg==null){
  8448.                         if(receiverJMS!=null){
  8449.                             // rollback jms receiver
  8450.                             String strMessageSelector = "ID = '"+this.idBusta+"'";
  8451.                             if (receiverJMS.clean(RicezioneBuste.ID_MODULO,strMessageSelector)){
  8452.                                 this.log.info("Trovato messaggio nella coda "+RicezioneBuste.ID_MODULO+" con id ["+this.idBusta+"] non consumato");
  8453.                             }
  8454.                         }
  8455.                     }else{
  8456.                         // rollback repository
  8457.                         rollbackRepository = new RollbackRepositoryBuste(rifMsg,stateful,this.oneWayVersione11);
  8458.                         rollbackRepository.rollbackBustaIntoOutBox(false); // non effettuo il rollback dell'history (riscontro/ricevuta arrivera...)

  8460.                         if(receiverJMS!=null){
  8461.                             // rollback jms receiver
  8462.                             String strMessageSelector = "ID = '"+rifMsg+"'";
  8463.                             if (receiverJMS.clean(RicezioneContenutiApplicativi.ID_MODULO,strMessageSelector)){
  8464.                                 this.log.info("Trovato messaggio (tramite riferimento) nella coda "+RicezioneContenutiApplicativi.ID_MODULO+" con id ["+rifMsg+"] non consumato");
  8465.                             }
  8466.                         }
  8467.                     }
  8468.                 }else{
  8469.                     // rollback messaggio scaduto (eventuale profilo + accesso_pdd)
  8470.                     rollbackMessaggio = new RollbackRepositoryBuste(this.idBusta, stateful,this.oneWayVersione11);
  8471.                     rollbackMessaggio.rollbackBustaIntoOutBox();
  8472.                     if(rifMsg==null){
  8473.                         if(receiverJMS!=null){
  8474.                             //  rollback jms receiver
  8475.                             String strMessageSelector = "ID = '"+this.idBusta+"'";
  8476.                             if (receiverJMS.clean(RicezioneContenutiApplicativi.ID_MODULO,strMessageSelector)){
  8477.                                 this.log.info("Trovato messaggio nella coda "+RicezioneContenutiApplicativi.ID_MODULO+" con id ["+this.idBusta+"] non consumato");
  8478.                             }
  8479.                         }
  8480.                     }else{
  8481.                         // rollback repository
  8482.                         rollbackRepository = new RollbackRepositoryBuste(rifMsg, stateful,this.oneWayVersione11);
  8483.                         rollbackRepository.rollbackBustaIntoInBox(false); // non effettuo il rollback dell'history (busta e' ricevuta)

  8485.                         if(receiverJMS!=null){
  8486.                             //  rollback jms receiver
  8487.                             String strMessageSelector = "ID = '"+rifMsg+"'";
  8488.                             if (receiverJMS.clean(RicezioneBuste.ID_MODULO,strMessageSelector)){
  8489.                                 this.log.info("Trovato messaggio (tramite riferimento) nella coda "+RicezioneBuste.ID_MODULO+" con id ["+rifMsg+"] non consumato");
  8490.                             }
  8491.                         }
  8492.                     }
  8493.                 }
  8494.                 // Update proprietario messaggio
  8495.                 this.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);


  8498.                 // esecuzione forced delete
  8499.                 this.openspcoopstate.commit();

  8501.                 //  Aggiornamento cache proprietario messaggio
  8502.                 this.addProprietariIntoCache_readFromTable("GestoreMessaggi", "forcedDeleteMessage",this.getRiferimentoMessaggio(),false);

  8504.                 return true;

  8506.             } catch(Exception e) {
  8507.                 String errorMsg = "GESTORE_MESSAGGI, Errore forcedDeleteMessage "+this.tipo+"/"+this.idBusta+": "+e.getMessage();       
  8508.                 this.log.error(errorMsg,e);

  8510.                 throw new GestoreMessaggiException(errorMsg,e);
  8511.             }
  8512.         } // else if (this.openspcoopstate instanceof OpenSPCoopStateless){
  8513.         // Stateful only    
  8514.         else{
  8515.             throw new GestoreMessaggiException("Metodo invocato con OpenSPCoopState non valido");
  8516.         }

  8518.     }







  8526.     /** 
  8527.      * Costruisce un Messaggio conforme all'interfaccia di pubblicazione del RepositoryMessaggi 
  8528.      * 
  8529.      * 
  8530.      */
  8531.     public OpenSPCoop2Message buildRichiestaPubblicazioneMessaggio_RepositoryMessaggi(IDSoggetto soggettoMittente,String tipoServizio,String servizio,String azione) throws GestoreMessaggiException{

  8533.         try{
  8534.             String msg = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n"+
  8535.                     "<soapenv:Body>\n"+
  8536.                     "<pubblicazioneMessaggio xmlns=\"http://gestoreeventi.openspcoop.org\">" +
  8537.                     "<richiesta xmlns:types=\"http://types.gestoreeventi.openspcoop.org\"><types:idMessaggio>"+this.idBusta+"</types:idMessaggio>"+
  8538.                     "<types:soggetto><types:nome>"+soggettoMittente.getNome()+"</types:nome><types:tipo>"+soggettoMittente.getTipo()+"</types:tipo></types:soggetto>"+
  8539.                     "<types:servizio><types:nome>"+servizio+"</types:nome><types:tipo>"+tipoServizio+"</types:tipo></types:servizio>"+
  8540.                     "<types:tipoEvento>"+azione+"</types:tipoEvento>"+
  8541.                     "</richiesta></pubblicazioneMessaggio>\n"+
  8542.                     "</soapenv:Body>\n"+
  8543.                     "</soapenv:Envelope>";
  8544.             OpenSPCoop2MessageParseResult pr = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createMessage(MessageType.SOAP_11, MessageRole.REQUEST, 
  8545.                     MessageUtilities.getDefaultContentType(MessageType.SOAP_11),
  8546.                     msg.getBytes());
  8547.             return pr.getMessage_throwParseException();
  8548.         }catch(Exception e){
  8549.             String errorMsg = "GESTORE_MESSAGGI, error buildRichiestaPubblicazioneMessaggio_RepositoryMessaggi: "+e.getMessage();       
  8550.             this.log.error(errorMsg,e);
  8551.             throw new GestoreMessaggiException(errorMsg,e);
  8552.         }

  8554.     }

  8556.     /** 
  8557.      * Costruisce un Messaggio conforme all'interfaccia di prelevamento dal RepositoryMessaggi 
  8558.      * 
  8559.      * 
  8560.      */
  8561.     public OpenSPCoop2Message buildRispostaPrelevamentoMessaggio_RepositoryMessaggi(byte[] messaggio, MessageType messageType) throws GestoreMessaggiException{

  8563.         try{
  8564.             String namespace;
  8565.             if(MessageType.SOAP_11.equals(messageType)){
  8566.                 namespace = "http://schemas.xmlsoap.org/soap/envelope/";
  8567.             } else {
  8568.                 namespace = "http://www.w3.org/2003/05/soap-envelope";
  8569.             }
  8570.             String msgUpper = "<soapenv:Envelope xmlns:soapenv=\"" + namespace + "\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n"+
  8571.                     "<soapenv:Body>\n"+
  8572.                     "<prelevaMessaggioResponse xmlns=\"http://gestoreeventi.openspcoop.org\">"+
  8573.                     "<prelevaMessaggioReturn>";
  8574.             String msgDown ="</prelevaMessaggioReturn></prelevaMessaggioResponse>\n"+
  8575.                     "</soapenv:Body>\n"+
  8576.                     "</soapenv:Envelope>";
  8577.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  8578.             bout.write(msgUpper.getBytes());
  8579.             bout.write(Base64Utilities.encode(messaggio));
  8580.             bout.write(msgDown.getBytes());
  8581.             bout.flush();
  8582.             bout.close();
  8583.             OpenSPCoop2MessageParseResult pr = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createMessage(messageType, MessageRole.RESPONSE, 
  8584.                     MessageUtilities.getDefaultContentType(messageType),
  8585.                     bout.toByteArray());
  8586.             return pr.getMessage_throwParseException();
  8587.         }catch(Exception e){
  8588.             String errorMsg = "GESTORE_MESSAGGI, error buildRispostaPrelevamentoMessaggio_RepositoryMessaggi: "+e.getMessage();     
  8589.             this.log.error(errorMsg,e);
  8590.             throw new GestoreMessaggiException(errorMsg,e);
  8591.         }

  8593.     }
  8594.     public void setReadyForDrop(boolean readyForDrop) {
  8595.         this.readyForDrop = readyForDrop;
  8596.     }
  8597.     public void setOneWayVersione11(boolean oneWay11) {
  8598.         this.oneWayVersione11 = oneWay11;
  8599.     }
  8600.     public boolean isOneWayVersione11() {
  8601.         return this.oneWayVersione11;
  8602.     }
  8603.     public void setPortaDiTipoStateless(boolean portaDiTipoStateless) {
  8604.         this.portaDiTipoStateless = portaDiTipoStateless;
  8605.     }
  8606.     public void setRoutingStateless(boolean routingStateless) {
  8607.         this.routingStateless = routingStateless;
  8608.     }
  8609.     public boolean isRichiesta() {
  8610.         return this.isRichiesta;
  8611.     }
  8612.     public void setRichiesta(boolean isRichiesta) {
  8613.         this.isRichiesta = isRichiesta;
  8614.     }


















  8633.     /* ------------- LOCK PER GESTIONE DELETE DI MESSAGGI DUPLICATI IN CONCORRENZA CON L'ELIMINAZIONE DEL TIMER -------------- */
  8634.     
  8635.     private Semaphore getSemaphoreByInstance(String idLock) throws UtilsException {
  8636.         if(this.propertiesReader.isTimerLockByDatabase()) {
  8637.             try{
  8638.                 InfoStatistics semaphore_statistics = new InfoStatistics();
  8639.                         
  8640.                 SemaphoreConfiguration config = newSemaphoreConfiguration(this.propertiesReader.getTimerGestoreMessaggiLockMaxLife(), 
  8641.                         this.propertiesReader.getTimerGestoreMessaggiLockIdleTime());
  8642.                 
  8643.                 TipiDatabase databaseType = TipiDatabase.toEnumConstant(this.propertiesReader.getDatabaseType());
  8644.                 Semaphore semaphoreDB = new Semaphore(semaphore_statistics, SemaphoreMapping.newInstance(idLock), 
  8645.                         config, databaseType, this.log);
  8646.                 return semaphoreDB;
  8647.             }catch(Exception e){
  8648.                 throw new UtilsException(e.getMessage(),e);
  8649.             }
  8650.         }
  8651.         return null;
  8652.     }
  8653.     private Connection getConnectionByInstance() {
  8654.         Connection connectionDB = null;
  8655.         if( (this.openspcoopstate instanceof OpenSPCoopStateful) || (this.oneWayVersione11)) {
  8656.             StateMessage stateMSG = (this.isRichiesta) ? ((StateMessage)this.openspcoopstate.getStatoRichiesta()) 
  8657.                     : ((StateMessage)this.openspcoopstate.getStatoRisposta()) ;
  8658.             connectionDB = stateMSG.getConnectionDB();
  8659.         }
  8660.         return connectionDB;
  8661.     }
  8662.     
  8663.     public static SemaphoreConfiguration newSemaphoreConfiguration(long maxLife,long idleTime) {
  8664.         
  8665.         OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  8666.         Logger logTimers = OpenSPCoop2Logger.getLoggerOpenSPCoopTimers();
  8667.         
  8668.         SemaphoreConfiguration config = new SemaphoreConfiguration();
  8669.         config.setSerializableTimeWaitMs(propertiesReader.getGestioneSerializableDBAttesaAttiva());
  8670.         config.setSerializableNextIntervalTimeMs(propertiesReader.getGestioneSerializableDBCheckInterval());
  8671.         config.setMaxLife(maxLife);
  8672.         config.setMaxIdleTime(idleTime);
  8673.         boolean logEvent = propertiesReader.isTimerLockByDatabaseNotifyLogEnabled();
  8674.         config.setEmitEvent(logEvent);
  8675.         if(logEvent) {
  8676.             config.setEventGenerator(new SemaphoreLogEventGenerator(logTimers));
  8677.         }
  8678.         config.setIdNode(propertiesReader.getClusterId(true));
  8679.         config.setSerializableLevel(false); // in modo da non avere il lock esclusivo sulla tabella, cmq le entries sono inizializzate
  8680.         
  8681.         return config;
  8682.     }
  8683.     
  8684.     private static StringBuilder LOCK = new StringBuilder();
  8685.     private static String LOCK_MODULO = null;

  8687.     // I Metodi sotto riportati commentati funzionavano bene, ma non garantivano il fair dei lock, 
  8688.     // Inoltre alla scadenza del while non veniva lanciata una eccezione che indicava il timeout per l'acquisizione del lock
  8689.     // When fairness is set true, the semaphore guarantees that threads invoking any of the acquire methods are selected to obtain permits in the order in which their invocation of those methods was processed (first-in-first-out; FIFO)
  8690.     // NOTA: La sincronizzazione non servirebbe. Serve solo per avere maggiori informazioni diagnostiche
  8691.     
  8692.     // Con l'introduzione di più nodi il problema descritto più sopra nella sezione 'ELIMINAZIONE MESSAGGI'
  8693.     // si poteva ripresentare distribuito su più nodi. Per questo motivo l'implementazione del lock è stata distribuita grazie al semaforo implementato su database.
  8694.     // Tale semaforo e' stato poi implementato anche per gli altri timer che pero' non necessitano di una semaforizzazione nel caso non esistano piu' di una istanza di PdD
  8695.     // Questo comporta che la gestione tramite synchronized con lock viene attuata solamente per il timer di eliminazione messaggi che presentava tale problematica.
  8696.     
  8697.     private static final int LOCK_NUMBER_OF_PERMITS = 1;
  8698.     private static final boolean LOCK_FAIR_FIFO = true;
  8699.     private static java.util.concurrent.Semaphore LOCK_SEMAPHORE = new java.util.concurrent.Semaphore(LOCK_NUMBER_OF_PERMITS, LOCK_FAIR_FIFO);
  8700.     public static void acquireLock(GestoreMessaggi gestoreMessaggi, TimerLock timerLock,
  8701.             MsgDiagnostico msgDiag,String causa,long attesaAttivaLock,int checkIntervalLock) throws UtilsException, TimerLockNotAvailableException{
  8702.         acquireLock(gestoreMessaggi.getSemaphoreByInstance(timerLock.getIdLock()), gestoreMessaggi.getConnectionByInstance(), timerLock, 
  8703.                 msgDiag, causa, attesaAttivaLock, checkIntervalLock);
  8704.     }
  8705.     public static void acquireLock(Semaphore semaphoreDB, Connection connectionDB, TimerLock timerLock,
  8706.             MsgDiagnostico msgDiag,String causa,long attesaAttivaLock,int checkIntervalLock) throws UtilsException, TimerLockNotAvailableException{

  8708.         msgDiag.addKeyword(CostantiPdD.KEY_LOCK_CAUSALE, causa);
  8709.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneLock.inCorso");

  8711.         if(semaphoreDB!=null) {
  8712.             
  8713.             if(connectionDB==null) {
  8714.                 throw new UtilsException("Gestione Lock su db richiede una connessione");
  8715.             }
  8716.             try {
  8717.                 if(connectionDB.isClosed()) {
  8718.                     throw new UtilsException("Gestione Lock su db richiede una connessione attiva");
  8719.                 }
  8720.             }catch(Exception e) {
  8721.                 throw new UtilsException("Gestione Lock su db richiede una connessione attiva: "+e.getMessage(),e);
  8722.             }
  8723.             
  8724.             // La sleep ci vuole anche prima del primo lock, senno il timer che prende un lock continuera' a prenderlo.
  8725.             Utilities.sleep(checkIntervalLock);
  8726.             
  8727.             boolean lock = semaphoreDB.newLock(connectionDB, causa);
  8728.             int i=0;
  8729.             while(i<attesaAttivaLock && !lock){
  8730.                 Utilities.sleep(checkIntervalLock);
  8731.                 i=i+checkIntervalLock;
  8732.                 lock = semaphoreDB.newLock(connectionDB, causa);
  8733.             }
  8734.             if(!lock) {
  8735.                 String error = "Timeout: lock non disponibile dopo una attesa di "+attesaAttivaLock+"ms";
  8736.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, error);
  8737.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneLock.nonDisponibile");
  8738.                 throw new TimerLockNotAvailableException(error);
  8739.             }

  8741.         }
  8742.         else {
  8743.         
  8744.             if(TipoLock._getLockGestioneRepositoryMessaggi().equals(timerLock.getTipoLock())) {
  8745.             
  8746.                 synchronized (GestoreMessaggi.LOCK) {
  8747.         
  8748.                     // NOTA: puo' comunque succedere che un proprietario non esista, quindi non viene stampato il log con proprietario, pero' due thread in parallelo poi
  8749.                     //       chiamano il tryAcquire e quindi solo uno dei due lo prende. L'altro rimane bloccato senza aver emesso il log con precedente proprietario.          
  8750.                     if(GestoreMessaggi.LOCK.length()>0){
  8751.                         msgDiag.addKeyword(CostantiPdD.KEY_LOCK_CAUSALE, GestoreMessaggi.LOCK.toString());
  8752.                         msgDiag.addKeyword(CostantiPdD.KEY_LOCK_ID_MODULO, GestoreMessaggi.LOCK_MODULO);
  8753.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneLock.wait.existsOldOwner");
  8754.                     }
  8755.                     else{
  8756.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneLock.wait.withoutOwner");
  8757.                     }
  8758.         
  8759.                 }
  8760.         
  8761.                 /*
  8762.                  *  Acquires a permit from this semaphore, if one becomes available within the given waiting time and the current thread has not been interrupted.
  8763.                     Acquires a permit, if one is available and returns immediately/
  8764.         
  8765.                     If no permit is available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
  8766.                     - Some other thread invokes the release() method for this semaphore and the current thread is next to be assigned a permit; or
  8767.                     - Some other thread interrupts the current thread; or
  8768.                     - The specified waiting time elapses. 
  8769.         
  8770.                     If a permit is acquired then the value true is returned.
  8771.         
  8772.                     If the current thread:
  8773.                     - has its interrupted status set on entry to this method; or
  8774.                     - is interrupted while waiting to acquire a permit, 
  8775.                     then InterruptedException is thrown and the current thread's interrupted status is cleared.
  8776.         
  8777.                     If the specified waiting time elapses then the value false is returned. If the time is less than or equal to zero, the method will not wait at all. 
  8778.                  */
  8779.                 boolean lockAcquired = false;
  8780.                 try {
  8781.                     lockAcquired = LOCK_SEMAPHORE.tryAcquire(attesaAttivaLock, TimeUnit.MILLISECONDS);
  8782.                 }catch(InterruptedException ie) {
  8783.                     Thread.currentThread().interrupt();
  8784.                     throw new UtilsException("Timeout: lock non disponibile dopo una attesa di "+attesaAttivaLock+"ms (attuale modulo proprietario: "+GestoreMessaggi.LOCK_MODULO+", causa: "+GestoreMessaggi.LOCK.toString()+"): "+ie.getMessage(),ie);
  8785.                 }
  8786.                 if(lockAcquired==false){
  8787.                     throw new UtilsException("Timeout: lock non disponibile dopo una attesa di "+attesaAttivaLock+"ms (attuale modulo proprietario: "+GestoreMessaggi.LOCK_MODULO+", causa: "+GestoreMessaggi.LOCK.toString()+")");
  8788.                 }
  8789.         
  8790.                 GestoreMessaggi.LOCK.append(causa);
  8791.                 GestoreMessaggi.LOCK_MODULO = msgDiag.getFunzione();
  8792.                 
  8793.             }
  8794.             
  8795.         }

  8797.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneLock.ok");

  8799.     }

  8801.     public static void updateLock(GestoreMessaggi gestoreMessaggi, TimerLock timerLock,
  8802.             MsgDiagnostico msgDiag,String causa) throws UtilsException{
  8803.         updateLock(gestoreMessaggi.getSemaphoreByInstance(timerLock.getIdLock()), gestoreMessaggi.getConnectionByInstance(), timerLock, msgDiag, causa);
  8804.     }
  8805.     public static void updateLock(Semaphore semaphoreDB,  Connection connectionDB, TimerLock timerLock,
  8806.             MsgDiagnostico msgDiag,String causa) throws UtilsException{
  8807.         
  8808.         msgDiag.addKeyword(CostantiPdD.KEY_LOCK_CAUSALE, causa);
  8809.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "updateLock.inCorso");

  8811.         if(semaphoreDB!=null) {
  8812.             
  8813.             if(connectionDB==null) {
  8814.                 throw new UtilsException("Gestione Lock su db richiede una connessione");
  8815.             }
  8816.             try {
  8817.                 if(connectionDB.isClosed()) {
  8818.                     throw new UtilsException("Gestione Lock su db richiede una connessione attiva");
  8819.                 }
  8820.             }catch(Exception e) {
  8821.                 throw new UtilsException("Gestione Lock su db richiede una connessione attiva: "+e.getMessage(),e);
  8822.             }
  8823.             
  8824.             boolean unlock = semaphoreDB.updateLock(connectionDB, causa);
  8825.             if(!unlock) {
  8826.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "updateLock.ko");
  8827.                 throw new UtilsException(msgDiag.getMessaggio_replaceKeywords("all", "updateLock.ko"));
  8828.             }
  8829.         }
  8830.         else {
  8831.         
  8832.             // nop
  8833.             //aggiornamento non previsto con implementazione singleton
  8834.             
  8835.         }
  8836.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "updateLock.ok");
  8837.         
  8838.     }
  8839.     
  8840.     public static void releaseSafeLock(GestoreMessaggi gestoreMessaggi, TimerLock timerLock,
  8841.             MsgDiagnostico msgDiag,String causa) throws UtilsException{
  8842.         releaseSafeLock(gestoreMessaggi.getSemaphoreByInstance(timerLock.getIdLock()), gestoreMessaggi.getConnectionByInstance(), timerLock, msgDiag, causa);
  8843.     }
  8844.     public static void releaseSafeLock(Semaphore semaphoreDB,  Connection connectionDB, TimerLock timerLock,
  8845.             MsgDiagnostico msgDiag,String causa) throws UtilsException{
  8846.         try{
  8847.             releaseLock(
  8848.                     semaphoreDB, connectionDB, timerLock,
  8849.                     msgDiag, causa);
  8850.         }catch(Exception e){
  8851.             // ignore
  8852.         }
  8853.     }
  8854.     
  8855.     public static void releaseLock(GestoreMessaggi gestoreMessaggi, TimerLock timerLock,
  8856.             MsgDiagnostico msgDiag,String causa) throws UtilsException{
  8857.         releaseLock(gestoreMessaggi.getSemaphoreByInstance(timerLock.getIdLock()), gestoreMessaggi.getConnectionByInstance(), timerLock, msgDiag, causa);
  8858.     }
  8859.     public static void releaseLock(Semaphore semaphoreDB,  Connection connectionDB, TimerLock timerLock,
  8860.             MsgDiagnostico msgDiag,String causa) throws UtilsException{

  8862.         msgDiag.addKeyword(CostantiPdD.KEY_LOCK_CAUSALE, causa);
  8863.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneUnlock.inCorso");

  8865.         if(semaphoreDB!=null) {
  8866.             
  8867.             if(connectionDB==null) {
  8868.                 throw new UtilsException("Gestione Lock su db richiede una connessione");
  8869.             }
  8870.             try {
  8871.                 if(connectionDB.isClosed()) {
  8872.                     throw new UtilsException("Gestione Lock su db richiede una connessione attiva");
  8873.                 }
  8874.             }catch(Exception e) {
  8875.                 throw new UtilsException("Gestione Lock su db richiede una connessione attiva: "+e.getMessage(),e);
  8876.             }
  8877.             
  8878.             boolean unlock = semaphoreDB.releaseLock(connectionDB, causa);
  8879.             if(!unlock) {
  8880.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneUnlock.ko");
  8881.                 throw new UtilsException(msgDiag.getMessaggio_replaceKeywords("all", "acquisizioneUnlock.ko"));
  8882.             }
  8883.         }
  8884.         else {
  8885.         
  8886.             if(TipoLock._getLockGestioneRepositoryMessaggi().equals(timerLock.getTipoLock())) {
  8887.             
  8888.                 // Esiste solo un thread attivo, grazie al semaforo
  8889.                 // metto il synchronized per garantire il log consistente sopra
  8890.                 
  8891.                 if( ! (GestoreMessaggi.LOCK.length()>0) ){
  8892.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneUnlock.ko");
  8893.                     throw new UtilsException(msgDiag.getMessaggio_replaceKeywords("all", "acquisizioneUnlock.ko"));
  8894.                 }
  8895.         
  8896.                 synchronized (GestoreMessaggi.LOCK) {   
  8897.                     GestoreMessaggi.LOCK.delete(0, GestoreMessaggi.LOCK.length());
  8898.                     GestoreMessaggi.LOCK_MODULO = null;
  8899.                 }
  8900.                 LOCK_SEMAPHORE.release();
  8901.                 
  8902.             }
  8903.             
  8904.         }
  8905.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_ALL, "acquisizioneUnlock.ok");

  8907.     }

  8909. }
Created with JaCoCo 0.8.8.202204050719