IntegrationManager.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.services.skeleton;

  25. import java.util.ArrayList;
  26. import java.util.Date;
  27. import java.util.List;

  29. import javax.servlet.http.HttpServletRequest;
  30. import javax.servlet.http.HttpServletResponse;

  32. import org.openspcoop2.core.commons.CoreException;
  33. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  34. import org.openspcoop2.core.constants.TipoPdD;
  35. import org.openspcoop2.core.id.IDPortaApplicativa;
  36. import org.openspcoop2.core.id.IDServizio;
  37. import org.openspcoop2.core.id.IDServizioApplicativo;
  38. import org.openspcoop2.core.id.IDSoggetto;
  39. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  40. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  41. import org.openspcoop2.message.OpenSPCoop2Message;
  42. import org.openspcoop2.message.soap.TunnelSoapUtils;
  43. import org.openspcoop2.pdd.config.ClassNameProperties;
  44. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  45. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  46. import org.openspcoop2.pdd.core.AbstractCore;
  47. import org.openspcoop2.pdd.core.CostantiPdD;
  48. import org.openspcoop2.pdd.core.GestoreMessaggi;
  49. import org.openspcoop2.pdd.core.MessaggioServizioApplicativo;
  50. import org.openspcoop2.pdd.core.PdDContext;
  51. import org.openspcoop2.pdd.core.StatoServiziPdD;
  52. import org.openspcoop2.pdd.core.autenticazione.GestoreAutenticazione;
  53. import org.openspcoop2.pdd.core.autenticazione.pd.EsitoAutenticazionePortaDelegata;
  54. import org.openspcoop2.pdd.core.connettori.InfoConnettoreIngresso;
  55. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  56. import org.openspcoop2.pdd.core.credenziali.GestoreCredenzialiConfigurationException;
  57. import org.openspcoop2.pdd.core.credenziali.IGestoreCredenzialiIM;
  58. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  59. import org.openspcoop2.pdd.core.handlers.HandlerException;
  60. import org.openspcoop2.pdd.core.handlers.IntegrationManagerRequestContext;
  61. import org.openspcoop2.pdd.core.handlers.IntegrationManagerResponseContext;
  62. import org.openspcoop2.pdd.core.state.OpenSPCoopStateDBManager;
  63. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  64. import org.openspcoop2.pdd.core.transazioni.GestoreConsegnaMultipla;
  65. import org.openspcoop2.pdd.logger.Dump;
  66. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  67. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  68. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  69. import org.openspcoop2.pdd.logger.Tracciamento;
  70. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  71. import org.openspcoop2.pdd.services.service.RicezioneContenutiApplicativiIntegrationManagerService;
  72. import org.openspcoop2.pdd.timers.TimerMonitoraggioRisorseThread;
  73. import org.openspcoop2.pdd.timers.TimerThresholdThread;
  74. import org.openspcoop2.protocol.engine.LetturaParametriBusta;
  75. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  76. import org.openspcoop2.protocol.engine.URLProtocolContextImpl;
  77. import org.openspcoop2.protocol.engine.constants.Costanti;
  78. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  79. import org.openspcoop2.protocol.sdk.Busta;
  80. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  81. import org.openspcoop2.protocol.sdk.ProtocolException;
  82. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  83. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  84. import org.openspcoop2.protocol.sdk.builder.IBustaBuilder;
  85. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  86. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  87. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  88. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  89. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  90. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  91. import org.openspcoop2.protocol.sdk.constants.IDService;
  92. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  93. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  94. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  95. import org.openspcoop2.protocol.utils.ErroriProperties;
  96. import org.openspcoop2.utils.LoggerWrapperFactory;
  97. import org.openspcoop2.utils.Semaphore;
  98. import org.openspcoop2.utils.SemaphoreLock;
  99. import org.openspcoop2.utils.UtilsException;
  100. import org.openspcoop2.utils.date.DateManager;
  101. import org.openspcoop2.utils.id.IUniqueIdentifier;
  102. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  103. import org.openspcoop2.utils.resources.Loader;
  104. import org.openspcoop2.utils.transport.TransportRequestContext;
  105. import org.slf4j.Logger;

  107.         
  108. /**
  109.  * IntegrationManager service
  110.  *
  111.  *
  112.  * @author Lo Votrico Fabio (fabio@link.it)
  113.  * @author Poli Andrea (apoli@link.it)
  114.  * @author Tronci Fabio (tronci@link.it)
  115.  * @author Nardi Lorenzo (nardi@link.it)
  116.  * @author $Author$
  117.  * @version $Rev$, $Date$
  118.  */
  119.         
  120. public abstract class IntegrationManager implements IntegrationManagerMessageBoxInterface,IntegrationManagerPDInterface {

  122.     public static final IDService ID_SERVICE = IDService.INTEGRATION_MANAGER_SOAP;
  123.     public static final String ID_MODULO = ID_SERVICE.getValue();
  124.     
  125.     private static void logError(Logger logCore, String msg) {
  126.         logCore.error(msg);
  127.     }
  128.     private static void logError(Logger logCore, String msg, Throwable e) {
  129.         logCore.error(msg,e);
  130.     }
  131.     
  132.     private OpenSPCoop2Properties propertiesReader;
  133.     private ClassNameProperties className;

  135.     private static final boolean useNewMethod = true; // compatta diverse query e usa le date

  137.     private boolean inizializzato = false;

  139.     /** Indicazione se il servizio PD risulta attivo */
  140.     private static Semaphore semaphore = new Semaphore(ID_MODULO);
  141.     private static Boolean staticInitialized = false;
  142.     
  143.     private void init(){
  144.         if(!this.inizializzato){
  145.             this.propertiesReader = OpenSPCoop2Properties.getInstance();
  146.             this.className = ClassNameProperties.getInstance();
  147.             this.inizializzato = true;
  148.             SemaphoreLock lock = semaphore.acquireThrowRuntime("init");
  149.             try {
  150.                 if(!IntegrationManager.staticInitialized){
  151.                     IntegrationManager.staticInitialized = true;
  152.                 }
  153.             }finally {
  154.                 semaphore.release(lock, "init");
  155.             }
  156.         }
  157.     }


  160.     protected abstract HttpServletRequest getHttpServletRequest() throws IntegrationManagerException;
  161.     protected abstract HttpServletResponse getHttpServletResponse() throws IntegrationManagerException;

  163.     private ErroriProperties getErroriProperties(Logger log) {
  164.         ErroriProperties erroriProperties = null;
  165.         try {
  166.             erroriProperties = ErroriProperties.getInstance(log);
  167.         }catch(Exception ignore) {
  168.             // non succede
  169.         }
  170.         return erroriProperties;
  171.     }
  172.     
  173.     private IProtocolFactory<?> getProtocolFactory(Logger log) throws IntegrationManagerException{
  174.         try {
  175.             String protocolName = (String) getHttpServletRequest().getAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME.getValue());
  176.             return ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocolName);
  177.         } catch (Exception e) {
  178.             log.error("Errore durante il recupero della ProtocolFactory: "+e.getMessage(),e);
  179.             throw new IntegrationManagerException(null,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  180.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(log));
  181.         } 
  182.     }
  183.     
  184.     private void checkIMAuthorization(Logger log) throws IntegrationManagerException{
  185.         try {
  186.             Object o = getHttpServletRequest().getAttribute(org.openspcoop2.core.constants.Costanti.INTEGRATION_MANAGER_ENGINE_AUTHORIZED.getValue());
  187.             if(!(o instanceof Boolean)){
  188.                 throw new CoreException("Invocazione del Servizio non autorizzata");
  189.             }
  190.             Boolean b = (Boolean) o;
  191.             if(!b.booleanValue()){
  192.                 throw new CoreException("Invocazione del Servizio non autorizzata");
  193.             }
  194.         } catch (Exception e) {
  195.             log.error(e.getMessage(),e);
  196.             throw new IntegrationManagerException(null,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  197.                     IntegrationFunctionError.AUTHORIZATION, this.getErroriProperties(log));
  198.         } 
  199.     }
  200.     private void setNomePortaDelegata(Logger log,String nomePorta) throws IntegrationManagerException{
  201.         try {
  202.             getHttpServletRequest().setAttribute(org.openspcoop2.core.constants.Costanti.PORTA_DELEGATA.getValue(), nomePorta);
  203.         } catch (Exception e) {
  204.             log.error(e.getMessage(),e);
  205.             throw new IntegrationManagerException(null,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  206.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(log));
  207.         } 
  208.     }
  209.     
  210.     
  211.     public static InfoConnettoreIngresso buildInfoConnettoreIngresso(javax.servlet.http.HttpServletRequest req,Credenziali credenziali,URLProtocolContext urlProtocolContext){
  212.         // Informazioni connettore ingresso
  213.         InfoConnettoreIngresso connettoreIngresso = new InfoConnettoreIngresso();
  214.         connettoreIngresso.setCredenziali(credenziali);
  215.         connettoreIngresso.setFromLocation(urlProtocolContext.getSource());
  216.         connettoreIngresso.setUrlProtocolContext(urlProtocolContext);
  217.         return connettoreIngresso;
  218.     }
  219.     
  220.     private IntegrationManagerRequestContext buildIMRequestContext(Date dataRichiestaOperazione,
  221.             Operazione tipoOperazione, PdDContext pddContext, Logger logCore,IProtocolFactory<?> protocolFactory) throws IntegrationManagerException, ProtocolException, UtilsException{
  222.         
  223.         IntegrationManagerRequestContext imRequestContext = 
  224.             new IntegrationManagerRequestContext(dataRichiestaOperazione, tipoOperazione, pddContext, logCore,protocolFactory);
  225.         
  226.         // Raccolta oggetti da contesto
  227.         Credenziali credenziali = null;
  228.         javax.servlet.http.HttpServletRequest req = getHttpServletRequest();
  229.         URLProtocolContext urlProtocolContext = new URLProtocolContextImpl(req,logCore,true,true,this.propertiesReader.getCustomContexts());
  230.         try {
  231.             credenziali = new Credenziali(urlProtocolContext.getCredential());
  232.         }catch(Exception e){
  233.             credenziali = new Credenziali();
  234.         }
  235.         imRequestContext.setConnettore(buildInfoConnettoreIngresso(req, credenziali, urlProtocolContext));
  236.         
  237.         return imRequestContext;
  238.     }

  240.     /** IGestoreCredenziali: lista di gestori delle credenziali */
  241.     // E' stato aggiunto lo stato dentro l'oggetto.
  242.     private String [] tipiGestoriCredenziali = null;
  243.     private synchronized void initializeGestoreCredenziali(Logger logCore,IProtocolFactory<?> protocolFactory,MsgDiagnostico msgDiag) throws IntegrationManagerException{
  244.         if(this.tipiGestoriCredenziali==null){
  245.             
  246.             Loader loader = Loader.getInstance();
  247.             
  248.             this.tipiGestoriCredenziali = this.propertiesReader.getTipoGestoreCredenzialiIM();
  249.             if(this.tipiGestoriCredenziali!=null){
  250.                 for (int i = 0; i < this.tipiGestoriCredenziali.length; i++) {
  251.                     String classType = this.className.getGestoreCredenzialiIM(this.tipiGestoriCredenziali[i]);
  252.                     try {
  253.                         IGestoreCredenzialiIM gestore = (IGestoreCredenzialiIM)loader.newInstance(classType);
  254.                         gestore.toString();
  255.                     } catch (Exception e) {
  256.                         msgDiag.logErroreGenerico(e, "InizializzazioneGestoreCredenziali("+this.tipiGestoriCredenziali[i]+")");
  257.                         throw new IntegrationManagerException(protocolFactory,
  258.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  259.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_548_GESTORE_CREDENZIALI_NON_FUNZIONANTE),
  260.                                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  261.                     }
  262.                 }
  263.             }
  264.         }
  265.     }
  266.     private void gestioneCredenziali(Logger logCore,IProtocolFactory<?> protocolFactory,MsgDiagnostico msgDiag,
  267.             InfoConnettoreIngresso infoConnettoreIngresso,PdDContext pddContext) throws IntegrationManagerException {
  268.         if(this.tipiGestoriCredenziali==null){
  269.             initializeGestoreCredenziali(logCore,protocolFactory,msgDiag);
  270.         }
  271.         if(this.tipiGestoriCredenziali!=null){
  272.             msgDiag.mediumDebug("Gestione personalizzata delle credenziali...");
  273.             
  274.             Loader loader = Loader.getInstance();
  275.             
  276.             for (int i = 0; i < this.tipiGestoriCredenziali.length; i++) {
  277.                 try {
  278.                                     
  279.                     String classType = null;
  280.                     IGestoreCredenzialiIM gestore = null;
  281.                     try {
  282.                         classType = this.className.getGestoreCredenzialiIM(this.tipiGestoriCredenziali[i]);
  283.                         gestore = (IGestoreCredenzialiIM)loader.newInstance(classType);
  284.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  285.                     } catch (Exception e) {
  286.                         msgDiag.logErroreGenerico(e, "InizializzazioneGestoreCredenziali("+this.tipiGestoriCredenziali[i]+")");
  287.                         throw new IntegrationManagerException(protocolFactory,
  288.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  289.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_548_GESTORE_CREDENZIALI_NON_FUNZIONANTE),
  290.                                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  291.                     }
  292.                     
  293.                     if (gestore != null) {
  294.                         Credenziali credenzialiRitornate = gestore.elaborazioneCredenziali(infoConnettoreIngresso);
  295.                         if(credenzialiRitornate==null){
  296.                             throw new CoreException("Credenziali non ritornate");
  297.                         }
  298.                         if(infoConnettoreIngresso.getCredenziali().equals(credenzialiRitornate) == false){
  299.                             String nuoveCredenziali = credenzialiRitornate.toString();
  300.                             nuoveCredenziali = nuoveCredenziali.substring(0,(nuoveCredenziali.length()-1));
  301.                             msgDiag.addKeyword(CostantiPdD.KEY_NUOVE_CREDENZIALI,nuoveCredenziali);
  302.                             String identita = gestore.getIdentitaGestoreCredenziali();
  303.                             if(identita==null){
  304.                                 identita = "Gestore delle credenziali di tipo "+this.tipiGestoriCredenziali[i];
  305.                             }
  306.                             msgDiag.addKeyword(CostantiPdD.KEY_IDENTITA_GESTORE_CREDENZIALI, identita);
  307.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.IDENTITA_GESTORE_CREDENZIALI, identita);
  308.                             msgDiag.logPersonalizzato("gestoreCredenziali.nuoveCredenziali");
  309.                             // update credenziali
  310.                             infoConnettoreIngresso.setCredenziali(credenzialiRitornate);    
  311.                         }
  312.                     } else {
  313.                         throw new CoreException("non inizializzato");
  314.                     }
  315.                 } 
  316.                 catch (Exception e) {
  317.                     OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Errore durante l'identificazione delle credenziali ["+ this.tipiGestoriCredenziali[i]
  318.                              + "]: "+ e.getMessage(),e);
  319.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_GESTORE_CREDENZIALI,this.tipiGestoriCredenziali[i]);
  320.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  321.                     msgDiag.logPersonalizzato("gestoreCredenziali.errore");
  322.                     ErroreIntegrazione errore = null;
  323.                     IntegrationFunctionError integrationFunctionError = null;
  324.                     if(e instanceof GestoreCredenzialiConfigurationException){
  325.                         GestoreCredenzialiConfigurationException ge = (GestoreCredenzialiConfigurationException) e;
  326.                         integrationFunctionError = ge.getIntegrationFunctionError();
  327.                         errore = ErroriIntegrazione.ERRORE_431_GESTORE_CREDENZIALI_ERROR.
  328.                                 getErrore431_ErroreGestoreCredenziali(this.tipiGestoriCredenziali[i], e);
  329.                     }else{
  330.                         errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  331.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_548_GESTORE_CREDENZIALI_NON_FUNZIONANTE);
  332.                     }
  333.                     if(integrationFunctionError==null) {
  334.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  335.                     }
  336.                     
  337.                     throw new IntegrationManagerException(protocolFactory,errore,
  338.                             integrationFunctionError, this.getErroriProperties(logCore));
  339.                     
  340.                 }
  341.             }
  342.         }
  343.     }

  345.     /**
  346.      * Effettua il processo di autenticazione
  347.      *
  348.      * @return il nome del Servizio Applicativo invocante
  349.      * 
  350.      */
  351.     private IDServizioApplicativo autenticazione(Logger logCore, IProtocolFactory<?> protocolFactory,MsgDiagnostico msgDiag,InfoConnettoreIngresso infoConnettoreIngresso,
  352.             ConfigurazionePdDManager configPdDManager,PdDContext pddContext) throws IntegrationManagerException {
  353.         
  354.         Credenziali credenziali = infoConnettoreIngresso.getCredenziali();
  355.         
  356.         // Autenticazione
  357.         String credenzialiFornite = "";
  358.         if(credenziali!=null){
  359.             credenzialiFornite = credenziali.toString();
  360.         }       
  361.         msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_SA_FRUITORE, credenzialiFornite);

  363.         IDServizioApplicativo servizioApplicativo = null;       
  364.         String [] tipoAutenticazione = configPdDManager.getIntegrationManagerAuthentication();
  365.         if(tipoAutenticazione==null || tipoAutenticazione.length<1){
  366.             msgDiag.logPersonalizzato("autenticazioneNonImpostata");
  367.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  368.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_519_INTEGRATION_MANAGER_CONFIGURATION_ERROR),
  369.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  370.         }
  371.         for(int i=0; i<tipoAutenticazione.length; i++){
  372.             if(CostantiConfigurazione.INVOCAZIONE_SERVIZIO_AUTENTICAZIONE_NONE.toString().equalsIgnoreCase(tipoAutenticazione[i]) == true){
  373.                 msgDiag.logPersonalizzato("autenticazioneNonImpostata");
  374.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  375.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_519_INTEGRATION_MANAGER_CONFIGURATION_ERROR),
  376.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  377.             }
  378.         }
  379.         
  380.         StringBuilder errori = new StringBuilder();
  381.         for(int i=0; i<tipoAutenticazione.length; i++){
  382.             
  383.             org.openspcoop2.pdd.core.autenticazione.pd.DatiInvocazionePortaDelegata datiInvocazione = new org.openspcoop2.pdd.core.autenticazione.pd.DatiInvocazionePortaDelegata();
  384.             datiInvocazione.setInfoConnettoreIngresso(infoConnettoreIngresso);
  385.             
  386.             EsitoAutenticazionePortaDelegata esito = null;
  387.             try{
  388.                 esito = GestoreAutenticazione.verificaAutenticazioneMessageBox(tipoAutenticazione[i], 
  389.                         datiInvocazione, null, 
  390.                         pddContext, protocolFactory); 
  391.             }catch(Exception e){
  392.                 msgDiag.logErroreGenerico(e,"Autenticazione("+tipoAutenticazione[i]+")");
  393.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  394.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_503_AUTENTICAZIONE),
  395.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  396.             }   
  397.             if(esito.getDetails()==null){
  398.                 msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  399.             }else{
  400.                 msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, " ("+esito.getDetails()+")");
  401.             }
  402.             if (esito.isClientAuthenticated()==false || esito.isClientIdentified() == false) {
  403.                 if(errori.length()>0 || tipoAutenticazione.length>1)
  404.                     errori.append("\n");
  405.                 try{
  406.                     if(esito.getErroreIntegrazione()!=null) {
  407.                         errori.append("(Autenticazione " +tipoAutenticazione[i]+") "+ esito.getErroreIntegrazione().getDescrizione(protocolFactory));
  408.                     }
  409.                     else {
  410.                         // l'errore puo' non esserci se l'identificazione non e' obbligatoria nella modalita' scelta.
  411.                         errori.append("(Autenticazione " +tipoAutenticazione[i]+") non ha identificato alcun servizio applicativo");
  412.                     }
  413.                 }catch(Exception e){
  414.                     OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Errore durante l'identificazione dell'errore: "+e.getMessage(),e);
  415.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  416.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_519_INTEGRATION_MANAGER_CONFIGURATION_ERROR),
  417.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  418.                 }
  419.             }
  420.             else{
  421.                 servizioApplicativo = esito.getIdServizioApplicativo();
  422.                 break; //sa individuato
  423.             }
  424.         }
  425.         
  426.         if(servizioApplicativo == null){
  427.             if(errori.length()>0){
  428.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errori.toString());
  429.                 msgDiag.logPersonalizzato("servizioApplicativo.identificazioneTramiteCredenziali");
  430.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_402_AUTENTICAZIONE_FALLITA.
  431.                         getErrore402_AutenticazioneFallita(errori.toString()),
  432.                         IntegrationFunctionError.AUTHENTICATION, this.getErroriProperties(logCore));
  433.             }
  434.             else{
  435.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "servizio applicativo non autenticato");
  436.                 msgDiag.logPersonalizzato("servizioApplicativo.identificazioneTramiteCredenziali");
  437.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  438.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_503_AUTENTICAZIONE),
  439.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  440.             }
  441.         }
  442.         
  443.         msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, servizioApplicativo.getNome());
  444.         msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, servizioApplicativo.getNome());
  445.         msgDiag.setServizioApplicativo(servizioApplicativo.getNome());
  446.         if(servizioApplicativo.getIdSoggettoProprietario()!=null){
  447.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MITTENTE_BUSTA_RICHIESTA, servizioApplicativo.getIdSoggettoProprietario().getTipo());
  448.             msgDiag.addKeyword(CostantiPdD.KEY_MITTENTE_BUSTA_RICHIESTA, servizioApplicativo.getIdSoggettoProprietario().getNome());
  449.             msgDiag.setFruitore(servizioApplicativo.getIdSoggettoProprietario());
  450.         }
  451.         return  servizioApplicativo;
  452.     }


  455.     /* ----------- Init -------------- */
  456.     private void verificaRisorseSistema(IProtocolFactory<?> protocolFactory,Logger logCore,String tipoOperazione) throws IntegrationManagerException {
  457.         
  458.         if( !OpenSPCoop2Startup.initialize){
  459.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Inizializzazione di GovWay non correttamente effettuata");
  460.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  461.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),
  462.                     IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, this.getErroriProperties(logCore));
  463.         }
  464.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  465.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Risorse di sistema non disponibili: "+TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage(),TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  466.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  467.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_532_RISORSE_NON_DISPONIBILI),
  468.                     IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, this.getErroriProperties(logCore));
  469.         }
  470.         if (!TimerThresholdThread.freeSpace) {
  471.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Non sono disponibili abbastanza risorse per la gestione della richiesta");
  472.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  473.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_533_RISORSE_DISPONIBILI_LIVELLO_CRITICO),
  474.                     IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, this.getErroriProperties(logCore));
  475.         }
  476.         if( !Tracciamento.tracciamentoDisponibile){
  477.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Tracciatura non disponibile: "+Tracciamento.motivoMalfunzionamentoTracciamento.getMessage(),Tracciamento.motivoMalfunzionamentoTracciamento);
  478.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  479.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_545_TRACCIATURA_NON_FUNZIONANTE),
  480.                     IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, this.getErroriProperties(logCore));
  481.         }
  482.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  483.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Sistema di diagnostica non disponibile: "+MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage(),MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  484.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  485.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_546_DIAGNOSTICA_NON_FUNZIONANTE),
  486.                     IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, this.getErroriProperties(logCore));
  487.         }
  488.         if( !Dump.isSistemaDumpDisponibile()){
  489.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Sistema di dump dei contenuti applicativi non disponibile: "+Dump.getMotivoMalfunzionamentoDump().getMessage(),Dump.getMotivoMalfunzionamentoDump());
  490.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  491.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_547_DUMP_CONTENUTI_APPLICATIVI_NON_FUNZIONANTE),
  492.                     IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, this.getErroriProperties(logCore));
  493.         }
  494.         // Check Configurazione (XML)
  495.         try{
  496.             ConfigurazionePdDManager.getInstance().verificaConsistenzaConfigurazione();
  497.         }catch(Exception e){
  498.             logError(logCore, "["+IntegrationManager.ID_MODULO+"]["+tipoOperazione+"] Riscontrato errore durante la verifica della consistenza della configurazione PdD",e);
  499.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  500.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  501.                     IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, this.getErroriProperties(logCore));
  502.         }
  503.         
  504.         boolean serviceIsEnabled = false;
  505.         Exception serviceIsEnabledExceptionProcessamento = null;
  506.         try{
  507.             serviceIsEnabled = StatoServiziPdD.isEnabledIntegrationManager();
  508.         }catch(Exception e){
  509.             serviceIsEnabledExceptionProcessamento = e;
  510.         }
  511.         if (!serviceIsEnabled || serviceIsEnabledExceptionProcessamento!=null) {
  512.             if(serviceIsEnabledExceptionProcessamento!=null){
  513.                 logError(logCore, "["+ IntegrationManager.ID_MODULO+ "]["+tipoOperazione+"] Identificazione stato servizio IntegrationManager non riuscita: "+serviceIsEnabledExceptionProcessamento.getMessage(),serviceIsEnabledExceptionProcessamento);
  514.             }else{
  515.                 logError(logCore, "["+ IntegrationManager.ID_MODULO+ "]["+tipoOperazione+"] Servizio IntegrationManager disabilitato");
  516.             }
  517.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  518.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_552_IM_SERVICE_NOT_ACTIVE),
  519.                     IntegrationFunctionError.API_SUSPEND, this.getErroriProperties(logCore));
  520.         }

  522.     }
  523.     
  524.     /* -------- Utility -------------- */
  525.     private IUniqueIdentifier getUniqueIdentifier(Logger logCore, IProtocolFactory<?> protocolFactory,MsgDiagnostico msgDiag,String tipoOperazione) throws IntegrationManagerException {
  526.         try{
  527.             return UniqueIdentifierManager.newUniqueIdentifier();
  528.         }catch(Exception e){
  529.             msgDiag.logErroreGenerico(e,"("+tipoOperazione+").getUniqueIdentifier()");
  530.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  531.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  532.         }
  533.     }
  534.     private MsgDiagnostico getMsgDiagnostico(){
  535.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(IntegrationManager.ID_MODULO);
  536.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_INTEGRATION_MANAGER);
  537.         return msgDiag;
  538.     }
  539.     
  540.     private EsitoTransazione getEsitoTransazione(IProtocolFactory<?> pf,IntegrationManagerRequestContext imRequestContext, EsitoTransazioneName name) throws ProtocolException{
  541.         TransportRequestContext t = null;
  542.         if(imRequestContext!=null && imRequestContext.getConnettore()!=null){
  543.             t = imRequestContext.getConnettore().getUrlProtocolContext();
  544.         }
  545.         return pf.createEsitoBuilder().getEsito(t,name);
  546.     }
  547.     


  550.     /*-------- getAllMessagesID ----*/

  552.     /**
  553.      * Restituisce gli id di tutti i messaggi in base al servizio_applicativo
  554.      * Al servizio e all'azione se presenti
  555.      *
  556.      * @param tipoServizio Filtro per Servizio
  557.      * @param servizio Filtro per Servizio
  558.      * @param azione Filtro per Azione
  559.      * @param counter Indica il numero di id da ritornare
  560.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  561.      * 
  562.      */
  563.     private List<String> getAllMessagesId_engine(Operazione tipoOperazione,String tipoServizio,String servizio, Integer versioneServizio,
  564.             String azione,int counter, int offset) throws IntegrationManagerException {

  566.         // Timestamp
  567.         Date dataRichiestaOperazione = DateManager.getTimestamp();
  568.         
  569.         // Logger
  570.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  571.         if(logCore==null)
  572.             logCore = LoggerWrapperFactory.getLogger(IntegrationManager.ID_MODULO);
  573.         
  574.         // check Autorizzazione
  575.         checkIMAuthorization(logCore);
  576.         
  577.         // ProtocolFactoyr
  578.         IProtocolFactory<?> protocolFactory = getProtocolFactory(logCore);
  579.         
  580.         // Verifica risorse sistema
  581.         this.verificaRisorseSistema(protocolFactory,logCore, tipoOperazione.toString());

  583.         MsgDiagnostico msgDiag = getMsgDiagnostico();
  584.         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_OPERAZIONE_IM, tipoOperazione.toString());
  585.         
  586.         IDServizioApplicativo idServizioApplicativo = null;
  587.         OpenSPCoopStateful stato = null;
  588.         
  589.         // PddContext
  590.         PdDContext pddContext = new PdDContext();
  591.         String idTransazione = this.getUniqueIdentifier(logCore, protocolFactory,msgDiag,tipoOperazione.toString()).getAsString();
  592.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  593.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  594.         
  595.         IDServizio idServizio = null;
  596.         try {
  597.             int ver = -1;
  598.             if(versioneServizio!=null) {
  599.                 ver = versioneServizio;
  600.             }
  601.             idServizio = IDServizioFactory.getInstance().getIDServizioFromValuesWithoutCheck(tipoServizio,servizio, 
  602.                 OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory.getProtocol(), null).getTipo(), 
  603.                 OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory.getProtocol(), null).getNome(), 
  604.                 ver);
  605.         } catch(Exception e) {
  606.             msgDiag.logErroreGenerico(e, "IDServizioFactory.getIDServizioFromValues");
  607.             ErroreIntegrazione erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  608.             throw new IntegrationManagerException(protocolFactory,erroreIntegrazione,
  609.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  610.         }
  611.         idServizio.setAzione(azione);
  612.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_SERVIZIO,idServizio);
  613.         msgDiag.setPddContext(pddContext, protocolFactory);
  614.         
  615.         
  616.         
  617.         /* ------------  IntegrationManagerRequestHandler ------------- */
  618.         IntegrationManagerRequestContext imRequestContext = null;
  619.         try {
  620.             imRequestContext = buildIMRequestContext(dataRichiestaOperazione, tipoOperazione, pddContext,logCore,protocolFactory);
  621.             GestoreHandlers.integrationManagerRequest(imRequestContext, msgDiag, logCore);
  622.         } catch(Exception e) {
  623.             ErroreIntegrazione erroreIntegrazione = null;
  624.             IntegrationFunctionError integrationFunctionError = null;
  625.             if(e instanceof HandlerException){
  626.                 HandlerException he = (HandlerException) e;
  627.                 integrationFunctionError = he.getIntegrationFunctionError();
  628.                 if(he.isEmettiDiagnostico()){
  629.                     msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  630.                 }
  631.                 erroreIntegrazione = he.convertToErroreIntegrazione();
  632.             } else {
  633.                 msgDiag.logErroreGenerico(e, "IntegrationManagerRequestHandler");
  634.             } 
  635.             if(erroreIntegrazione==null){
  636.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  637.             }
  638.             if(integrationFunctionError==null) {
  639.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  640.             }
  641.             throw new IntegrationManagerException(protocolFactory,erroreIntegrazione,
  642.                     integrationFunctionError, this.getErroriProperties(logCore));
  643.         }

  645.         
  646.         
  647.         /* ------------  Gestione Operazione ------------- */
  648.         IntegrationManagerResponseContext imResponseContext = 
  649.             new IntegrationManagerResponseContext(dataRichiestaOperazione,tipoOperazione,pddContext,logCore,protocolFactory);
  650.         if(imRequestContext!=null){
  651.             imResponseContext.setConnettore(imRequestContext.getConnettore());
  652.         }
  653.         
  654.         try{
  655.             
  656.             // init stato
  657.             stato = new OpenSPCoopStateful();
  658.             stato.initResource(this.propertiesReader.getIdentitaPortaDefault(protocolFactory.getProtocol(), null),IntegrationManager.ID_MODULO, idTransazione, 
  659.                     OpenSPCoopStateDBManager.messageBox);
  660.             ConfigurazionePdDManager configPdDManager = ConfigurazionePdDManager.getInstance(stato.getStatoRichiesta(),stato.getStatoRisposta());
  661.             msgDiag.updateState(configPdDManager);
  662.             
  663.             // gestione credenziali
  664.             this.gestioneCredenziali(logCore, protocolFactory,msgDiag, imRequestContext.getConnettore(),pddContext);
  665.                         
  666.             // Autenticazione Servizio Applicativo
  667.             idServizioApplicativo = autenticazione(logCore, protocolFactory,msgDiag,imRequestContext.getConnettore(),configPdDManager,pddContext);
  668.             imResponseContext.setServizioApplicativo(idServizioApplicativo);
  669.             String tipoServizioLog = "";
  670.             String servizioLog = "";
  671.             String azioneLog = "";
  672.             String counterLog = "";
  673.             if(tipoServizio!=null)
  674.                 tipoServizioLog = " tipoServizio["+tipoServizio+"]";
  675.             if(servizio!=null)
  676.                 servizioLog = " servizio["+servizio+"]";
  677.             if(azione!=null)
  678.                 azioneLog = " azione["+azione+"]";
  679.             if(counter>=0)
  680.                 counterLog = " counter["+counter+"]";
  681.             String param = "ServizioApplicativo["+idServizioApplicativo.getNome()+"]"+tipoServizioLog+servizioLog+azioneLog+counterLog;
  682.             msgDiag.addKeyword(CostantiPdD.KEY_PARAMETRI_OPERAZIONE_IM, param);
  683.             msgDiag.logPersonalizzato("logInvocazioneOperazione");

  685.             // Ricerca Messaggi
  686.             List<IdentificativoIM> ids = null;

  688.             GestoreMessaggi gestoreMessaggi = new GestoreMessaggi(stato, true, msgDiag,pddContext);

  690.             if(counter<0 && offset<0){
  691.                 ids = gestoreMessaggi.getIDMessaggi_ServizioApplicativo(idServizioApplicativo.getNome(),tipoServizio,servizio,azione);
  692.             }else if(offset<0){
  693.                 ids = gestoreMessaggi.getIDMessaggi_ServizioApplicativo(idServizioApplicativo.getNome(),tipoServizio,servizio,azione,counter);
  694.             }else{
  695.                 ids = gestoreMessaggi.getIDMessaggi_ServizioApplicativo(idServizioApplicativo.getNome(),tipoServizio,servizio,azione,counter,offset);
  696.             }
  697.             if(ids==null || ids.isEmpty()){
  698.                 msgDiag.logPersonalizzato("messaggiNonPresenti");
  699.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_406_INTEGRATION_MANAGER_MESSAGGI_FOR_SIL_NON_TROVATI.
  700.                         getErroreIntegrazione(),idServizioApplicativo,
  701.                         IntegrationFunctionError.IM_MESSAGES_NOT_FOUND, this.getErroriProperties(logCore));
  702.             }
  703.             List<String> listResponse = new ArrayList<>();
  704.             if(ids!=null && !ids.isEmpty()){
  705.                 for (IdentificativoIM id : ids) {
  706.                     if(this.propertiesReader.isIntegrationManagerIdWithDate()) {
  707.                         listResponse.add(id.getIdWithDate());
  708.                     }
  709.                     else {
  710.                         listResponse.add(id.getId());
  711.                     }   
  712.                 }
  713.             }

  715.             imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.OK));
  716.             
  717.             return listResponse;

  719.         }catch(Exception e){
  720.             
  721.             try{
  722.                 imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX));
  723.     
  724.                 if(e instanceof IntegrationManagerException){
  725.                     IntegrationManagerException exc = (IntegrationManagerException) e;
  726.                     if(CodiceErroreIntegrazione.CODICE_402_AUTENTICAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione()) ||
  727.                             CodiceErroreIntegrazione.CODICE_431_GESTORE_CREDENZIALI_ERROR.equals(exc.getCodiceErroreIntegrazione())){
  728.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTENTICAZIONE_FALLITA));
  729.                     }else if(CodiceErroreIntegrazione.CODICE_406_INTEGRATION_MANAGER_MESSAGGI_FOR_SIL_NON_TROVATI.equals(exc.getCodiceErroreIntegrazione())){
  730.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.MESSAGGI_NON_PRESENTI));
  731.                     }
  732.                 }
  733.             }catch(Exception eInteral){
  734.                 logError(logCore, "Errore durante la generazione dell'esito: "+eInteral.getMessage(),eInteral);
  735.                 imResponseContext.setEsito(EsitoTransazione.ESITO_TRANSAZIONE_ERROR);
  736.             }
  737.             
  738.             // Controllo Eccezioni
  739.             if(e instanceof IntegrationManagerException){
  740.                 // Lanciata all'interno del metodo
  741.                 throw (IntegrationManagerException)e;
  742.             }else{
  743.                 msgDiag.logErroreGenerico(e,"getAllMessagesId("+tipoOperazione+")");
  744.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),idServizioApplicativo,
  745.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  746.             }
  747.         }finally{
  748.             try{
  749.                 if(stato!=null)
  750.                     stato.releaseResource();
  751.             }catch(Exception eClose){}
  752.             
  753.             
  754.             /* ------------  IntegrationManagerResponseHandler ------------- */
  755.             imResponseContext.setDataCompletamentoOperazione(DateManager.getDate());
  756.             try{
  757.                 GestoreHandlers.integrationManagerResponse(imResponseContext, msgDiag, logCore);
  758.             }catch(Exception e){
  759.                 if(e instanceof HandlerException){
  760.                     HandlerException he = (HandlerException) e;
  761.                     if(he.isEmettiDiagnostico()){
  762.                         msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  763.                     }
  764.                 }else{
  765.                     msgDiag.logErroreGenerico(e, "IntegrationManagerResponseHandler");
  766.                 }
  767.             }
  768.         }
  769.     }
  770.     /**
  771.      * Restituisce gli id di tutti i messaggi in base al servizio_applicativo
  772.      *
  773.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  774.      * 
  775.      */
  776.     @Override
  777.     public List<String> getAllMessagesId() throws IntegrationManagerException {
  778.         init();
  779.         return getAllMessagesId_engine(Operazione.getAllMessagesId,null,null,null,null,-1,-1);
  780.     }


  783.     /**
  784.      * Restituisce gli id di tutti i messaggi in base a servizio_applicativo, servizio
  785.      *
  786.      * @param tipoServizio Filtro per Servizio
  787.      * @param servizio Filtro per Servizio
  788.      * @param azione Filtro per Azione
  789.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  790.      * 
  791.      */
  792.     @Override
  793.     public List<String> getAllMessagesIdByService(String tipoServizio, String servizio, String azione) throws IntegrationManagerException {
  794.         init();
  795.         return getAllMessagesId_engine(Operazione.getAllMessagesIdByService,tipoServizio,servizio,null,azione,-1,-1);
  796.     }


  799.     /**
  800.      * Restituisce gli id dei primi <var>counter</var> i messaggi, in base al servizio_applicativo,
  801.      *
  802.      * @param counter Indica il numero di id da ritornare
  803.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  804.      * 
  805.      */
  806.     @Override
  807.     @Deprecated
  808.     public List<String> getNextMessagesId(int counter) throws IntegrationManagerException {
  809.         init();
  810.         return getAllMessagesId_engine(Operazione.getNextMessagesId,null,null,null,null,counter,-1);    
  811.     }

  813.     /**
  814.      *  Restituisce gli id dei primi <var>counter</var> i messaggi, in base a servizio_applicativo, servizio
  815.      *
  816.      * @param counter Indica il numero di id da ritornare
  817.      * @param tipoServizio Filtro per Servizio
  818.      * @param servizio Filtro per Servizio
  819.      * @param azione Filtro per Azione
  820.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  821.      * 
  822.      */
  823.     @Override
  824.     @Deprecated
  825.     public List<String> getNextMessagesIdByService(int counter,String tipoServizio,String servizio, String azione) throws IntegrationManagerException {
  826.         init();
  827.         return getAllMessagesId_engine(Operazione.getNextMessagesIdByService,tipoServizio,servizio,null,azione,counter,-1); 
  828.     }
  829.     
  830.     /**
  831.      * Restituisce gli id dei primi <var>counter</var> i messaggi, in base al servizio_applicativo,
  832.      *
  833.      * @param counter Indica il numero di id da ritornare
  834.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  835.      * 
  836.      */
  837.     @Override
  838.     public List<String> getMessagesIdArray(int offset,int counter) throws IntegrationManagerException {
  839.         init();
  840.         return getAllMessagesId_engine(Operazione.getMessagesIdArray,null,null,null,null,counter,offset);   
  841.     }

  843.     /**
  844.      *  Restituisce gli id dei primi <var>counter</var> i messaggi, in base a servizio_applicativo, servizio
  845.      *
  846.      * @param counter Indica il numero di id da ritornare
  847.      * @param tipoServizio Filtro per Servizio
  848.      * @param servizio Filtro per Servizio
  849.      * @param azione Filtro per Azione
  850.      * @return una Collezione di ID di risposte applicative destinate al servizio applicativo che ha invocato il servizio
  851.      * 
  852.      */
  853.     @Override
  854.     public List<String> getMessagesIdArrayByService(int offset,int counter,String tipoServizio,String servizio, String azione) throws IntegrationManagerException {
  855.         init();
  856.         return getAllMessagesId_engine(Operazione.getMessagesIdArrayByService,tipoServizio,servizio,null,azione,counter,offset);    
  857.     }









  867.     /* ------ Get ----- */

  869.     /**
  870.      * Recupera e restituisce un messaggio
  871.      *
  872.      * @param idMessaggio ID del Messaggio da recuperare
  873.      * @param isRiferimentoMessaggio Indicazione se l'id e' un riferimento messaggio
  874.      * @return un Message contenente il messaggio recuperato (e informazioni supplementari)
  875.      * 
  876.      */
  877.     private IntegrationManagerMessage getMessage_engine(Operazione tipoOperazione, String idMessaggioParam, boolean isRiferimentoMessaggio) throws IntegrationManagerException {

  879.         // Timestamp
  880.         Date dataRichiestaOperazione = DateManager.getTimestamp();
  881.         
  882.         // Logger
  883.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  884.         if(logCore==null)
  885.             logCore = LoggerWrapperFactory.getLogger(IntegrationManager.ID_MODULO);

  887.         // check Autorizzazione
  888.         checkIMAuthorization(logCore);
  889.         
  890.         // ProtocolFactoyr
  891.         IProtocolFactory<?> protocolFactory = getProtocolFactory(logCore);
  892.         
  893.         // Verifica risorse sistema
  894.         this.verificaRisorseSistema(protocolFactory,logCore, tipoOperazione.toString());

  896.         MsgDiagnostico msgDiag = getMsgDiagnostico();
  897.         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_OPERAZIONE_IM, tipoOperazione.toString());

  899.         // Parse identificativo
  900.         String idMessaggio = null;
  901.         Date dataMessaggio = null;
  902.         if(this.propertiesReader.isIntegrationManagerIdWithDate()) {
  903.             IdentificativoIM idIM = IdentificativoIM.getIdentificativoIM(idMessaggioParam, logCore);
  904.             idMessaggio = idIM.getId();
  905.             dataMessaggio = idIM.getData();
  906.         }
  907.         else {
  908.             idMessaggio = idMessaggioParam;
  909.         }
  910.         
  911.         // Context
  912.         if(isRiferimentoMessaggio){
  913.             msgDiag.addKeyword(CostantiPdD.KEY_RIFERIMENTO_MESSAGGIO_RICHIESTA, idMessaggio);
  914.             msgDiag.addKeyword(CostantiPdD.KEY_RIFERIMENTO_MESSAGGIO_RISPOSTA, idMessaggio);
  915.         }else{
  916.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessaggio);
  917.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, idMessaggio);
  918.         }
  919.         
  920.         IDServizioApplicativo idServizioApplicativo = null;
  921.         OpenSPCoopStateful stato = null;
  922.         // PddContext
  923.         PdDContext pddContext = new PdDContext();
  924.         String idTransazione = this.getUniqueIdentifier(logCore, protocolFactory,msgDiag,tipoOperazione.toString()).getAsString();
  925.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  926.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_MESSAGGIO,idMessaggio);
  927.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME,protocolFactory.getProtocol());
  928.         msgDiag.setPddContext(pddContext, protocolFactory);
  929.         
  930.         
  931.         /* ------------  IntegrationManagerRequesCHandler ------------- */
  932.         IntegrationManagerRequestContext imRequestContext = null;
  933.         try{
  934.             imRequestContext = buildIMRequestContext(dataRichiestaOperazione, tipoOperazione, pddContext,logCore,protocolFactory);
  935.             imRequestContext.setIdMessaggio(idMessaggio);
  936.             GestoreHandlers.integrationManagerRequest(imRequestContext, msgDiag, logCore);
  937.         }catch(Exception e){
  938.             ErroreIntegrazione erroreIntegrazione = null;
  939.             IntegrationFunctionError integrationFunctionError = null;
  940.             if(e instanceof HandlerException){
  941.                 HandlerException he = (HandlerException) e;
  942.                 integrationFunctionError = he.getIntegrationFunctionError();
  943.                 if(he.isEmettiDiagnostico()){
  944.                     msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  945.                 }
  946.                 erroreIntegrazione = he.convertToErroreIntegrazione();
  947.             }else{
  948.                 msgDiag.logErroreGenerico(e, "IntegrationManagerRequestHandler");
  949.             }
  950.             if(erroreIntegrazione==null){
  951.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  952.             }
  953.             if(integrationFunctionError==null) {
  954.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  955.             }
  956.             throw new IntegrationManagerException(protocolFactory,erroreIntegrazione,
  957.                     integrationFunctionError, this.getErroriProperties(logCore));
  958.         }
  959.         
  960.         
  961.         /* ------------  Gestione Operazione ------------- */
  962.         IntegrationManagerResponseContext imResponseContext = 
  963.             new IntegrationManagerResponseContext(dataRichiestaOperazione,tipoOperazione,pddContext,logCore,protocolFactory);
  964.         if(imRequestContext!=null){
  965.             imResponseContext.setConnettore(imRequestContext.getConnettore());
  966.         }
  967.         imResponseContext.setIdMessaggio(idMessaggio);
  968.         try{

  970.             // init stato
  971.             stato = new OpenSPCoopStateful();
  972.             stato.initResource(this.propertiesReader.getIdentitaPortaDefault(protocolFactory.getProtocol(), null),IntegrationManager.ID_MODULO, idTransazione, 
  973.                     OpenSPCoopStateDBManager.messageBox);
  974.             ConfigurazionePdDManager configPdDManager = ConfigurazionePdDManager.getInstance(stato.getStatoRichiesta(),stato.getStatoRisposta());
  975.             msgDiag.updateState(configPdDManager);
  976.             
  977.             // gestione credenziali
  978.             this.gestioneCredenziali(logCore, protocolFactory,msgDiag, imRequestContext.getConnettore(),pddContext);
  979.             
  980.             // Autenticazione Servizio Applicativo
  981.             idServizioApplicativo = autenticazione(logCore, protocolFactory,msgDiag,imRequestContext.getConnettore(),configPdDManager,pddContext);
  982.             imResponseContext.setServizioApplicativo(idServizioApplicativo);
  983.             String param = "ServizioApplicativo["+idServizioApplicativo.getNome()+"] ID["+idMessaggio+"]";
  984.             msgDiag.addKeyword(CostantiPdD.KEY_PARAMETRI_OPERAZIONE_IM, param);
  985.             msgDiag.logPersonalizzato("logInvocazioneOperazione");

  987.             // Gestore Messaggio
  988.             GestoreMessaggi gestoreMessaggi = new GestoreMessaggi(stato, true, idMessaggio, Costanti.INBOX, msgDiag, pddContext);
  989.             MessaggioIM messaggioIM = null;
  990.             if(useNewMethod) {
  991.                 messaggioIM = gestoreMessaggi.readMessageForSIL(idServizioApplicativo.getNome(),isRiferimentoMessaggio, dataMessaggio);
  992.             }
  993.             
  994.             // Check Esistenza Messaggio
  995.             boolean exists = false;
  996.             if(useNewMethod) {
  997.                 exists = messaggioIM!=null;
  998.             }
  999.             else { 
  1000.                 exists = gestoreMessaggi.existsMessageForSIL(idServizioApplicativo.getNome(),isRiferimentoMessaggio); 
  1001.             }
  1002.             if(!exists){
  1003.                 msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_TRANSACTION_MANAGER, idMessaggio);
  1004.                 msgDiag.logPersonalizzato("messaggioNonTrovato");
  1005.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_407_INTEGRATION_MANAGER_MSG_RICHIESTO_NON_TROVATO.
  1006.                         getErroreIntegrazione(),idServizioApplicativo,
  1007.                         IntegrationFunctionError.IM_MESSAGE_NOT_FOUND, this.getErroriProperties(logCore));
  1008.             }

  1010.             // Check Autorizzazione all'utilizzo di IntegrationManager
  1011.             boolean authorized = false;
  1012.             if(useNewMethod) {
  1013.                 authorized = messaggioIM.isAuthorized();
  1014.             }
  1015.             else { 
  1016.                 authorized = gestoreMessaggi.checkAutorizzazione(idServizioApplicativo.getNome(),isRiferimentoMessaggio);
  1017.             }
  1018.             if(!authorized){
  1019.                 msgDiag.logPersonalizzato("servizioApplicativo.nonAutorizzato");
  1020.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  1021.                         getErrore404_AutorizzazioneFallitaServizioApplicativo(idServizioApplicativo.getNome()),
  1022.                         idServizioApplicativo,
  1023.                         IntegrationFunctionError.AUTHORIZATION, this.getErroriProperties(logCore));
  1024.             }

  1026.             // GetIDMessaggio Richiesto
  1027.             String idMessaggioRichiesto = idMessaggio;
  1028.             try{
  1029.                 if(isRiferimentoMessaggio) {
  1030.                     if(useNewMethod) {
  1031.                         idMessaggioRichiesto = messaggioIM.getIdentificativoRichiesta();
  1032.                     }
  1033.                     else {
  1034.                         idMessaggioRichiesto = gestoreMessaggi.mapRiferimentoIntoIDBusta();
  1035.                     }
  1036.                 }
  1037.             }catch(Exception e){
  1038.                 msgDiag.addKeywordErroreProcessamento(e);
  1039.                 msgDiag.logPersonalizzato("mappingRifMsgToId.nonRiuscito");
  1040.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1041.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1042.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1043.             }

  1045.             // Proprieta' Protocollo del Messaggio da ritornare
  1046.             RepositoryBuste repository = new RepositoryBuste(stato.getStatoRichiesta(), true, protocolFactory);
  1047.             ProtocolHeaderInfo protocolHeaderInfo = null;
  1048.             IDSoggetto fruitore = null;
  1049.             IDServizio idServizio = null;
  1050.             Busta busta = null;
  1051.             try{
  1052.                 LetturaParametriBusta parametri = new LetturaParametriBusta();
  1053.                 parametri.setMittente(true);
  1054.                 parametri.setDestinatario(true);
  1055.                 parametri.setRiferimentoMessaggio(true);
  1056.                 parametri.setServizio(true);
  1057.                 parametri.setAzione(true);
  1058.                 parametri.setCollaborazione(true);
  1059.                 busta = repository.getSomeValuesFromInBox(idMessaggioRichiesto,parametri,dataMessaggio);
  1060.                 if(busta!=null){
  1061.                     protocolHeaderInfo = new ProtocolHeaderInfo();
  1062.                     protocolHeaderInfo.setID(idMessaggioRichiesto);
  1063.                     protocolHeaderInfo.setRiferimentoMessaggio(busta.getRiferimentoMessaggio());
  1064.                     protocolHeaderInfo.setTipoMittente(busta.getTipoMittente());
  1065.                     protocolHeaderInfo.setMittente(busta.getMittente());
  1066.                     protocolHeaderInfo.setTipoDestinatario(busta.getTipoDestinatario());
  1067.                     protocolHeaderInfo.setDestinatario(busta.getDestinatario());
  1068.                     protocolHeaderInfo.setTipoServizio(busta.getTipoServizio());
  1069.                     protocolHeaderInfo.setServizio(busta.getServizio());
  1070.                     protocolHeaderInfo.setAzione(busta.getAzione());
  1071.                     protocolHeaderInfo.setIdCollaborazione(busta.getCollaborazione());
  1072.                     busta.setID(idMessaggioRichiesto);
  1073.                     msgDiag.addKeywords(busta, true);
  1074.                     
  1075.                     fruitore = new IDSoggetto(busta.getTipoMittente(),busta.getMittente());
  1076.                     idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(),busta.getServizio(), 
  1077.                             busta.getTipoDestinatario(),busta.getDestinatario(), 
  1078.                             busta.getVersioneServizio());

  1080.                 }
  1081.             }catch(Exception e){
  1082.                 msgDiag.logErroreGenerico(e,"ReadInformazioniProtocollo("+tipoOperazione+","+idMessaggioRichiesto+")");
  1083.                 if(e.getMessage()==null || (e.getMessage().indexOf("Busta non trovata")<0) ){
  1084.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1085.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1086.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1087.                 }// else
  1088.                 //{
  1089.                 //busta non presente, il msg puo' cmq essere consumato
  1090.                 //}
  1091.             }


  1094.             // Indicazione se il messaggio deve essere sbustato
  1095.             boolean sbustamentoSoap = false;
  1096.             if(useNewMethod) {
  1097.                 sbustamentoSoap = messaggioIM.isSbustamentoSoap();
  1098.             }
  1099.             else {
  1100.                 sbustamentoSoap = gestoreMessaggi.sbustamentoSOAP(idServizioApplicativo.getNome(),isRiferimentoMessaggio);
  1101.             }
  1102.             boolean sbustamentoInformazioniProtocollo = false;
  1103.             if(useNewMethod) {
  1104.                 sbustamentoInformazioniProtocollo = messaggioIM.isSbustamentoInformazioniProtocollo();
  1105.             }
  1106.             else {
  1107.                 sbustamentoInformazioniProtocollo = gestoreMessaggi.sbustamentoInformazioniProtocollo(idServizioApplicativo.getNome(),isRiferimentoMessaggio);
  1108.             }

  1110.             // TipoMessaggio
  1111.             GestoreMessaggi gestoreMessaggiIdentificativoReale = null;
  1112.             RuoloMessaggio ruoloMessaggio = RuoloMessaggio.RICHIESTA;
  1113.             try{
  1114.                 gestoreMessaggiIdentificativoReale = new GestoreMessaggi(stato, true, idMessaggioRichiesto, Costanti.INBOX, msgDiag, pddContext);
  1115.                 if(useNewMethod) {
  1116.                     ruoloMessaggio = messaggioIM.getRiferimentoMessaggio()==null ? RuoloMessaggio.RICHIESTA : RuoloMessaggio.RISPOSTA;
  1117.                 }
  1118.                 else {
  1119.                     ruoloMessaggio = gestoreMessaggiIdentificativoReale.getRiferimentoMessaggio()==null ? RuoloMessaggio.RICHIESTA : RuoloMessaggio.RISPOSTA;
  1120.                 }
  1121.             }catch(Exception e){
  1122.                 logError(logCore, "Identificazione tipo messaggio non riuscita: "+e.getMessage(),e);
  1123.             }
  1124.             
  1125.             // Messaggio
  1126.             OpenSPCoop2Message consegnaMessage = null;
  1127.             try{
  1128.                 if(useNewMethod && gestoreMessaggiIdentificativoReale!=null) {
  1129.                     consegnaMessage = gestoreMessaggiIdentificativoReale.getMessage(dataMessaggio); // risoluzione riferimento messaggio gia' effettuata
  1130.                 }
  1131.                 else {
  1132.                     consegnaMessage = gestoreMessaggi.getMessage(isRiferimentoMessaggio);
  1133.                 }
  1134.             }catch(Exception e){
  1135.                 msgDiag.logErroreGenerico(e,"gestoreMessaggi.getMessage("+isRiferimentoMessaggio+","+tipoOperazione+")");
  1136.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1137.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1138.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1139.             }
  1140.             
  1141.             // Eventuale sbustamento
  1142.             if(sbustamentoInformazioniProtocollo){
  1143.                 try{
  1144.                     IBustaBuilder<?> bustaBuilder = protocolFactory.createBustaBuilder(stato.getStatoRichiesta());
  1145.                     
  1146.                     FaseSbustamento fase = null;
  1147.                     if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)){
  1148.                         fase = FaseSbustamento.PRE_CONSEGNA_RICHIESTA;
  1149.                     }else{
  1150.                         fase = FaseSbustamento.PRE_CONSEGNA_RISPOSTA;
  1151.                     }
  1152.                     
  1153.                     // attachments non gestiti!
  1154.                     ProprietaManifestAttachments proprietaManifest = this.propertiesReader.getProprietaManifestAttachments("standard");
  1155.                     proprietaManifest.setGestioneManifest(false);
  1156.                     ProtocolMessage  protocolMessage = bustaBuilder.sbustamento(consegnaMessage, pddContext,
  1157.                             busta, ruoloMessaggio, proprietaManifest, fase, null, null); 
  1158.                     if(protocolMessage!=null) {
  1159.                         consegnaMessage = protocolMessage.getMessage(); // updated
  1160.                     }
  1161.                 }catch(Exception e){
  1162.                     msgDiag.logErroreGenerico(e,"gestoreMessaggi.getMessage("+isRiferimentoMessaggio+","+tipoOperazione+")");
  1163.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1164.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1165.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));                
  1166.                 }
  1167.             }
  1168.             
  1169.             //  dump applicativo
  1170.             msgDiag.mediumDebug("Dump applicativo messaggio ritornato...");
  1171.             Dump dumpApplicativo = new Dump(this.propertiesReader.getIdentitaPortaDefault(protocolFactory.getProtocol(), null),
  1172.                     IntegrationManager.ID_MODULO,idMessaggio,
  1173.                     fruitore,idServizio,
  1174.                     TipoPdD.INTEGRATION_MANAGER,null,pddContext,
  1175.                     stato.getStatoRichiesta(),stato.getStatoRisposta(),
  1176.                     null);
  1177.             dumpApplicativo.dumpIntegrationManagerGetMessage(consegnaMessage);

  1179.             // Costruzione Message da ritornare
  1180.             IntegrationManagerMessage msgReturn = null;
  1181.             try{
  1182.                 if(!sbustamentoSoap){
  1183.                     msgReturn = new IntegrationManagerMessage(consegnaMessage,false,protocolHeaderInfo);
  1184.                 }else{
  1185.                     byte [] sbustato = TunnelSoapUtils.sbustamentoMessaggio(consegnaMessage);
  1186.                     msgReturn = new IntegrationManagerMessage(sbustato,false,protocolHeaderInfo);
  1187.                 }
  1188.             }catch(Exception e){
  1189.                 msgDiag.logErroreGenerico(e,"buildMsgReturn("+idMessaggio+","+tipoOperazione+")");
  1190.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1191.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_523_CREAZIONE_PROTOCOL_MESSAGE),idServizioApplicativo,
  1192.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1193.             }

  1195.             imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.OK));
  1196.             imResponseContext.setDimensioneMessaggioBytes(Long.valueOf(msgReturn.getMessage().length));
  1197.             
  1198.             // Informazione da salvare
  1199.             try {
  1200.                 TransazioneApplicativoServer transazioneApplicativoServer = null;
  1201.                 String nomePorta = null;
  1202.                 if(useNewMethod) {
  1203.                     transazioneApplicativoServer = new TransazioneApplicativoServer();
  1204.                     transazioneApplicativoServer.setIdTransazione(messaggioIM.getIdTransazione());
  1205.                     transazioneApplicativoServer.setServizioApplicativoErogatore(messaggioIM.getServizioApplicativo());
  1206.                     transazioneApplicativoServer.setDataRegistrazione(messaggioIM.getOraRegistrazione());
  1207.                     transazioneApplicativoServer.setDataPrelievoIm(DateManager.getDate());
  1208.                     transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  1209.                     nomePorta = messaggioIM.getNomePorta();
  1210.                 }
  1211.                 else {
  1212.                     MessaggioServizioApplicativo info = gestoreMessaggiIdentificativoReale.readInfoDestinatario(idServizioApplicativo.getNome(), true, logCore);
  1213.                     if(info!=null) {
  1214.                         transazioneApplicativoServer = new TransazioneApplicativoServer();
  1215.                         transazioneApplicativoServer.setIdTransazione(info.getIdTransazione());
  1216.                         transazioneApplicativoServer.setServizioApplicativoErogatore(info.getServizioApplicativo());
  1217.                         transazioneApplicativoServer.setDataRegistrazione(info.getOraRegistrazione());
  1218.                         transazioneApplicativoServer.setDataPrelievoIm(DateManager.getDate());
  1219.                         transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  1220.                         nomePorta = info.getNomePorta();
  1221.                     }
  1222.                 }
  1223.                 if(transazioneApplicativoServer!=null) {
  1224.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1225.                     idPA.setNome(nomePorta);
  1226.                     try {
  1227.                         GestoreConsegnaMultipla.getInstance().safeUpdatePrelievoIM(transazioneApplicativoServer, idPA, stato, pddContext);
  1228.                     }catch(Throwable t) {
  1229.                         logError(logCore, "["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  1230.                     }
  1231.                 }
  1232.             }catch(Exception e){
  1233.                 logError(logCore, "Salvataggio informazioni sulla transazione non riuscita: "+e.getMessage(),e);
  1234.             }
  1235.             
  1236.             return msgReturn;

  1238.         }catch(Exception e){
  1239.             
  1240.             try{
  1241.                 imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX));
  1242.                 
  1243.                 if(e instanceof IntegrationManagerException){
  1244.                     IntegrationManagerException exc = (IntegrationManagerException) e;
  1245.                     if(CodiceErroreIntegrazione.CODICE_402_AUTENTICAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione()) ||
  1246.                             CodiceErroreIntegrazione.CODICE_431_GESTORE_CREDENZIALI_ERROR.equals(exc.getCodiceErroreIntegrazione())){
  1247.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTENTICAZIONE_FALLITA));
  1248.                     }else if(CodiceErroreIntegrazione.CODICE_407_INTEGRATION_MANAGER_MSG_RICHIESTO_NON_TROVATO.equals(exc.getCodiceErroreIntegrazione())){
  1249.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.MESSAGGIO_NON_TROVATO));
  1250.                     }else if(CodiceErroreIntegrazione.CODICE_404_AUTORIZZAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione())){
  1251.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTORIZZAZIONE_FALLITA));
  1252.                     }
  1253.                 }
  1254.             }catch(Exception eInteral){
  1255.                 logError(logCore, "Errore durante la generazione dell'esito: "+eInteral.getMessage(),eInteral);
  1256.                 imResponseContext.setEsito(EsitoTransazione.ESITO_TRANSAZIONE_ERROR);
  1257.             }
  1258.             
  1259.             // Controllo Eccezioni
  1260.             if(e instanceof IntegrationManagerException){
  1261.                 // Lanciata all'interno del metodo
  1262.                 throw (IntegrationManagerException)e;
  1263.             }else{  
  1264.                 msgDiag.logErroreGenerico(e,"getMessage("+tipoOperazione+")");
  1265.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),idServizioApplicativo,
  1266.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1267.             }
  1268.         }finally{
  1269.             try{
  1270.                 if(stato!=null)
  1271.                     stato.releaseResource();
  1272.             }catch(Exception eClose){}
  1273.             
  1274.             
  1275.             
  1276.             /* ------------  IntegrationManagerResponseHandler ------------- */
  1277.             imResponseContext.setDataCompletamentoOperazione(DateManager.getDate());
  1278.             try{
  1279.                 GestoreHandlers.integrationManagerResponse(imResponseContext, msgDiag, logCore);
  1280.             }catch(Exception e){
  1281.                 if(e instanceof HandlerException){
  1282.                     HandlerException he = (HandlerException) e;
  1283.                     if(he.isEmettiDiagnostico()){
  1284.                         msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1285.                     }
  1286.                 }else{
  1287.                     msgDiag.logErroreGenerico(e, "IntegrationManagerResponseHandler");
  1288.                 }
  1289.             }
  1290.         }
  1291.     }

  1293.     /**
  1294.      * Recupera e restituisce un messaggio
  1295.      *
  1296.      * @param idMessaggio ID del Messaggio da recuperare
  1297.      * @return un Message contenente il messaggio recuperato (e informazioni supplementari)
  1298.      * 
  1299.      */
  1300.     @Override
  1301.     public IntegrationManagerMessage getMessage(String idMessaggio) throws IntegrationManagerException {
  1302.         init();
  1303.         return getMessage_engine(Operazione.getMessage,idMessaggio,false);
  1304.     }

  1306.     /**
  1307.      * Recupera e restituisce un messaggio cercandolo per riferimentoMessaggio
  1308.      *
  1309.      * @param riferimentoMsg del Messaggio da recuperare
  1310.      * @return un Message contenente il messaggio recuperato (e informazioni supplementari)
  1311.      * 
  1312.      */
  1313.     @Override
  1314.     public IntegrationManagerMessage getMessageByReference(String riferimentoMsg) throws IntegrationManagerException {
  1315.         init();
  1316.         return getMessage_engine(Operazione.getMessageByReference,riferimentoMsg,true);
  1317.     }





















  1339.     /* -------- delete ------ */
  1340.     /**
  1341.      * Cancella un messaggio
  1342.      *
  1343.      * @param idMessaggio ID del Messaggio da recuperare
  1344.      * @param isRiferimentoMessaggio Indicazione se l'id e' un riferimento messaggio
  1345.      * 
  1346.      */
  1347.     private void deleteMessage_engine(Operazione tipoOperazione,String idMessaggioParam,boolean isRiferimentoMessaggio) throws IntegrationManagerException {

  1349.         // Timestamp
  1350.         Date dataRichiestaOperazione = DateManager.getTimestamp();
  1351.         
  1352.         // Logger
  1353.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  1354.         if(logCore==null)
  1355.             logCore = LoggerWrapperFactory.getLogger(IntegrationManager.ID_MODULO);

  1357.         // check Autorizzazione
  1358.         checkIMAuthorization(logCore);
  1359.         
  1360.         // ProtocolFactoyr
  1361.         IProtocolFactory<?> protocolFactory = getProtocolFactory(logCore);
  1362.         
  1363.         // Verifica risorse sistema
  1364.         this.verificaRisorseSistema(protocolFactory,logCore, tipoOperazione.toString());

  1366.         MsgDiagnostico msgDiag = getMsgDiagnostico();
  1367.         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_OPERAZIONE_IM, tipoOperazione.toString());
  1368.         
  1369.         // Parse identificativo
  1370.         String idMessaggio = null;
  1371.         Date dataMessaggio = null;
  1372.         if(this.propertiesReader.isIntegrationManagerIdWithDate()) {
  1373.             IdentificativoIM idIM = IdentificativoIM.getIdentificativoIM(idMessaggioParam, logCore);
  1374.             idMessaggio = idIM.getId();
  1375.             dataMessaggio = idIM.getData();
  1376.         }
  1377.         else {
  1378.             idMessaggio = idMessaggioParam;
  1379.         }
  1380.         
  1381.         // Context
  1382.         if(isRiferimentoMessaggio){
  1383.             msgDiag.addKeyword(CostantiPdD.KEY_RIFERIMENTO_MESSAGGIO_RICHIESTA, idMessaggio);
  1384.             msgDiag.addKeyword(CostantiPdD.KEY_RIFERIMENTO_MESSAGGIO_RISPOSTA, idMessaggio);
  1385.         }else{
  1386.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessaggio);
  1387.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, idMessaggio);
  1388.         }
  1389.         
  1390.         GestoreMessaggi gestoreMessaggi = null;
  1391.         IDServizioApplicativo idServizioApplicativo = null;
  1392.         String servizioApplicativo = null;
  1393.         OpenSPCoopStateful stato = null;
  1394.         // PddContext
  1395.         PdDContext pddContext = new PdDContext();
  1396.         String idTransazione = this.getUniqueIdentifier(logCore, protocolFactory,msgDiag,tipoOperazione.toString()).getAsString();
  1397.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  1398.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_MESSAGGIO,idMessaggio);
  1399.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  1400.         msgDiag.setPddContext(pddContext, protocolFactory);
  1401.         
  1402.         
  1403.         
  1404.         /* ------------  IntegrationManagerRequesCHandler ------------- */
  1405.         IntegrationManagerRequestContext imRequestContext = null;
  1406.         try{
  1407.             imRequestContext = buildIMRequestContext(dataRichiestaOperazione, tipoOperazione, pddContext,logCore,protocolFactory);
  1408.             imRequestContext.setIdMessaggio(idMessaggio);
  1409.             GestoreHandlers.integrationManagerRequest(imRequestContext, msgDiag, logCore);
  1410.         }catch(Exception e){
  1411.             ErroreIntegrazione erroreIntegrazione = null;
  1412.             IntegrationFunctionError integrationFunctionError = null;
  1413.             if(e instanceof HandlerException){
  1414.                 HandlerException he = (HandlerException) e;
  1415.                 integrationFunctionError = he.getIntegrationFunctionError();
  1416.                 if(he.isEmettiDiagnostico()){
  1417.                     msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1418.                 }
  1419.                 erroreIntegrazione = he.convertToErroreIntegrazione();
  1420.             }else{
  1421.                 msgDiag.logErroreGenerico(e, "IntegrationManagerRequestHandler");
  1422.             }
  1423.             if(erroreIntegrazione==null){
  1424.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  1425.             }
  1426.             if(integrationFunctionError==null) {
  1427.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1428.             }
  1429.             throw new IntegrationManagerException(protocolFactory,erroreIntegrazione,
  1430.                     integrationFunctionError, this.getErroriProperties(logCore));
  1431.         }
  1432.         
  1433.         
  1434.         /* ------------  Gestione Operazione ------------- */
  1435.         IntegrationManagerResponseContext imResponseContext = 
  1436.             new IntegrationManagerResponseContext(dataRichiestaOperazione,tipoOperazione,pddContext,logCore,protocolFactory);
  1437.         if(imRequestContext!=null){
  1438.             imResponseContext.setConnettore(imRequestContext.getConnettore());
  1439.         }
  1440.         imResponseContext.setIdMessaggio(idMessaggio);
  1441.         try{    

  1443.             // init stato
  1444.             stato = new OpenSPCoopStateful();
  1445.             stato.initResource(this.propertiesReader.getIdentitaPortaDefault(protocolFactory.getProtocol(), null),IntegrationManager.ID_MODULO, idTransazione, 
  1446.                     OpenSPCoopStateDBManager.messageBox);
  1447.             ConfigurazionePdDManager configPdDManager = ConfigurazionePdDManager.getInstance(stato.getStatoRichiesta(),stato.getStatoRisposta());
  1448.             msgDiag.updateState(configPdDManager);  
  1449.             
  1450.             // gestione credenziali
  1451.             this.gestioneCredenziali(logCore, protocolFactory,msgDiag, imRequestContext.getConnettore(),pddContext);
  1452.             
  1453.             // Autenticazione Servizio Applicativo
  1454.             idServizioApplicativo = autenticazione(logCore, protocolFactory,msgDiag,imRequestContext.getConnettore(),configPdDManager,pddContext);
  1455.             servizioApplicativo = idServizioApplicativo.getNome();
  1456.             imResponseContext.setServizioApplicativo(idServizioApplicativo);
  1457.             String param = "ServizioApplicativo["+servizioApplicativo+"] ID["+idMessaggio+"]";
  1458.             msgDiag.addKeyword(CostantiPdD.KEY_PARAMETRI_OPERAZIONE_IM, param);
  1459.             msgDiag.logPersonalizzato("logInvocazioneOperazione");

  1461.             // Gestore Messaggio
  1462.             gestoreMessaggi = new GestoreMessaggi(stato, true, idMessaggio, Costanti.INBOX, msgDiag, pddContext);
  1463.             MessaggioIM messaggioIM = null;
  1464.             if(useNewMethod) {
  1465.                 messaggioIM = gestoreMessaggi.readMessageForSIL(idServizioApplicativo.getNome(),isRiferimentoMessaggio, dataMessaggio);
  1466.             }
  1467.             
  1468.             // Check Esistenza Messaggio
  1469.             boolean exists = false;
  1470.             if(useNewMethod) {
  1471.                 exists = messaggioIM!=null;
  1472.             }
  1473.             else { 
  1474.                 exists = gestoreMessaggi.existsMessageForSIL(servizioApplicativo,isRiferimentoMessaggio); 
  1475.             }
  1476.             if(!exists){
  1477.                 msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_TRANSACTION_MANAGER, idMessaggio);
  1478.                 msgDiag.logPersonalizzato("messaggioNonTrovato");
  1479.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_407_INTEGRATION_MANAGER_MSG_RICHIESTO_NON_TROVATO.
  1480.                         getErroreIntegrazione(),idServizioApplicativo,
  1481.                         IntegrationFunctionError.IM_MESSAGE_NOT_FOUND, this.getErroriProperties(logCore));
  1482.             }

  1484.             // Check Autorizzazione all'utilizzo di IntegrationManager
  1485.             boolean authorized = false;
  1486.             if(useNewMethod) {
  1487.                 authorized = messaggioIM.isAuthorized();
  1488.             }
  1489.             else { 
  1490.                 authorized = gestoreMessaggi.checkAutorizzazione(servizioApplicativo,isRiferimentoMessaggio);
  1491.             }
  1492.             if(!authorized){
  1493.                 msgDiag.logPersonalizzato("servizioApplicativo.nonAutorizzato");
  1494.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA.
  1495.                         getErrore404_AutorizzazioneFallitaServizioApplicativo(servizioApplicativo),
  1496.                         idServizioApplicativo,
  1497.                         IntegrationFunctionError.AUTHORIZATION, this.getErroriProperties(logCore));
  1498.             }

  1500.             //  GetIDMessaggio Richiesto
  1501.             String idMessaggioRichiesto = idMessaggio;
  1502.             try{
  1503.                 if(isRiferimentoMessaggio) {
  1504.                     if(useNewMethod) {
  1505.                         idMessaggioRichiesto = messaggioIM.getIdentificativoRichiesta();
  1506.                     }
  1507.                     else {
  1508.                         idMessaggioRichiesto = gestoreMessaggi.mapRiferimentoIntoIDBusta();
  1509.                     }
  1510.                 }
  1511.             }catch(Exception e){
  1512.                 msgDiag.addKeywordErroreProcessamento(e);
  1513.                 msgDiag.logPersonalizzato("mappingRifMsgToId.nonRiuscito");
  1514.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1515.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1516.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1517.             }

  1519.             //  Gestore Messaggio da eliminare
  1520.             GestoreMessaggi gestoreEliminazione = null;
  1521.             try{
  1522.                 gestoreEliminazione = new GestoreMessaggi(stato, true, idMessaggioRichiesto,Costanti.INBOX,msgDiag,pddContext);
  1523.             }catch(Exception e){
  1524.                 msgDiag.logErroreGenerico(e,"gestoreMessaggi.eliminaDestinatarioMessaggio("+tipoOperazione+","+servizioApplicativo+","+idMessaggio+")");
  1525.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1526.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_522_DELETE_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1527.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1528.             }
  1529.             
  1530.             // Aggiorno la transazione prima di eliminare il messaggio
  1531.             try {
  1532.                 TransazioneApplicativoServer transazioneApplicativoServer = null;
  1533.                 String nomePorta = null;
  1534.                 if(useNewMethod) {
  1535.                     transazioneApplicativoServer = new TransazioneApplicativoServer();
  1536.                     transazioneApplicativoServer.setIdTransazione(messaggioIM.getIdTransazione());
  1537.                     transazioneApplicativoServer.setServizioApplicativoErogatore(messaggioIM.getServizioApplicativo());
  1538.                     transazioneApplicativoServer.setDataRegistrazione(messaggioIM.getOraRegistrazione());
  1539.                     transazioneApplicativoServer.setDataEliminazioneIm(DateManager.getDate());
  1540.                     transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  1541.                     nomePorta = messaggioIM.getNomePorta();
  1542.                 }
  1543.                 else {
  1544.                     MessaggioServizioApplicativo info = gestoreEliminazione.readInfoDestinatario(idServizioApplicativo.getNome(), true, logCore);
  1545.                     if(info!=null) {
  1546.                         transazioneApplicativoServer = new TransazioneApplicativoServer();
  1547.                         transazioneApplicativoServer.setIdTransazione(info.getIdTransazione());
  1548.                         transazioneApplicativoServer.setServizioApplicativoErogatore(info.getServizioApplicativo());
  1549.                         transazioneApplicativoServer.setDataRegistrazione(info.getOraRegistrazione());
  1550.                         transazioneApplicativoServer.setDataEliminazioneIm(DateManager.getDate());
  1551.                         transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  1552.                         nomePorta = info.getNomePorta();
  1553.                     }
  1554.                 }
  1555.                 if(transazioneApplicativoServer!=null) {
  1556.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1557.                     idPA.setNome(nomePorta);
  1558.                     try {
  1559.                         GestoreConsegnaMultipla.getInstance().safeUpdateEliminazioneIM(transazioneApplicativoServer, idPA, stato, pddContext);
  1560.                     }catch(Throwable t) {
  1561.                         logError(logCore, "["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  1562.                     }
  1563.                 }
  1564.             }catch(Exception e){
  1565.                 logError(logCore, "Salvataggio informazioni sulla transazione non riuscita: "+e.getMessage(),e);
  1566.             }
  1567.             
  1568.             // Elimino Messaggio
  1569.             try{
  1570.                 gestoreEliminazione.eliminaDestinatarioMessaggio(servizioApplicativo, gestoreEliminazione.getRiferimentoMessaggio(), dataMessaggio);
  1571.             }catch(Exception e){
  1572.                 msgDiag.logErroreGenerico(e,"gestoreMessaggi.eliminaDestinatarioMessaggio("+tipoOperazione+","+servizioApplicativo+","+idMessaggio+")");
  1573.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1574.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_522_DELETE_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1575.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1576.             }

  1578.             imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.OK));
  1579.             
  1580.         }catch(Exception e){
  1581.             
  1582.             try{
  1583.                 imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX));
  1584.                 
  1585.                 if(e instanceof IntegrationManagerException){
  1586.                     IntegrationManagerException exc = (IntegrationManagerException) e;
  1587.                     if(CodiceErroreIntegrazione.CODICE_402_AUTENTICAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione()) ||
  1588.                             CodiceErroreIntegrazione.CODICE_431_GESTORE_CREDENZIALI_ERROR.equals(exc.getCodiceErroreIntegrazione())){
  1589.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTENTICAZIONE_FALLITA));
  1590.                     }else if(CodiceErroreIntegrazione.CODICE_407_INTEGRATION_MANAGER_MSG_RICHIESTO_NON_TROVATO.equals(exc.getCodiceErroreIntegrazione())){
  1591.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.MESSAGGIO_NON_TROVATO));
  1592.                     }else if(CodiceErroreIntegrazione.CODICE_404_AUTORIZZAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione())){
  1593.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTORIZZAZIONE_FALLITA));
  1594.                     }
  1595.                 }
  1596.             }catch(Exception eInteral){
  1597.                 logError(logCore, "Errore durante la generazione dell'esito: "+eInteral.getMessage(),eInteral);
  1598.                 imResponseContext.setEsito(EsitoTransazione.ESITO_TRANSAZIONE_ERROR);
  1599.             }
  1600.             
  1601.             // Controllo Eccezioni
  1602.             if(e instanceof IntegrationManagerException){
  1603.                 // Lanciata all'interno del metodo
  1604.                 throw (IntegrationManagerException)e;
  1605.             }else{
  1606.                 msgDiag.logErroreGenerico(e,"deleteMessage("+tipoOperazione+")");
  1607.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),idServizioApplicativo,
  1608.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1609.             }
  1610.         }finally{
  1611.             try{
  1612.                 if(stato!=null)
  1613.                     stato.releaseResource();
  1614.             }catch(Exception eClose){}
  1615.             
  1616.             
  1617.             /* ------------  IntegrationManagerResponseHandler ------------- */
  1618.             imResponseContext.setDataCompletamentoOperazione(DateManager.getDate());
  1619.             try{
  1620.                 GestoreHandlers.integrationManagerResponse(imResponseContext, msgDiag, logCore);
  1621.             }catch(Exception e){
  1622.                 if(e instanceof HandlerException){
  1623.                     HandlerException he = (HandlerException) e;
  1624.                     if(he.isEmettiDiagnostico()){
  1625.                         msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1626.                     }
  1627.                 }else{
  1628.                     msgDiag.logErroreGenerico(e, "IntegrationManagerResponseHandler");
  1629.                 }
  1630.             }
  1631.         }
  1632.     }

  1634.     /**
  1635.      * Cancella un messaggio
  1636.      *
  1637.      * @param idMessaggio ID del Messaggio da recuperare
  1638.      * 
  1639.      */
  1640.     @Override
  1641.     public void deleteMessage(String idMessaggio) throws IntegrationManagerException {
  1642.         init();
  1643.         deleteMessage_engine(Operazione.deleteMessage,idMessaggio,false);
  1644.     }

  1646.     /**
  1647.      * Cancella un messaggio cercandolo per riferimentoMessaggio
  1648.      *
  1649.      * @param riferimentoMsg del Messaggio da recuperare
  1650.      * 
  1651.      */
  1652.     @Override
  1653.     public void deleteMessageByReference(String riferimentoMsg) throws IntegrationManagerException {
  1654.         init();
  1655.         deleteMessage_engine(Operazione.deleteMessageByReference,riferimentoMsg,true);
  1656.     }






















  1679.     /* --------- delete All Messages ----------- */

  1681.     /**
  1682.      * Cancella tutti i messaggi di un servizio applicativo
  1683.      *
  1684.      * 
  1685.      */
  1686.     @Override
  1687.     public void deleteAllMessages() throws IntegrationManagerException {

  1689.         init();
  1690.         
  1691.         Operazione tipoOperazione = Operazione.deleteAllMessages;

  1693.         // Timestamp
  1694.         Date dataRichiestaOperazione = DateManager.getTimestamp();
  1695.         
  1696.         // Logger
  1697.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  1698.         if(logCore==null)
  1699.             logCore = LoggerWrapperFactory.getLogger(IntegrationManager.ID_MODULO);

  1701.         // check Autorizzazione
  1702.         checkIMAuthorization(logCore);
  1703.         
  1704.         // ProtocolFactoyr
  1705.         IProtocolFactory<?> protocolFactory = getProtocolFactory(logCore);
  1706.         
  1707.         // Verifica risorse sistema
  1708.         this.verificaRisorseSistema(protocolFactory,logCore, tipoOperazione.toString());

  1710.         MsgDiagnostico msgDiag = getMsgDiagnostico();
  1711.         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_OPERAZIONE_IM, tipoOperazione.toString());
  1712.         
  1713.         IDServizioApplicativo idServizioApplicativo = null;
  1714.         OpenSPCoopStateful stato = null;
  1715.         // PddContext
  1716.         PdDContext pddContext = new PdDContext();
  1717.         String idTransazione = this.getUniqueIdentifier(logCore, protocolFactory,msgDiag,tipoOperazione.toString()).getAsString();
  1718.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  1719.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  1720.         msgDiag.setPddContext(pddContext, protocolFactory);
  1721.         
  1722.         
  1723.         
  1724.         
  1725.         /* ------------  IntegrationManagerRequesCHandler ------------- */
  1726.         IntegrationManagerRequestContext imRequestContext = null;
  1727.         try{
  1728.             imRequestContext = buildIMRequestContext(dataRichiestaOperazione, tipoOperazione, pddContext,logCore,protocolFactory);
  1729.             GestoreHandlers.integrationManagerRequest(imRequestContext, msgDiag, logCore);
  1730.         }catch(Exception e){
  1731.             ErroreIntegrazione erroreIntegrazione = null;
  1732.             IntegrationFunctionError integrationFunctionError = null;
  1733.             if(e instanceof HandlerException){
  1734.                 HandlerException he = (HandlerException) e;
  1735.                 integrationFunctionError = he.getIntegrationFunctionError();
  1736.                 if(he.isEmettiDiagnostico()){
  1737.                     msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1738.                 }
  1739.                 erroreIntegrazione = he.convertToErroreIntegrazione();
  1740.             }else{
  1741.                 msgDiag.logErroreGenerico(e, "IntegrationManagerRequestHandler");
  1742.             }
  1743.             if(erroreIntegrazione==null){
  1744.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  1745.             }
  1746.             if(integrationFunctionError==null) {
  1747.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1748.             }
  1749.             throw new IntegrationManagerException(protocolFactory,erroreIntegrazione,
  1750.                     integrationFunctionError, getErroriProperties(logCore));
  1751.         }
  1752.         
  1753.         
  1754.         /* ------------  Gestione Operazione ------------- */
  1755.         IntegrationManagerResponseContext imResponseContext = 
  1756.             new IntegrationManagerResponseContext(dataRichiestaOperazione,tipoOperazione,pddContext,logCore,protocolFactory);
  1757.         if(imRequestContext!=null){
  1758.             imResponseContext.setConnettore(imRequestContext.getConnettore());
  1759.         }
  1760.         try{

  1762.             // init stato
  1763.             stato = new OpenSPCoopStateful();
  1764.             stato.initResource(this.propertiesReader.getIdentitaPortaDefault(protocolFactory.getProtocol(), null),IntegrationManager.ID_MODULO, idTransazione, 
  1765.                     OpenSPCoopStateDBManager.messageBox);
  1766.             ConfigurazionePdDManager configPdDManager = ConfigurazionePdDManager.getInstance(stato.getStatoRichiesta(),stato.getStatoRisposta());
  1767.             msgDiag.updateState(configPdDManager);  
  1768.             
  1769.             // gestione credenziali
  1770.             this.gestioneCredenziali(logCore, protocolFactory,msgDiag, imRequestContext.getConnettore(),pddContext);
  1771.             
  1772.             // Autenticazione Servizio Applicativo
  1773.             idServizioApplicativo = autenticazione(logCore, protocolFactory,msgDiag,imRequestContext.getConnettore(),configPdDManager,pddContext);
  1774.             imResponseContext.setServizioApplicativo(idServizioApplicativo);
  1775.             String param = "ServizioApplicativo["+idServizioApplicativo.getNome()+"]";
  1776.             msgDiag.addKeyword(CostantiPdD.KEY_PARAMETRI_OPERAZIONE_IM, param);
  1777.             msgDiag.logPersonalizzato("logInvocazioneOperazione");

  1779.             // Effettuo ricerca ID DEL SERVIZIO APPLICATIVO
  1780.             GestoreMessaggi gestoreSearchID = new GestoreMessaggi(stato, true,msgDiag,pddContext);

  1782.             List<IdentificativoIM> ids =  gestoreSearchID.getIDMessaggi_ServizioApplicativo(idServizioApplicativo.getNome());      
  1783.             if(ids.isEmpty()){
  1784.                 msgDiag.logPersonalizzato("messaggiNonPresenti");
  1785.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_406_INTEGRATION_MANAGER_MESSAGGI_FOR_SIL_NON_TROVATI.
  1786.                         getErroreIntegrazione(),idServizioApplicativo,
  1787.                         IntegrationFunctionError.IM_MESSAGES_NOT_FOUND, this.getErroriProperties(logCore));
  1788.             }

  1790.             // Creo i vari gestori di messaggi
  1791.             List<MessaggioIM> messaggiIM = new ArrayList<MessaggioIM>();
  1792.             for(int i=0; i<ids.size(); i++){
  1793.                 IdentificativoIM idIM = ids.get(i);
  1794.                 String idMessaggio = idIM.getId();
  1795.                 Date dataMessaggio = idIM.getData();
  1796.                 
  1797.                 GestoreMessaggi gestoreMessaggi = new GestoreMessaggi(stato, true,idMessaggio,Costanti.INBOX,msgDiag,pddContext);
  1798.                 MessaggioIM messaggioIM = null;
  1799.                 if(useNewMethod) {
  1800.                     messaggioIM = gestoreMessaggi.readMessageForSIL(idServizioApplicativo.getNome(), dataMessaggio);
  1801.                     if(messaggioIM!=null) {
  1802.                         messaggiIM.add(messaggioIM);
  1803.                     }
  1804.                 }
  1805.                 
  1806.                 // Check Esistenza Messaggio
  1807.                 boolean exists = false;
  1808.                 if(useNewMethod) {
  1809.                     exists = messaggioIM!=null;
  1810.                 }
  1811.                 else { 
  1812.                     exists = gestoreMessaggi.existsMessageForSIL(idServizioApplicativo.getNome()); 
  1813.                 }
  1814.                 if(!exists){
  1815.                     msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_TRANSACTION_MANAGER, idMessaggio);
  1816.                     msgDiag.logPersonalizzato("messaggioNonTrovato");
  1817.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1818.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1819.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1820.                 }

  1822.                 // Check Autorizzazione all'utilizzo di IntegrationManager
  1823.                 boolean authorized = false;
  1824.                 if(useNewMethod) {
  1825.                     authorized = messaggioIM.isAuthorized();
  1826.                 }
  1827.                 else { 
  1828.                     authorized = gestoreMessaggi.checkAutorizzazione(idServizioApplicativo.getNome());
  1829.                 }
  1830.                 if(!authorized){
  1831.                     msgDiag.logPersonalizzato("servizioApplicativo.nonAutorizzato");
  1832.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA
  1833.                             .getErrore404_AutorizzazioneFallitaServizioApplicativo(idServizioApplicativo.getNome()),
  1834.                             idServizioApplicativo,
  1835.                             IntegrationFunctionError.AUTHORIZATION, this.getErroriProperties(logCore));
  1836.                 }
  1837.             }

  1839.             // Elimino i messaggi
  1840.             while(!ids.isEmpty()){
  1841.                 // Elimino Messaggio
  1842.                 IdentificativoIM idIM = ids.remove(0);
  1843.                 String idMessaggio = idIM.getId();
  1844.                 Date dataMessaggio = idIM.getData();
  1845.                 MessaggioIM messaggioIM = null;
  1846.                 if(useNewMethod) {
  1847.                     messaggioIM = messaggiIM.remove(0);
  1848.                 }
  1849.                 
  1850.                 // Gestore Messaggio da eliminare
  1851.                 GestoreMessaggi gestoreEliminazione = null;
  1852.                 try{
  1853.                     //  Elimino accesso daPdD
  1854.                     gestoreEliminazione = new GestoreMessaggi(stato, true,idMessaggio,Costanti.INBOX,msgDiag,pddContext);
  1855.                 }catch(Exception e){
  1856.                     msgDiag.logErroreGenerico(e,"gestoreMessaggi.eliminaDestinatarioMessaggio("+tipoOperazione+","+idServizioApplicativo.getNome()+","+idMessaggio+")");
  1857.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1858.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_522_DELETE_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1859.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1860.                 }
  1861.                 
  1862.                 // Aggiorno la transazione prima di eliminare il messaggio
  1863.                 try {
  1864.                     TransazioneApplicativoServer transazioneApplicativoServer = null;
  1865.                     String nomePorta = null;
  1866.                     if(useNewMethod) {
  1867.                         transazioneApplicativoServer = new TransazioneApplicativoServer();
  1868.                         transazioneApplicativoServer.setIdTransazione(messaggioIM.getIdTransazione());
  1869.                         transazioneApplicativoServer.setServizioApplicativoErogatore(messaggioIM.getServizioApplicativo());
  1870.                         transazioneApplicativoServer.setDataRegistrazione(messaggioIM.getOraRegistrazione());
  1871.                         transazioneApplicativoServer.setDataEliminazioneIm(DateManager.getDate());
  1872.                         transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  1873.                         nomePorta = messaggioIM.getNomePorta();
  1874.                     }
  1875.                     else {              
  1876.                         MessaggioServizioApplicativo info = gestoreEliminazione.readInfoDestinatario(idServizioApplicativo.getNome(), true, logCore);
  1877.                         if(info!=null) {
  1878.                             transazioneApplicativoServer = new TransazioneApplicativoServer();
  1879.                             transazioneApplicativoServer.setIdTransazione(info.getIdTransazione());
  1880.                             transazioneApplicativoServer.setServizioApplicativoErogatore(info.getServizioApplicativo());
  1881.                             transazioneApplicativoServer.setDataRegistrazione(info.getOraRegistrazione());
  1882.                             transazioneApplicativoServer.setDataEliminazioneIm(DateManager.getDate());
  1883.                             transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  1884.                             nomePorta = info.getNomePorta();
  1885.                         }
  1886.                     }
  1887.                     if(transazioneApplicativoServer!=null) {
  1888.                         IDPortaApplicativa idPA = new IDPortaApplicativa();
  1889.                         idPA.setNome(nomePorta);
  1890.                         try {
  1891.                             GestoreConsegnaMultipla.getInstance().safeUpdateEliminazioneIM(transazioneApplicativoServer, idPA, stato, pddContext);
  1892.                         }catch(Throwable t) {
  1893.                             logError(logCore, "["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  1894.                         }
  1895.                     }
  1896.                 }catch(Exception e){
  1897.                     logError(logCore, "Salvataggio informazioni sulla transazione non riuscita: "+e.getMessage(),e);
  1898.                 }
  1899.                 
  1900.                 // Elimino Messaggio
  1901.                 try{
  1902.                     gestoreEliminazione.eliminaDestinatarioMessaggio(idServizioApplicativo.getNome(), gestoreEliminazione.getRiferimentoMessaggio(), dataMessaggio);
  1903.                 }catch(Exception e){
  1904.                     msgDiag.logErroreGenerico(e,"gestoreMessaggi.eliminaDestinatarioMessaggio("+tipoOperazione+","+idServizioApplicativo.getNome()+","+idMessaggio+")");
  1905.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1906.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_522_DELETE_MSG_FROM_INTEGRATION_MANAGER),idServizioApplicativo,
  1907.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1908.                 }
  1909.             }
  1910.             
  1911.             imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.OK));


  1914.         }catch(Exception e){
  1915.             
  1916.             try{
  1917.                 imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX));
  1918.                 
  1919.                 if(e instanceof IntegrationManagerException){
  1920.                     IntegrationManagerException exc = (IntegrationManagerException) e;
  1921.                     if(CodiceErroreIntegrazione.CODICE_402_AUTENTICAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione()) ||
  1922.                             CodiceErroreIntegrazione.CODICE_431_GESTORE_CREDENZIALI_ERROR.equals(exc.getCodiceErroreIntegrazione())){
  1923.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTENTICAZIONE_FALLITA));
  1924.                     }else if(CodiceErroreIntegrazione.CODICE_406_INTEGRATION_MANAGER_MESSAGGI_FOR_SIL_NON_TROVATI.equals(exc.getCodiceErroreIntegrazione())){
  1925.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.MESSAGGI_NON_PRESENTI));
  1926.                     }else if(CodiceErroreIntegrazione.CODICE_404_AUTORIZZAZIONE_FALLITA.equals(exc.getCodiceErroreIntegrazione())){
  1927.                         imResponseContext.setEsito(this.getEsitoTransazione(protocolFactory, imRequestContext, EsitoTransazioneName.AUTORIZZAZIONE_FALLITA));
  1928.                     }
  1929.                 }
  1930.             }catch(Exception eInteral){
  1931.                 logError(logCore, "Errore durante la generazione dell'esito: "+eInteral.getMessage(),eInteral);
  1932.                 imResponseContext.setEsito(EsitoTransazione.ESITO_TRANSAZIONE_ERROR);
  1933.             }
  1934.             
  1935.             // Controllo Eccezioni
  1936.             if(e instanceof IntegrationManagerException){
  1937.                 // Lanciata all'interno del metodo
  1938.                 throw (IntegrationManagerException)e;
  1939.             }else{
  1940.                 msgDiag.logErroreGenerico(e,"deleteAllMessages("+tipoOperazione+")");
  1941.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),idServizioApplicativo,
  1942.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, this.getErroriProperties(logCore));
  1943.             }
  1944.         }finally{
  1945.             try{
  1946.                 if(stato!=null)
  1947.                     stato.releaseResource();
  1948.             }catch(Exception eClose){}
  1949.             
  1950.             
  1951.             
  1952.             /* ------------  IntegrationManagerResponseHandler ------------- */
  1953.             imResponseContext.setDataCompletamentoOperazione(DateManager.getDate());
  1954.             try{
  1955.                 GestoreHandlers.integrationManagerResponse(imResponseContext, msgDiag, logCore);
  1956.             }catch(Exception e){
  1957.                 if(e instanceof HandlerException){
  1958.                     HandlerException he = (HandlerException) e;
  1959.                     if(he.isEmettiDiagnostico()){
  1960.                         msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1961.                     }
  1962.                 }else{
  1963.                     msgDiag.logErroreGenerico(e, "IntegrationManagerResponseHandler");
  1964.                 }
  1965.             }
  1966.         }

  1968.     }























  1992.     /* ------- Invocazione Porta Delegata ---------------*/

  1994.     /**
  1995.      * Invoca una porta delegata
  1996.      *
  1997.      * @param portaDelegata Porta Delegata da invocare
  1998.      * @param msg Message da utilizza come messaggio da invocare (contiene anche il servizio che si desidera invocare)
  1999.      * @return un Message contenente il messaggio di risposta 
  2000.      * 
  2001.      */
  2002.     @Override
  2003.     public IntegrationManagerMessage invocaPortaDelegata(String portaDelegata,IntegrationManagerMessage msg) throws IntegrationManagerException {
  2004.         init();
  2005.         String tipoOperazione = "invocaPortaDelegata";
  2006.         return invocaPortaDelegata_engine(tipoOperazione,portaDelegata,msg,null);

  2008.     }


  2011.     /**
  2012.      * Invoca una porta delegata per riferimento
  2013.      *
  2014.      * @param portaDelegata Porta Delegata da invocare
  2015.      * @param msg Message da utilizza come messaggio da invocare (contiene anche il servizio che si desidera invocare)
  2016.      * @param riferimentoMessaggio ID che identifica un Messaggio da utilizzare
  2017.      * 
  2018.      * @return un Message contenente il messaggio di risposta 
  2019.      * 
  2020.      */
  2021.     @Override
  2022.     public IntegrationManagerMessage invocaPortaDelegataPerRiferimento(String portaDelegata,
  2023.             IntegrationManagerMessage msg,String riferimentoMessaggio) throws IntegrationManagerException {
  2024.         init();
  2025.         String tipoOperazione = "invocaPortaDelegataPerRiferimento";
  2026.         return invocaPortaDelegata_engine(tipoOperazione,portaDelegata,msg,riferimentoMessaggio);

  2028.     }


  2031.     /**
  2032.      * Invia una risposta asicrona a OpenSPCoop
  2033.      * @param portaDelegata Porta Delegata da invocare
  2034.      * @param msg Message da utilizza come messaggio da invocare (contiene anche il servizio che si desidera invocare)
  2035.      * @return un Message contenente il messaggio di risposta 
  2036.      * 
  2037.      */
  2038.     @Override
  2039.     public IntegrationManagerMessage sendRispostaAsincronaSimmetrica(String portaDelegata,IntegrationManagerMessage msg) throws IntegrationManagerException {
  2040.         init();
  2041.         String tipoOperazione = "sendRispostaAsincronaSimmetrica";      
  2042.         return invocaPortaDelegata_engine(tipoOperazione,portaDelegata,msg,null);

  2044.     }

  2046.     /**
  2047.      * Invia una risposta asicrona a OpenSPCoop
  2048.      * @param portaDelegata Porta Delegata da invocare
  2049.      * @param msg Message da utilizza come messaggio da invocare (contiene anche il servizio che si desidera invocare)
  2050.      * @return un Message contenente il messaggio di risposta 
  2051.      * 
  2052.      */
  2053.     @Override
  2054.     public IntegrationManagerMessage sendRichiestaStatoAsincronaAsimmetrica(String portaDelegata,IntegrationManagerMessage msg) throws IntegrationManagerException {
  2055.         init();
  2056.         String tipoOperazione = "sendRichiestaStatoAsincronaAsimmetrica";
  2057.         return invocaPortaDelegata_engine(tipoOperazione,portaDelegata,msg,null);

  2059.     }


  2062.     private IntegrationManagerMessage invocaPortaDelegata_engine(String tipoOperazione, String portaDelegata, IntegrationManagerMessage msg,
  2063.             String idInvocazionePerRiferimento) throws IntegrationManagerException {

  2065.         // Timestamp
  2066.         Date dataAccettazioneRichiesta = DateManager.getDate();
  2067.         Date dataIngressoRichiesta = dataAccettazioneRichiesta;
  2068.         
  2069.         // Logger
  2070.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  2071.         if(logCore==null)
  2072.             logCore = LoggerWrapperFactory.getLogger(IntegrationManager.ID_MODULO);
  2073.         
  2074.         // check Autorizzazione
  2075.         checkIMAuthorization(logCore);
  2076.         
  2077.         // ProtocolFactory
  2078.         IProtocolFactory<?> protocolFactory = getProtocolFactory(logCore);
  2079.         
  2080.         // Verifica risorse sistema
  2081.         this.verificaRisorseSistema(protocolFactory,logCore, tipoOperazione);
  2082.         
  2083.         // SetNomePD
  2084.         this.setNomePortaDelegata(logCore, portaDelegata);
  2085.         
  2086.         RicezioneContenutiApplicativiIntegrationManagerService service = new RicezioneContenutiApplicativiIntegrationManagerService();
  2087.         return service.process(tipoOperazione, portaDelegata, msg, idInvocazionePerRiferimento, 
  2088.                 logCore, getHttpServletRequest(), getHttpServletResponse(), 
  2089.                 protocolFactory, dataAccettazioneRichiesta, dataIngressoRichiesta);

  2091.     }

  2093. }
Created with JaCoCo 0.8.8.202204050719