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


  22. package org.openspcoop2.pdd.mdb;

  24. import java.io.ByteArrayInputStream;
  25. import java.sql.Timestamp;
  26. import java.util.ArrayList;
  27. import java.util.Date;
  28. import java.util.Enumeration;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.Map;

  34. import javax.xml.soap.SOAPBody;
  35. import javax.xml.soap.SOAPFault;

  37. import org.apache.commons.io.output.NullOutputStream;
  38. import org.openspcoop2.core.config.CorrelazioneApplicativaRisposta;
  39. import org.openspcoop2.core.config.DumpConfigurazione;
  40. import org.openspcoop2.core.config.GestioneErrore;
  41. import org.openspcoop2.core.config.PortaApplicativa;
  42. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  43. import org.openspcoop2.core.config.PortaDelegata;
  44. import org.openspcoop2.core.config.Proprieta;
  45. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  46. import org.openspcoop2.core.config.ServizioApplicativo;
  47. import org.openspcoop2.core.config.Trasformazioni;
  48. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  49. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  50. import org.openspcoop2.core.config.constants.ProprietaProtocolloValore;
  51. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  52. import org.openspcoop2.core.config.constants.TipoBehaviour;
  53. import org.openspcoop2.core.constants.CostantiConnettori;
  54. import org.openspcoop2.core.constants.TipoPdD;
  55. import org.openspcoop2.core.id.IDAccordo;
  56. import org.openspcoop2.core.id.IDPortaApplicativa;
  57. import org.openspcoop2.core.id.IDPortaDelegata;
  58. import org.openspcoop2.core.id.IDServizio;
  59. import org.openspcoop2.core.id.IDServizioApplicativo;
  60. import org.openspcoop2.core.id.IDSoggetto;
  61. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  62. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  63. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  64. import org.openspcoop2.message.OpenSPCoop2Message;
  65. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  66. import org.openspcoop2.message.OpenSPCoop2RestJsonMessage;
  67. import org.openspcoop2.message.OpenSPCoop2RestXmlMessage;
  68. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  69. import org.openspcoop2.message.constants.MessageRole;
  70. import org.openspcoop2.message.constants.MessageType;
  71. import org.openspcoop2.message.constants.ServiceBinding;
  72. import org.openspcoop2.message.exception.ParseException;
  73. import org.openspcoop2.message.soap.SoapUtils;
  74. import org.openspcoop2.message.soap.TunnelSoapUtils;
  75. import org.openspcoop2.message.soap.mtom.MtomXomReference;
  76. import org.openspcoop2.message.utils.MessageUtilities;
  77. import org.openspcoop2.monitor.sdk.transaction.FaseTracciamento;
  78. import org.openspcoop2.pdd.config.ClassNameProperties;
  79. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  80. import org.openspcoop2.pdd.config.ForwardProxy;
  81. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  82. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  83. import org.openspcoop2.pdd.config.RichiestaDelegata;
  84. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  85. import org.openspcoop2.pdd.core.AbstractCore;
  86. import org.openspcoop2.pdd.core.CostantiPdD;
  87. import org.openspcoop2.pdd.core.EJBUtils;
  88. import org.openspcoop2.pdd.core.EJBUtilsException;
  89. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativa;
  90. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativaConfig;
  91. import org.openspcoop2.pdd.core.GestoreMessaggi;
  92. import org.openspcoop2.pdd.core.IntegrationContext;
  93. import org.openspcoop2.pdd.core.LocalForwardEngine;
  94. import org.openspcoop2.pdd.core.LocalForwardException;
  95. import org.openspcoop2.pdd.core.LocalForwardParameter;
  96. import org.openspcoop2.pdd.core.PdDContext;
  97. import org.openspcoop2.pdd.core.ProtocolContext;
  98. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativi;
  99. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiException;
  100. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiRest;
  101. import org.openspcoop2.pdd.core.behaviour.BehaviourForwardToConfiguration;
  102. import org.openspcoop2.pdd.core.behaviour.BehaviourLoadBalancer;
  103. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.ConfigurazioneGestioneConsegnaNotifiche;
  104. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MessaggioDaNotificare;
  105. import org.openspcoop2.pdd.core.connettori.ConnettoreBase;
  106. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseHTTP;
  107. import org.openspcoop2.pdd.core.connettori.ConnettoreException;
  108. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  109. import org.openspcoop2.pdd.core.connettori.ConnettoreUtils;
  110. import org.openspcoop2.pdd.core.connettori.GestoreErroreConnettore;
  111. import org.openspcoop2.pdd.core.connettori.IConnettore;
  112. import org.openspcoop2.pdd.core.connettori.InfoConnettoreUscita;
  113. import org.openspcoop2.pdd.core.connettori.RepositoryConnettori;
  114. import org.openspcoop2.pdd.core.controllo_traffico.ConnettoreUtilities;
  115. import org.openspcoop2.pdd.core.controllo_traffico.DatiTempiRisposta;
  116. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  117. import org.openspcoop2.pdd.core.handlers.HandlerException;
  118. import org.openspcoop2.pdd.core.handlers.InResponseContext;
  119. import org.openspcoop2.pdd.core.handlers.OutRequestContext;
  120. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  121. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePA;
  122. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePASoap;
  123. import org.openspcoop2.pdd.core.integrazione.InResponsePAMessage;
  124. import org.openspcoop2.pdd.core.integrazione.OutRequestPAMessage;
  125. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  126. import org.openspcoop2.pdd.core.state.OpenSPCoopStateDBManager;
  127. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  128. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  129. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  130. import org.openspcoop2.pdd.core.token.TokenForward;
  131. import org.openspcoop2.pdd.core.transazioni.GestoreConsegnaMultipla;
  132. import org.openspcoop2.pdd.core.transazioni.Transaction;
  133. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  134. import org.openspcoop2.pdd.core.trasformazioni.GestoreTrasformazioni;
  135. import org.openspcoop2.pdd.core.trasformazioni.GestoreTrasformazioniException;
  136. import org.openspcoop2.pdd.core.trasformazioni.GestoreTrasformazioniUtilities;
  137. import org.openspcoop2.pdd.logger.DiagnosticInputStream;
  138. import org.openspcoop2.pdd.logger.Dump;
  139. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  140. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  141. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  142. import org.openspcoop2.pdd.logger.transazioni.InformazioniTransazione;
  143. import org.openspcoop2.pdd.logger.transazioni.TracciamentoManager;
  144. import org.openspcoop2.pdd.services.DirectVMProtocolInfo;
  145. import org.openspcoop2.pdd.services.ServicesUtils;
  146. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  147. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  148. import org.openspcoop2.protocol.basic.builder.EsitoBuilder;
  149. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  150. import org.openspcoop2.protocol.engine.constants.Costanti;
  151. import org.openspcoop2.protocol.engine.driver.ConsegnaInOrdine;
  152. import org.openspcoop2.protocol.engine.validator.ValidazioneSintattica;
  153. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  154. import org.openspcoop2.protocol.sdk.Busta;
  155. import org.openspcoop2.protocol.sdk.Context;
  156. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  157. import org.openspcoop2.protocol.sdk.ProtocolException;
  158. import org.openspcoop2.protocol.sdk.Riscontro;
  159. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  160. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  161. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  162. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  163. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  164. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  165. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  166. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  167. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  168. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  169. import org.openspcoop2.protocol.utils.EsitiProperties;
  170. import org.openspcoop2.utils.LimitExceededIOException;
  171. import org.openspcoop2.utils.LimitedInputStream;
  172. import org.openspcoop2.utils.MapKey;
  173. import org.openspcoop2.utils.TimeoutIOException;
  174. import org.openspcoop2.utils.TimeoutInputStream;
  175. import org.openspcoop2.utils.Utilities;
  176. import org.openspcoop2.utils.date.DateManager;
  177. import org.openspcoop2.utils.io.Base64Utilities;
  178. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  179. import org.openspcoop2.utils.rest.problem.JsonDeserializer;
  180. import org.openspcoop2.utils.rest.problem.ProblemConstants;
  181. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  182. import org.openspcoop2.utils.rest.problem.XmlDeserializer;
  183. import org.openspcoop2.utils.transport.TransportRequestContext;
  184. import org.openspcoop2.utils.transport.TransportResponseContext;
  185. import org.openspcoop2.utils.transport.TransportUtils;
  186. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  187. import org.slf4j.Logger;
  188. import org.w3c.dom.Node;

  190. /**
  191.  * Contiene la libreria ConsegnaContenutiApplicativi
  192.  *
  193.  * @author Poli Andrea (apoli@link.it)
  194.  * @author Tronci Fabio (tronci@link.it)
  195.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  196.  * @author $Author$
  197.  * @version $Rev$, $Date$
  198.  * 
  199.  */
  200. public class ConsegnaContenutiApplicativi extends GenericLib {

  202.     public static final String ID_MODULO = "ConsegnaContenutiApplicativi";

  204.     public ConsegnaContenutiApplicativi(Logger log) throws GenericLibException {
  205.         super(ConsegnaContenutiApplicativi.ID_MODULO, log);
  206.         inizializza();
  207.     }

  209.     @Override
  210.     protected synchronized void inizializza() throws GenericLibException {
  211.         super.inizializza();
  212.         ConsegnaContenutiApplicativi.initializeService(ClassNameProperties.getInstance(), this.propertiesReader);
  213.     }


  216.     /** IGestoreIntegrazionePA: lista di gestori, ordinati per priorita' minore */
  217.     public static String[] defaultGestoriIntegrazionePA = null;
  218.     private static java.util.concurrent.ConcurrentHashMap<String, String[]> defaultPerProtocolloGestoreIntegrazionePA = null;
  219.     
  220.     /** Indicazione se sono state inizializzate le variabili del servizio */
  221.     public static boolean initializeService = false;

  223.     /**
  224.      * Inizializzatore del servizio ConsegnaContenutiApplicativi
  225.      * 
  226.      * @throws Exception
  227.      */
  228.     public static synchronized void initializeService(ClassNameProperties className,OpenSPCoop2Properties propertiesReader) {

  230.         if(ConsegnaContenutiApplicativi.initializeService)
  231.             return;

  233.         boolean error = false;
  234.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  235.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  236.         
  237.         // Inizializzo IGestoreIntegrazionePA list
  238.         ConsegnaContenutiApplicativi.defaultGestoriIntegrazionePA = propertiesReader.getTipoIntegrazionePA();
  239.         for(int i=0; i<ConsegnaContenutiApplicativi.defaultGestoriIntegrazionePA.length; i++){
  240.             try{
  241.                 IGestoreIntegrazionePA gestore = pluginLoader.newIntegrazionePortaApplicativa(ConsegnaContenutiApplicativi.defaultGestoriIntegrazionePA[i]);
  242.                 gestore.toString();
  243.                 logCore.info("Inizializzazione gestore dati di integrazione per le erogazioni di tipo "+
  244.                         ConsegnaContenutiApplicativi.defaultGestoriIntegrazionePA[i]+" effettuata.");
  245.             }catch(Exception e){
  246.                 logCore.error(e.getMessage(),e);
  247.                 error = true;
  248.             }
  249.         }
  250.         
  251.         // Inizializzo IGestoreIntegrazionePA per protocollo
  252.         ConsegnaContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePA = new java.util.concurrent.ConcurrentHashMap<String, String[]>();
  253.         try{
  254.             Enumeration<String> enumProtocols = ProtocolFactoryManager.getInstance().getProtocolNames();
  255.             while (enumProtocols.hasMoreElements()) {
  256.                 String protocol = (String) enumProtocols.nextElement();
  257.                 String [] tipiIntegrazionePA = propertiesReader.getTipoIntegrazionePA(protocol);
  258.                 if(tipiIntegrazionePA!=null && tipiIntegrazionePA.length>0){
  259.                     List<String> tipiIntegrazionePerProtocollo = new ArrayList<>();
  260.                     for (int i = 0; i < tipiIntegrazionePA.length; i++) {
  261.                         try {
  262.                             IGestoreIntegrazionePA gestore =  pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazionePA[i]);
  263.                             gestore.toString();
  264.                             tipiIntegrazionePerProtocollo.add(tipiIntegrazionePA[i]);
  265.                             logCore.info("Inizializzazione gestore dati di integrazione (protocollo: "+protocol+") per le erogazioni di tipo "+
  266.                                     tipiIntegrazionePA[i]+" effettuata.");
  267.                         } catch (Exception e) {
  268.                             logCore.error(e.getMessage(),e);
  269.                             error = true;
  270.                         }
  271.                     }
  272.                     if(tipiIntegrazionePerProtocollo.size()>0){
  273.                         ConsegnaContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePA.put(protocol, tipiIntegrazionePerProtocollo.toArray(new String[1]));
  274.                     }
  275.                 }
  276.             }
  277.         }catch(Exception e){
  278.             logCore.error(
  279.                     "Riscontrato errore durante l'inizializzazione dei tipi di integrazione per protocollo: "+e.getMessage(),e);
  280.             error = true;
  281.         }
  282.         
  283.         

  285.         ConsegnaContenutiApplicativi.initializeService = !error;
  286.     }




  291.     /**
  292.      * Attivato,  quando viene ricevuto sulla coda associata al mdb (coda RequestIN_Soap)
  293.      * un messaggio JMS. Questo metodo implementa la logica del modulo ConsegnaContenutiApplicativi
  294.      * dell'infrastruttura OpenSPCoop.
  295.      * 
  296.      */
  297.     @Override
  298.     public EsitoLib _onMessage(IOpenSPCoopState openspcoopstate,
  299.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  300.             MsgDiagnostico msgDiag) throws OpenSPCoopStateException {
  301.         
  302.         ConsegnaContenutiApplicativiMessage consegnaContenutiApplicativiMsg = (ConsegnaContenutiApplicativiMessage) openspcoopstate.getMessageLib();
  303.         
  304.         if(consegnaContenutiApplicativiMsg==null) {
  305.             throw new OpenSPCoopStateException("ConsegnaContenutiApplicativiMessage is null");
  306.         }
  307.         
  308.         IDPortaApplicativa idApplicativa = null;
  309.         if(consegnaContenutiApplicativiMsg.getRichiestaApplicativa()!=null) {
  310.             idApplicativa = consegnaContenutiApplicativiMsg.getRichiestaApplicativa().getIdPortaApplicativa();
  311.         }
  312.         
  313.         OpenSPCoopStateDBManager dbManagerSource = OpenSPCoopStateDBManager.runtime;
  314.         
  315.         // Costruisco eventuale oggetto TransazioneServerApplicativo
  316.         TransazioneApplicativoServer transazioneApplicativoServer = null;
  317.         ConsegnaContenutiApplicativiBehaviourMessage behaviourConsegna = consegnaContenutiApplicativiMsg.getBehaviour();
  318.         Date oraRegistrazione = null;
  319.         if(behaviourConsegna!=null && behaviourConsegna.getIdTransazioneApplicativoServer()!=null) {
  320.             transazioneApplicativoServer = new TransazioneApplicativoServer();
  321.             transazioneApplicativoServer.setIdTransazione(behaviourConsegna.getIdTransazioneApplicativoServer().getIdTransazione());
  322.             transazioneApplicativoServer.setServizioApplicativoErogatore(behaviourConsegna.getIdTransazioneApplicativoServer().getServizioApplicativoErogatore());
  323.             transazioneApplicativoServer.setConnettoreNome(behaviourConsegna.getIdTransazioneApplicativoServer().getConnettoreNome());
  324.             if(behaviourConsegna.getOraRegistrazioneTransazioneApplicativoServer()!=null) {
  325.                 transazioneApplicativoServer.setDataRegistrazione(behaviourConsegna.getOraRegistrazioneTransazioneApplicativoServer());
  326.                 oraRegistrazione = behaviourConsegna.getOraRegistrazioneTransazioneApplicativoServer();
  327.             }
  328.             else {
  329.                 transazioneApplicativoServer.setDataRegistrazione(DateManager.getDate());
  330.             }
  331.             String protocol = (String) consegnaContenutiApplicativiMsg.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME);
  332.             transazioneApplicativoServer.setProtocollo(protocol);
  333.             transazioneApplicativoServer.setDataAccettazioneRichiesta(DateManager.getDate());
  334.             transazioneApplicativoServer.setIdentificativoMessaggio(consegnaContenutiApplicativiMsg.getBusta().getID());
  335.             transazioneApplicativoServer.setConsegnaTrasparente(true);
  336.             
  337.             msgDiag.setTransazioneApplicativoServer(transazioneApplicativoServer, idApplicativa);
  338.             
  339.             dbManagerSource = OpenSPCoopStateDBManager.consegnePreseInCarico;
  340.         }
  341.         BehaviourLoadBalancer loadBalancer = null;
  342.         if(consegnaContenutiApplicativiMsg!=null && consegnaContenutiApplicativiMsg.getLoadBalancer()!=null) {
  343.             loadBalancer = consegnaContenutiApplicativiMsg.getLoadBalancer();
  344.         }
  345.         
  346.         EsitoLib esitoLib = null;
  347.         try {
  348.             if(loadBalancer!=null) {
  349.                 try {
  350.                     loadBalancer.getLoadBalancerPool().addActiveConnection(loadBalancer.getConnectorName());
  351.                 }catch(Throwable t) {
  352.                     String prefix = "";
  353.                     if(transazioneApplicativoServer!=null) {
  354.                         prefix = "["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] " ;
  355.                     }
  356.                     this.log.error(prefix+"Errore durante il salvataggio delle informazioni di load balancer: "+t.getMessage(),t);
  357.                 }
  358.             }
  359.             esitoLib = this.engine_onMessage(openspcoopstate, dbManagerSource,
  360.                     registroServiziManager, configurazionePdDManager, msgDiag, transazioneApplicativoServer, oraRegistrazione);
  361.         }finally {
  362.             if(loadBalancer!=null) {
  363.                 try {
  364.                     loadBalancer.getLoadBalancerPool().removeActiveConnection(loadBalancer.getConnectorName());
  365.                 }catch(Throwable t) {
  366.                     String prefix = "";
  367.                     if(transazioneApplicativoServer!=null) {
  368.                         prefix = "["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] " ;
  369.                     }
  370.                     this.log.error(prefix+"Errore durante il salvataggio delle informazioni di load balancer: "+t.getMessage(),t);
  371.                 }
  372.                 try {
  373.                     boolean erroreUtilizzoConnettore = false;
  374.                     if(consegnaContenutiApplicativiMsg.getPddContext()!=null){
  375.                         Object o = consegnaContenutiApplicativiMsg.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ERRORE_UTILIZZO_CONNETTORE);
  376.                         if(o!=null && (o instanceof Boolean)){
  377.                             erroreUtilizzoConnettore = (Boolean) o;
  378.                         }
  379.                     }
  380.                     if(erroreUtilizzoConnettore) {
  381.                         loadBalancer.getLoadBalancerPool().registerConnectionError(loadBalancer.getConnectorName());
  382.                     }
  383.                 }catch(Throwable t) {
  384.                     String prefix = "";
  385.                     if(transazioneApplicativoServer!=null) {
  386.                         prefix = "["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] " ;
  387.                     }
  388.                     this.log.error(prefix+"Errore durante il salvataggio delle informazioni di load balancer (register error connection): "+t.getMessage(),t);
  389.                 }
  390.             }
  391.         }
  392.                 
  393.         if(transazioneApplicativoServer!=null) {
  394.             
  395.             if(EsitoLib.OK != esitoLib.getStatoInvocazione()) {
  396.                 if(esitoLib.getMotivazioneErroreNonGestito()!=null && !"".equals(esitoLib.getMotivazioneErroreNonGestito())) {
  397.                     transazioneApplicativoServer.setUltimoErrore(esitoLib.getMotivazioneErroreNonGestito());
  398.                 }
  399.                 else if(esitoLib.getErroreNonGestito()!=null) {
  400.                     Throwable e = Utilities.getInnerNotEmptyMessageException(esitoLib.getErroreNonGestito());
  401.                     if(e!=null) {
  402.                         transazioneApplicativoServer.setUltimoErrore(e.getMessage());
  403.                     }
  404.                     else {
  405.                         transazioneApplicativoServer.setUltimoErrore(esitoLib.getErroreNonGestito().toString());
  406.                     }
  407.                 }
  408.                 else {
  409.                     transazioneApplicativoServer.setUltimoErrore("Errore Generico durante il processamento del messaggio");
  410.                 }
  411.             }
  412.             
  413.             if(consegnaContenutiApplicativiMsg!=null && consegnaContenutiApplicativiMsg.getPddContext()!=null) {
  414.                 Object o = consegnaContenutiApplicativiMsg.getPddContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_RESPONSE_COMPLETE_DATE);
  415.                 if(o==null) {
  416.                     o = consegnaContenutiApplicativiMsg.getPddContext().get(DiagnosticInputStream.DIAGNOSTIC_INPUT_STREAM_RESPONSE_ERROR_DATE);
  417.                 }
  418.                 if(o!=null && o instanceof Date) {
  419.                     Date d = (Date) o;
  420.                     transazioneApplicativoServer.setDataIngressoRispostaStream(d);
  421.                 }
  422.             }
  423.             
  424.             try {
  425.                 RequestInfo requestInfo = null;
  426.                 Context context = null;
  427.                 if(consegnaContenutiApplicativiMsg!=null) {
  428.                     context = consegnaContenutiApplicativiMsg.getPddContext();
  429.                     if(context!=null && context.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  430.                         requestInfo = (RequestInfo) context.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  431.                     }
  432.                 }
  433.                 GestoreConsegnaMultipla.getInstance().safeUpdateConsegna(transazioneApplicativoServer, idApplicativa, openspcoopstate, requestInfo, context);
  434.             }catch(Throwable t) {
  435.                 this.log.error("["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  436.             }
  437.         }
  438.         
  439.         return esitoLib;
  440.     }
  441.     
  442.     private EsitoLib engine_onMessage(IOpenSPCoopState openspcoopstate, OpenSPCoopStateDBManager dbManagerSource,
  443.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  444.             MsgDiagnostico msgDiag,
  445.             TransazioneApplicativoServer transazioneApplicativoServer,
  446.             Date oraRegistrazione) throws OpenSPCoopStateException {

  448.         Date dataConsegna = DateManager.getDate();
  449.         
  450.         EsitoLib esito = new EsitoLib();
  451.         
  452.         if(openspcoopstate==null) {
  453.             if(msgDiag!=null) {
  454.                 msgDiag.logErroreGenerico("openspcoopstate is null", "openspcoopstate.checkNull");
  455.             }
  456.             else {
  457.                 this.log.error("openspcoopstate is null");
  458.             }
  459.             esito.setEsitoInvocazione(false); 
  460.             return esito;
  461.         }
  462.         
  463.         ConsegnaContenutiApplicativiMessage consegnaContenutiApplicativiMsg = (ConsegnaContenutiApplicativiMessage) openspcoopstate.getMessageLib();
  464.         
  465.         ConsegnaContenutiApplicativiBehaviourMessage behaviourConsegna = consegnaContenutiApplicativiMsg.getBehaviour();
  466.         String idMessaggioPreBehaviour = null;
  467.         BehaviourForwardToConfiguration behaviourForwardToConfiguration = null;
  468.         GestioneErrore gestioneErroreBehaviour = null;
  469.         if(behaviourConsegna!=null) {
  470.             idMessaggioPreBehaviour = behaviourConsegna.getIdMessaggioPreBehaviour();
  471.             behaviourForwardToConfiguration = behaviourConsegna.getBehaviourForwardToConfiguration();
  472.             gestioneErroreBehaviour = behaviourConsegna.getGestioneErrore();
  473.         }
  474.         
  475.         if(msgDiag==null) {
  476.             if(this.log!=null) {
  477.                 this.log.error("MsgDiagnostico is null");
  478.             }
  479.             openspcoopstate.releaseResource();
  480.             esito.setEsitoInvocazione(false); 
  481.             return esito;
  482.         }
  483.         
  484.         /* PddContext */
  485.         PdDContext pddContext = consegnaContenutiApplicativiMsg.getPddContext();
  486.         
  487.         if(pddContext==null) {
  488.             msgDiag.logErroreGenerico("PddContext is null", "PdDContext.checkNull"); 
  489.             openspcoopstate.releaseResource();
  490.             esito.setEsitoInvocazione(false); 
  491.             return esito;
  492.         }
  493.         
  494.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  495.                 
  496.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  497.         boolean requestInfoForMemoryOptimization = false;
  498.         if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO_IN_MEMORY)) {
  499.             requestInfoForMemoryOptimization = (Boolean) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO_IN_MEMORY);
  500.         }
  501.         
  502.         /* Protocol Factory */
  503.         IProtocolFactory<?> protocolFactory = null;
  504.         try{
  505.             protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  506.         }catch(Exception e){
  507.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  508.             openspcoopstate.releaseResource();
  509.             esito.setEsitoInvocazione(false); 
  510.             esito.setStatoInvocazioneErroreNonGestito(e);
  511.             return esito;
  512.         }
  513.         
  514.         // Transaction
  515.         Transaction transactionNullable = null;
  516.         try{
  517.             transactionNullable = TransactionContext.getTransaction(idTransazione);
  518.         }catch(Exception e){
  519.             // La transazione potrebbe essere stata eliminata nelle comunicazioni stateful
  520. //          msgDiag.logErroreGenerico(e, "getTransaction"); 
  521. //          openspcoopstate.releaseResource();
  522. //          esito.setEsitoInvocazione(false); 
  523. //          esito.setStatoInvocazioneErroreNonGestito(e);
  524. //          return esito;
  525.         }
  526.         
  527.         msgDiag.setPddContext(pddContext, protocolFactory);
  528.         /* ID e tipo di implementazione PdD con cui interoperare */
  529.         String idMessaggioConsegna = openspcoopstate.getIDMessaggioSessione();
  530.         String implementazionePdDMittente = consegnaContenutiApplicativiMsg.getImplementazionePdDSoggettoMittente();
  531.         String implementazionePdDDestinatario = consegnaContenutiApplicativiMsg.getImplementazionePdDSoggettoDestinatario();

  533.         RichiestaApplicativa richiestaApplicativa = consegnaContenutiApplicativiMsg.getRichiestaApplicativa();
  534.         RichiestaDelegata richiestaDelegata = consegnaContenutiApplicativiMsg.getRichiestaDelegata();
  535.         Busta bustaRichiesta = consegnaContenutiApplicativiMsg.getBusta(); // in caso di richiesta delegata serve per il profilo asincrono

  537.         TipoPdD tipoPdD = TipoPdD.APPLICATIVA;
  538.         if(msgDiag.getPorta()==null) {
  539.             if(richiestaApplicativa!=null && richiestaApplicativa.getIdPortaApplicativa()!=null) {
  540.                 msgDiag.updatePorta(tipoPdD, richiestaApplicativa.getIdPortaApplicativa().getNome(), requestInfo);
  541.             }
  542.             else if(richiestaDelegata!=null && richiestaDelegata.getIdPortaDelegata()!=null) {
  543.                 msgDiag.updatePorta(TipoPdD.DELEGATA, richiestaDelegata.getIdPortaDelegata().getNome(), requestInfo);
  544.             }
  545.         }
  546.         
  547.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI);
  548.         if(bustaRichiesta!=null){
  549.             msgDiag.addKeywords(bustaRichiesta, true);
  550.         }
  551.         String descrizioneBehaviour = "";
  552.         if(bustaRichiesta!=null){
  553.             descrizioneBehaviour = bustaRichiesta.removeProperty(CostantiPdD.KEY_DESCRIZIONE_BEHAVIOUR);
  554.             if(descrizioneBehaviour==null){
  555.                 descrizioneBehaviour = "";
  556.             }
  557.             if(!"".equals(descrizioneBehaviour)){
  558.                 descrizioneBehaviour =  " ("+descrizioneBehaviour+")";
  559.             }
  560.         }
  561.         msgDiag.addKeyword(CostantiPdD.KEY_DESCRIZIONE_BEHAVIOUR, descrizioneBehaviour);
  562.         
  563.         // VM ProtocolInfo (se siamo arrivati da un canale VM)
  564.         // Per il caso di LocalForward (se si mettera il tracciamento)
  565.         if(pddContext!=null && bustaRichiesta!=null)
  566.             DirectVMProtocolInfo.setInfoFromContext(pddContext, bustaRichiesta);
  567.         
  568.         // Dati per GestoreEventi
  569.         String servizio = null;
  570.         String tipoServizio = null;
  571.         String azione = null;
  572.         if(bustaRichiesta!=null){
  573.             servizio = bustaRichiesta.getServizio();
  574.             tipoServizio = bustaRichiesta.getTipoServizio();
  575.             azione = bustaRichiesta.getAzione(); // in caso di richiesta delegata serve per il profilo asincrono
  576.         }
  577.         String idModuloInAttesa = null; // in caso di richiesta delegata serve per il profilo asincrono
  578.         IDSoggetto identitaPdD = null; 
  579.         IDSoggetto soggettoFruitore = null; 
  580.         String servizioApplicativo = null; 
  581.         String scenarioCooperazione = null; 
  582.         IDServizio idServizio = null;
  583.         IDAccordo idAccordoServizio = null;
  584.         boolean isRicevutaAsincrona = false; 
  585.         String [] tipiIntegrazione = null;
  586.         boolean allegaBody = false;
  587.         boolean scartaBody = false;
  588.         String servizioApplicativoFruitore = null;
  589.         String idCorrelazioneApplicativa = null;
  590.         String idCorrelazioneApplicativaRisposta = null;
  591.         boolean portaDiTipoStateless = false;
  592.         CorrelazioneApplicativaRisposta correlazioneApplicativaRisposta = null;
  593.         boolean gestioneManifest = false;
  594.         ProprietaManifestAttachments proprietaManifestAttachments = this.propertiesReader.getProprietaManifestAttachments(implementazionePdDMittente);
  595.         Trasformazioni trasformazioni = null;

  597.         IDSoggetto soggettoErogatoreServizioHeaderIntegrazione = null;
  598.         IDSoggetto soggettoFruitoreHeaderIntegrazione = null;
  599.         String profiloGestione = null;
  600.         
  601.         DumpConfigurazione dumpConfig = null;
  602.         
  603.         boolean localForward = false;
  604.         
  605.         ResponseCachingConfigurazione responseCachingConfig = null;
  606.         
  607.         IntegrationContext integrationContext = null;
  608.         ProtocolContext protocolContext = null;
  609.         
  610.         if(richiestaApplicativa!=null){
  611.             identitaPdD = richiestaApplicativa.getDominio();
  612.             soggettoFruitore = richiestaApplicativa.getSoggettoFruitore();
  613.             servizioApplicativo = richiestaApplicativa.getServizioApplicativo();
  614.             idModuloInAttesa = richiestaApplicativa.getIdModuloInAttesa();
  615.             scenarioCooperazione = richiestaApplicativa.getScenario();
  616.             isRicevutaAsincrona = richiestaApplicativa.isRicevutaAsincrona();
  617.             idServizio = richiestaApplicativa.getIDServizio();
  618.             if(bustaRichiesta!=null){
  619.                 if(idServizio.getSoggettoErogatore()!=null){
  620.                     if(idServizio.getSoggettoErogatore().getCodicePorta()==null){
  621.                         idServizio.getSoggettoErogatore().setCodicePorta(bustaRichiesta.getIdentificativoPortaDestinatario());
  622.                     }
  623.                 }
  624.             }
  625.             if(azione!=null && !"".equals(azione) && idServizio!=null && 
  626.                     (idServizio.getAzione()==null || "".equals(idServizio.getAzione()))) {
  627.                 idServizio.setAzione(azione);
  628.             }
  629.             idAccordoServizio = richiestaApplicativa.getIdAccordo();
  630.             if(idServizio!=null) {
  631.                 soggettoErogatoreServizioHeaderIntegrazione = idServizio.getSoggettoErogatore();
  632.             }
  633.             profiloGestione = richiestaApplicativa.getProfiloGestione();
  634.             servizioApplicativoFruitore = richiestaApplicativa.getIdentitaServizioApplicativoFruitore();
  635.             idCorrelazioneApplicativa = richiestaApplicativa.getIdCorrelazioneApplicativa();

  637.             localForward = richiestaApplicativa.isLocalForward();
  638.             
  639.             integrationContext = richiestaApplicativa.getIntegrazione();
  640.             protocolContext = richiestaApplicativa.getProtocol();
  641.             
  642.         }else{
  643.             identitaPdD = richiestaDelegata.getDominio();
  644.             soggettoFruitore = richiestaDelegata.getIdSoggettoFruitore();
  645.             servizioApplicativo = richiestaDelegata.getServizioApplicativo();
  646.             idModuloInAttesa = richiestaDelegata.getIdModuloInAttesa();
  647.             scenarioCooperazione = richiestaDelegata.getScenario();
  648.             isRicevutaAsincrona = richiestaDelegata.isRicevutaAsincrona();
  649.             idServizio = richiestaDelegata.getIdServizio();
  650.             if(bustaRichiesta!=null){
  651.                 if(idServizio!=null && idServizio.getSoggettoErogatore()!=null){
  652.                     if(idServizio.getSoggettoErogatore().getCodicePorta()==null){
  653.                         idServizio.getSoggettoErogatore().setCodicePorta(bustaRichiesta.getIdentificativoPortaDestinatario());
  654.                     }
  655.                 }
  656.             }
  657.             if(azione!=null && !"".equals(azione) && idServizio!=null && 
  658.                     (idServizio.getAzione()==null || "".equals(idServizio.getAzione()))) {
  659.                 idServizio.setAzione(azione);
  660.             }
  661.             idAccordoServizio = richiestaDelegata.getIdAccordo();
  662.             if ( bustaRichiesta!=null && Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione) ){
  663.                 soggettoErogatoreServizioHeaderIntegrazione = new IDSoggetto(bustaRichiesta.getTipoDestinatario(),bustaRichiesta.getDestinatario());
  664.                 soggettoFruitoreHeaderIntegrazione = new IDSoggetto(bustaRichiesta.getTipoMittente(),bustaRichiesta.getMittente(), bustaRichiesta.getIdentificativoPortaMittente());
  665.             }else{
  666.                 soggettoErogatoreServizioHeaderIntegrazione = idServizio.getSoggettoErogatore();
  667.             }
  668.             profiloGestione = richiestaDelegata.getProfiloGestione();
  669.             servizioApplicativoFruitore = richiestaDelegata.getServizioApplicativo();
  670.             idCorrelazioneApplicativa = richiestaDelegata.getIdCorrelazioneApplicativa();
  671.             
  672.             integrationContext = richiestaDelegata.getIntegrazione();
  673.             protocolContext = richiestaDelegata.getProtocol();
  674.         }
  675.         
  676.         IDServizio servizioHeaderIntegrazione = null;
  677.         if(bustaRichiesta!=null){
  678.             // Per ricambiare il servizio in correlato per:
  679.             // - AsincronoAsimmetrico, richiestaStato
  680.             // - AsincronoSimmetrico, risposta
  681.             try{
  682.                 servizioHeaderIntegrazione = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRichiesta.getTipoServizio(), bustaRichiesta.getServizio(), 
  683.                         soggettoErogatoreServizioHeaderIntegrazione, bustaRichiesta.getVersioneServizio());
  684.                 servizioHeaderIntegrazione.setAzione(bustaRichiesta.getAzione());
  685.             }catch(Exception e){
  686.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.getIDServizioFromValues");
  687.                 esito.setEsitoInvocazione(false); 
  688.                 esito.setStatoInvocazioneErroreNonGestito(e);
  689.                 return esito;
  690.             }
  691.         }   
  692.         
  693.         IDServizioApplicativo servizioApplicativoToken = null;
  694.         if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN)) {
  695.             servizioApplicativoToken = (IDServizioApplicativo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_APPLICATIVO_TOKEN);
  696.         }
  697.         
  698.         msgDiag.mediumDebug("Profilo di gestione ["+ConsegnaContenutiApplicativi.ID_MODULO+"] della busta: "+profiloGestione);
  699.         msgDiag.setDominio(identitaPdD);  // imposto anche il dominio nel msgDiag
  700.         msgDiag.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  701.         msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, servizioApplicativo);
  702.         if(servizioApplicativoFruitore!=null){
  703.             msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, servizioApplicativoFruitore);
  704.         }
  705.         boolean soggettoVirtuale = false;
  706.         try{
  707.             soggettoVirtuale = configurazionePdDManager.isSoggettoVirtuale( identitaPdD, requestInfo );
  708.         }catch(Exception e){
  709.             msgDiag.logErroreGenerico(e, "isSoggettoVirtuale("+identitaPdD+")");
  710.             esito.setEsitoInvocazione(false); 
  711.             esito.setStatoInvocazioneErroreNonGestito(e);
  712.             return esito;
  713.         }
  714.         
  715.         // Aggiornamento Informazioni
  716.         msgDiag.setIdMessaggioRichiesta(idMessaggioConsegna);
  717.         if(idMessaggioPreBehaviour!=null){
  718.             msgDiag.setIdMessaggioRichiesta(idMessaggioPreBehaviour);
  719.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessaggioPreBehaviour);
  720.         }
  721.         if(soggettoFruitoreHeaderIntegrazione!=null)
  722.             msgDiag.setFruitore(soggettoFruitoreHeaderIntegrazione);
  723.         else
  724.             msgDiag.setFruitore(soggettoFruitore);
  725.         if(servizioHeaderIntegrazione!=null){
  726.             msgDiag.setServizio(servizioHeaderIntegrazione);
  727.         }else{
  728.             msgDiag.setServizio(idServizio);
  729.         }
  730.         if(transazioneApplicativoServer!=null) {
  731.             msgDiag.setServizioApplicativo(servizioApplicativo);
  732.         }

  734.         // Calcolo Profilo di Collaborazione
  735.         msgDiag.mediumDebug("Calcolo profilo di collaborazione...");
  736.         ProfiloDiCollaborazione profiloCollaborazione = EJBUtils.calcolaProfiloCollaborazione(scenarioCooperazione);


  739.         PortaApplicativa pa = null;
  740.         IDPortaApplicativa idPA = null;
  741.         PortaDelegata pd = null;
  742.         IDPortaDelegata idPD = null;
  743.         ServizioApplicativo sa = null;
  744.         if(richiestaApplicativa!=null){
  745.             idPA = richiestaApplicativa.getIdPortaApplicativa();
  746.             try{
  747.                 msgDiag.mediumDebug("getPortaApplicativa...");
  748.                 pa = configurazionePdDManager.getPortaApplicativa(idPA, requestInfo);
  749.             }catch(Exception e){
  750.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.getPortaApplicativa");
  751.                 esito.setEsitoInvocazione(false); 
  752.                 esito.setStatoInvocazioneErroreNonGestito(e);
  753.                 return esito;
  754.             }
  755.             try{
  756.                 msgDiag.mediumDebug("getServizioApplicativo(pa)...");
  757.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  758.                 idSA.setNome(richiestaApplicativa.getServizioApplicativo());
  759.                 idSA.setIdSoggettoProprietario(richiestaApplicativa.getIDServizio().getSoggettoErogatore());
  760.                 sa = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo);
  761.             }catch(Exception e){
  762.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.getServizioApplicativo");
  763.                 esito.setEsitoInvocazione(false); 
  764.                 esito.setStatoInvocazioneErroreNonGestito(e);
  765.                 return esito;
  766.             }
  767.             if(pa!=null)
  768.                 correlazioneApplicativaRisposta = pa.getCorrelazioneApplicativaRisposta();
  769.         }else{
  770.             idPD = richiestaDelegata.getIdPortaDelegata();
  771.             try{
  772.                 msgDiag.mediumDebug("getPortaDelegata...");
  773.                 pd = configurazionePdDManager.getPortaDelegata(idPD, requestInfo);
  774.             }catch(Exception e){
  775.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.getPortaApplicativa");
  776.                 esito.setEsitoInvocazione(false); 
  777.                 esito.setStatoInvocazioneErroreNonGestito(e);
  778.                 return esito;
  779.             }
  780.             try{
  781.                 msgDiag.mediumDebug("getServizioApplicativo(pd)...");
  782.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  783.                 idSA.setNome(richiestaDelegata.getServizioApplicativo());
  784.                 idSA.setIdSoggettoProprietario(richiestaDelegata.getIdSoggettoFruitore());
  785.                 sa = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo);
  786.             }catch(Exception e){
  787.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.getServizioApplicativo");
  788.                 esito.setEsitoInvocazione(false); 
  789.                 esito.setStatoInvocazioneErroreNonGestito(e);
  790.                 return esito;
  791.             }
  792.             if(pd!=null)
  793.                 correlazioneApplicativaRisposta = pd.getCorrelazioneApplicativaRisposta();
  794.         }


  797.         // Recupero informazioni behaviour
  798.         TipoBehaviour behaviourType = null;
  799.         boolean salvaRispostaPerNotifiche = false;
  800.         MessaggioDaNotificare tipiMessaggiNotificabili = null;
  801.         String identificativoMessaggioDoveSalvareLaRisposta = null; 
  802.         MessaggioDaNotificare tipoMessaggioDaNotificare_notificaAsincrona = null;
  803.         boolean transactionContext_notificaAsincrona = false;
  804.         HttpRequestMethod metodoHttpDaNotificare_notificaAsincrona = null;
  805.         String nomeConnettoreMultiplo = null;
  806.         String nomeServizioApplicativoErogatoreConnettoreMultiplo = null;
  807.         String nomeConnettoreAPIImplementation = null;
  808.         String nomeServizioApplicativoErogatoreAPIImplementation = null;
  809.         try{
  810.             if(pa!=null && pa.getBehaviour()!=null) {
  811.                 
  812.                 behaviourType = TipoBehaviour.toEnumConstant(pa.getBehaviour().getNome());
  813.                 
  814.                 // NomeConnettore
  815.                 if(transazioneApplicativoServer!=null) {
  816.                     for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  817.                         if(pasa!=null && pasa.getNome()!=null && pasa.getNome().equals(transazioneApplicativoServer.getServizioApplicativoErogatore())) {
  818.                             nomeServizioApplicativoErogatoreConnettoreMultiplo = transazioneApplicativoServer.getServizioApplicativoErogatore();
  819.                             nomeConnettoreMultiplo = pasa.getDatiConnettore()!= null ? pasa.getDatiConnettore().getNome() : null;
  820.                             if(nomeConnettoreMultiplo==null) {
  821.                                 nomeConnettoreMultiplo=CostantiConfigurazione.NOME_CONNETTORE_DEFAULT;
  822.                             }
  823.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_NOME_CONNETTORE, nomeConnettoreMultiplo);
  824.                             break;
  825.                         }
  826.                     }
  827.                 }
  828.                 else {
  829.                     for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  830.                         if(pasa!=null && pasa.getNome()!=null && pasa.getNome().equals(servizioApplicativo)) {
  831.                             nomeServizioApplicativoErogatoreAPIImplementation = servizioApplicativo;
  832.                             nomeConnettoreAPIImplementation = pasa.getDatiConnettore()!= null ? pasa.getDatiConnettore().getNome() : null;
  833.                             if(nomeConnettoreAPIImplementation==null) {
  834.                                 nomeConnettoreAPIImplementation=CostantiConfigurazione.NOME_CONNETTORE_DEFAULT;
  835.                             }
  836.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_NOME_CONNETTORE_API, nomeConnettoreAPIImplementation);
  837.                             break;
  838.                         }
  839.                     }
  840.                 }
  841.                 
  842.                 if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(behaviourType)) {
  843.                     if(transazioneApplicativoServer==null) {
  844.                         List<String> serviziApplicativiAbilitatiForwardTo = readServiziApplicativiAbilitatiForwardTo(pddContext);
  845.                         if(serviziApplicativiAbilitatiForwardTo!=null && !serviziApplicativiAbilitatiForwardTo.isEmpty()) {
  846.                             tipiMessaggiNotificabili = org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverUtils.readMessaggiNotificabili(pa, serviziApplicativiAbilitatiForwardTo);
  847.                             if(tipiMessaggiNotificabili!=null && 
  848.                                     (
  849.                                             MessaggioDaNotificare.RISPOSTA.equals(tipiMessaggiNotificabili)
  850.                                             ||
  851.                                             MessaggioDaNotificare.ENTRAMBI.equals(tipiMessaggiNotificabili)
  852.                                             )) {
  853.                                 salvaRispostaPerNotifiche = true;
  854.                                 identificativoMessaggioDoveSalvareLaRisposta = CostantiPdD.PREFIX_MESSAGGIO_CONNETTORE_MULTIPLO+0+CostantiPdD.SEPARATOR_MESSAGGIO_CONNETTORE_MULTIPLO+idMessaggioConsegna;
  855.                             }
  856.                             
  857.                             boolean injectTransactionContext = org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverUtils.isSaveTransactionContext(pa, serviziApplicativiAbilitatiForwardTo);
  858.                             if(injectTransactionContext) {
  859.                                 if(identificativoMessaggioDoveSalvareLaRisposta==null) {
  860.                                     identificativoMessaggioDoveSalvareLaRisposta = CostantiPdD.PREFIX_MESSAGGIO_CONNETTORE_MULTIPLO+0+CostantiPdD.SEPARATOR_MESSAGGIO_CONNETTORE_MULTIPLO+idMessaggioConsegna;
  861.                                 }
  862.                                 pddContext.addObject(CostantiPdD.SALVA_CONTESTO_IDENTIFICATIVO_MESSAGGIO_NOTIFICA, identificativoMessaggioDoveSalvareLaRisposta);
  863.                             }
  864.                         }
  865.                     }
  866.                     else {
  867.                         for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  868.                             if(pasa!=null && pasa.getNome()!=null && pasa.getNome().equals(transazioneApplicativoServer.getServizioApplicativoErogatore())) {
  869.                                 ConfigurazioneGestioneConsegnaNotifiche config = org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverUtils.read(pasa);
  870.                                 if(config!=null) {
  871.                                     tipoMessaggioDaNotificare_notificaAsincrona = config.getMessaggioDaNotificare();
  872.                                     transactionContext_notificaAsincrona = config.isInjectTransactionSyncContext();
  873.                                     metodoHttpDaNotificare_notificaAsincrona = config.getHttpMethod();
  874.                                 }
  875.                                 if(tipoMessaggioDaNotificare_notificaAsincrona==null) {
  876.                                     tipoMessaggioDaNotificare_notificaAsincrona = MessaggioDaNotificare.RICHIESTA;
  877.                                 }
  878.                                 if(metodoHttpDaNotificare_notificaAsincrona==null &&
  879.                                         (
  880.                                                 MessaggioDaNotificare.RISPOSTA.equals(tipoMessaggioDaNotificare_notificaAsincrona) || 
  881.                                                 MessaggioDaNotificare.ENTRAMBI.equals(tipoMessaggioDaNotificare_notificaAsincrona)
  882.                                         )
  883.                                     ) {
  884.                                     metodoHttpDaNotificare_notificaAsincrona = HttpRequestMethod.POST;
  885.                                 }
  886.                                 break;
  887.                             }
  888.                         }
  889.                     }
  890.                 }
  891.             }
  892.         }catch(Exception e){
  893.             msgDiag.logErroreGenerico(e, "ConfigurazioneBehaviour");
  894.             esito.setEsitoInvocazione(false); 
  895.             esito.setStatoInvocazioneErroreNonGestito(e);
  896.             return esito;
  897.         }

  899.         // Recupero anche pd in caso di local forward
  900.         if(localForward && pd==null){
  901.             try{
  902.                 msgDiag.mediumDebug("getPortaDelegata...");
  903.                 pd = configurazionePdDManager.getPortaDelegata(richiestaDelegata.getIdPortaDelegata(), requestInfo);
  904.             }catch(Exception e){
  905.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.getPortaApplicativa");
  906.                 esito.setEsitoInvocazione(false); 
  907.                 esito.setStatoInvocazioneErroreNonGestito(e);
  908.                 return esito;
  909.             }
  910.         }
  911.         


  914.         // La lettura dalla configurazione deve essere dopo il transaction manager
  915.         if(richiestaApplicativa!=null && !localForward){
  916.             try{
  917.                 msgDiag.mediumDebug("isAllegaBody(pa)...");
  918.                 allegaBody = configurazionePdDManager.isAllegaBody(pa);
  919.             }catch(Exception e){
  920.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.isAllegaBody");
  921.                 esito.setEsitoInvocazione(false); 
  922.                 esito.setStatoInvocazioneErroreNonGestito(e);
  923.                 return esito;
  924.             }   
  925.             try{
  926.                 msgDiag.mediumDebug("isScartaBody(pa)...");
  927.                 scartaBody = configurazionePdDManager.isScartaBody(pa);
  928.             }catch(Exception e){
  929.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.isScartaBody");
  930.                 esito.setEsitoInvocazione(false); 
  931.                 esito.setStatoInvocazioneErroreNonGestito(e);
  932.                 return esito;
  933.             }   
  934.             try{
  935.                 msgDiag.mediumDebug("getTipiIntegrazione(pa)...");
  936.                 tipiIntegrazione = configurazionePdDManager.getTipiIntegrazione(pa);
  937.             }catch(Exception e){
  938.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.getTipiIntegrazione");
  939.                 esito.setEsitoInvocazione(false); 
  940.                 esito.setStatoInvocazioneErroreNonGestito(e);
  941.                 return esito;
  942.             }
  943.             try{
  944.                 msgDiag.mediumDebug("isModalitaStateless(pa)...");
  945.                 portaDiTipoStateless = configurazionePdDManager.isModalitaStateless(pa, profiloCollaborazione); 
  946.             }catch(Exception e){
  947.                 msgDiag.logErroreGenerico(e, "RichiestaApplicativa.isModalitaStateless("+profiloCollaborazione+")");
  948.                 esito.setEsitoInvocazione(false); 
  949.                 esito.setStatoInvocazioneErroreNonGestito(e);
  950.                 return esito;
  951.             }
  952.             try{
  953.                 msgDiag.mediumDebug("isGestioneManifestAttachments(pa)...");
  954.                 gestioneManifest = configurazionePdDManager.isGestioneManifestAttachments(pa,protocolFactory); 
  955.             }catch(Exception e){
  956.                 msgDiag.logErroreGenerico(e, "isGestioneManifestAttachments(pa)");
  957.                 esito.setEsitoInvocazione(false); 
  958.                 esito.setStatoInvocazioneErroreNonGestito(e);
  959.                 return esito;
  960.             }
  961.             try{
  962.                 msgDiag.mediumDebug("readDumpConfig(pa)...");
  963.                 dumpConfig = configurazionePdDManager.getDumpConfigurazione(pa);
  964.             }catch(Exception e){
  965.                 msgDiag.logErroreGenerico(e, "readDumpConfig(pa)");
  966.                 esito.setEsitoInvocazione(false); 
  967.                 esito.setStatoInvocazioneErroreNonGestito(e);
  968.                 return esito;
  969.             }
  970.             try{
  971.                 msgDiag.mediumDebug("readResponseCachingConfig(pa)...");
  972.                 responseCachingConfig = configurazionePdDManager.getConfigurazioneResponseCaching(pa);
  973.             }catch(Exception e){
  974.                 msgDiag.logErroreGenerico(e, "readResponseCachingConfig(pa)");
  975.                 esito.setEsitoInvocazione(false); 
  976.                 esito.setStatoInvocazioneErroreNonGestito(e);
  977.                 return esito;
  978.             }
  979.             try{
  980.                 msgDiag.mediumDebug("readTrasformazioni(pa)...");
  981.                 trasformazioni = configurazionePdDManager.getTrasformazioni(pa);
  982.             }catch(Exception e){
  983.                 msgDiag.logErroreGenerico(e, "readTrasformazioni(pa)");
  984.                 esito.setEsitoInvocazione(false); 
  985.                 esito.setStatoInvocazioneErroreNonGestito(e);
  986.                 return esito;
  987.             }
  988.             
  989.         }else{
  990.             try{
  991.                 msgDiag.mediumDebug("isAllegaBody(pd)...");
  992.                 allegaBody = configurazionePdDManager.isAllegaBody(pd);
  993.             }catch(Exception e){
  994.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.isAllegaBody");
  995.                 esito.setEsitoInvocazione(false); 
  996.                 esito.setStatoInvocazioneErroreNonGestito(e);
  997.                 return esito;
  998.             }   
  999.             try{
  1000.                 msgDiag.mediumDebug("isScartaBody(pd)...");
  1001.                 scartaBody = configurazionePdDManager.isScartaBody(pd);
  1002.             }catch(Exception e){
  1003.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.isScartaBody");
  1004.                 esito.setEsitoInvocazione(false); 
  1005.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1006.                 return esito;
  1007.             }   
  1008.             try{
  1009.                 msgDiag.mediumDebug("getTipiIntegrazione(pd)...");
  1010.                 tipiIntegrazione = configurazionePdDManager.getTipiIntegrazione(pd);
  1011.             }catch(Exception e){
  1012.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.getTipiIntegrazione");
  1013.                 esito.setEsitoInvocazione(false); 
  1014.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1015.                 return esito;
  1016.             }
  1017.             try{
  1018.                 msgDiag.mediumDebug("isModalitaStateless(pd)...");
  1019.                 portaDiTipoStateless = configurazionePdDManager.isModalitaStateless(pd, profiloCollaborazione); 
  1020.             }catch(Exception e){
  1021.                 msgDiag.logErroreGenerico(e, "RichiestaDelegata.isModalitaStateless("+profiloCollaborazione+")");
  1022.                 esito.setEsitoInvocazione(false); 
  1023.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1024.                 return esito;
  1025.             }
  1026.             try{
  1027.                 msgDiag.mediumDebug("isGestioneManifestAttachments(pd)...");
  1028.                 gestioneManifest = configurazionePdDManager.isGestioneManifestAttachments(pd,protocolFactory); 
  1029.             }catch(Exception e){
  1030.                 msgDiag.logErroreGenerico(e, "isGestioneManifestAttachments(pd)");
  1031.                 esito.setEsitoInvocazione(false); 
  1032.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1033.                 return esito;
  1034.             }
  1035.             try{
  1036.                 msgDiag.mediumDebug("readDumpConfig(pd)...");
  1037.                 dumpConfig = configurazionePdDManager.getDumpConfigurazione(pd);
  1038.             }catch(Exception e){
  1039.                 msgDiag.logErroreGenerico(e, "readDumpConfig(pd)");
  1040.                 esito.setEsitoInvocazione(false); 
  1041.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1042.                 return esito;
  1043.             }
  1044.             try{
  1045.                 msgDiag.mediumDebug("readResponseCachingConfig(pd)...");
  1046.                 responseCachingConfig = configurazionePdDManager.getConfigurazioneResponseCaching(pd);
  1047.             }catch(Exception e){
  1048.                 msgDiag.logErroreGenerico(e, "readResponseCachingConfig(pd)");
  1049.                 esito.setEsitoInvocazione(false); 
  1050.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1051.                 return esito;
  1052.             }
  1053.             try{
  1054.                 msgDiag.mediumDebug("readTrasformazioni(pd)...");
  1055.                 trasformazioni = configurazionePdDManager.getTrasformazioni(pd);
  1056.             }catch(Exception e){
  1057.                 msgDiag.logErroreGenerico(e, "readTrasformazioni(pd)");
  1058.                 esito.setEsitoInvocazione(false); 
  1059.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1060.                 return esito;
  1061.             }
  1062.         }

  1064.         if(idMessaggioPreBehaviour!=null) {
  1065.             portaDiTipoStateless = false;
  1066.         }
  1067.         else if(soggettoVirtuale) {
  1068.             portaDiTipoStateless = false;
  1069.         }
  1070.         pddContext.addObject(org.openspcoop2.core.constants.Costanti.STATELESS, portaDiTipoStateless+"");


  1073.         
  1074.         LocalForwardEngine localForwardEngine = null;
  1075.         LocalForwardParameter localForwardParameter = null;
  1076.         try{
  1077.             
  1078.             if(localForward){
  1079.                 
  1080.                 localForwardParameter = new LocalForwardParameter();
  1081.                 localForwardParameter.setLog(this.log);
  1082.                 localForwardParameter.setConfigurazionePdDReader(configurazionePdDManager);
  1083.                 localForwardParameter.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  1084.                 localForwardParameter.setIdentitaPdD(identitaPdD);
  1085.                 localForwardParameter.setIdModulo(this.idModulo);
  1086.                 localForwardParameter.setIdRequest(idMessaggioConsegna);
  1087.                 localForwardParameter.setImplementazionePdDDestinatario(implementazionePdDDestinatario);
  1088.                 localForwardParameter.setImplementazionePdDMittente(implementazionePdDMittente);
  1089.                 localForwardParameter.setIdPdDMittente(registroServiziManager.getIdPortaDominio(soggettoFruitore, null, requestInfo));
  1090.                 localForwardParameter.setIdPdDDestinatario(registroServiziManager.getIdPortaDominio(idServizio.getSoggettoErogatore(), null, requestInfo));
  1091.                 localForwardParameter.setMsgDiag(msgDiag);
  1092.                 localForwardParameter.setOpenspcoopstate(openspcoopstate);
  1093.                 localForwardParameter.setPddContext(pddContext);
  1094.                 localForwardParameter.setProtocolFactory(protocolFactory);
  1095.                 localForwardParameter.setRichiestaDelegata(richiestaDelegata);
  1096.                 localForwardParameter.setRichiestaApplicativa(richiestaApplicativa);
  1097.                 localForwardParameter.setStateless(portaDiTipoStateless);
  1098.                 localForwardParameter.setBusta(bustaRichiesta);
  1099.                 
  1100.                 localForwardEngine = new LocalForwardEngine(localForwardParameter);
  1101.             }
  1102.             
  1103.         }catch(Exception e){
  1104.             msgDiag.logErroreGenerico(e, "LocalForwardEngine.init");
  1105.             esito.setEsitoInvocazione(false); 
  1106.             esito.setStatoInvocazioneErroreNonGestito(e);
  1107.             return esito;
  1108.         }
  1109.         
  1110.         
  1111.         


  1114.         /* ------------------ Connessione al DB  --------------- */
  1115.         msgDiag.mediumDebug("Richiesta connessione al database per la gestione della richiesta...");
  1116.         openspcoopstate.initResource(identitaPdD, ConsegnaContenutiApplicativi.ID_MODULO,idTransazione,dbManagerSource);
  1117.         registroServiziManager.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  1118.         configurazionePdDManager = configurazionePdDManager.refreshState(registroServiziManager);
  1119.         msgDiag.updateState(configurazionePdDManager);
  1120.         


  1123.         /* ----------- Analisi tipo di Consegna Contenuti Applicativi:
  1124.            OneWay (InvocazioneServizio) in modalita asincrona:
  1125.            - Non serve aspettare una risposta applicativa
  1126.            - Non serve generare una risposta (eventuale busta con riscontri e' gia' stata inviata)
  1127.            OneWay (InvocazioneServizio) in modalita sincrona:
  1128.            - Bisogna aspettare una risposta applicativa sincrona
  1129.            - Bisogna solo sbloccare RicezioneBuste non appena ricevuto http 200.
  1130.            Sincrono (InvocazioneServizio):
  1131.            - Bisogna aspettare una risposta applicativa sincrona
  1132.            - Bisogna quindi generare un busta della risposta sincrona
  1133.            AsincronoSimmetrico (InvocazioneServizio):
  1134.            - Non serve aspettare una risposta applicativa se la ricevuta applicativa e' disabilitata
  1135.              altrimenti deve essere aspettata.
  1136.            - Non serve generare una risposta (la ricevuta e' gia' stata inviata) se la ricevuta applicativa e' disabilitata
  1137.              altrimenti bisogna generare un busta contenente la ricevuta
  1138.           AsincronoSimmetrico (ConsegnaRisposta):
  1139.            - Non serve aspettare una risposta applicativa se la ricevuta applicativa e' disabilitata
  1140.              altrimenti deve essere aspettata.
  1141.            - Non serve generare una risposta (la ricevuta e' gia' stata inviata) se la ricevuta applicativa e' disabilitata
  1142.              altrimenti bisogna generare un busta contenente la ricevuta
  1143.            AsincronoAsimmetrico (InvocazioneServizio):
  1144.            - Non serve aspettare una risposta applicativa (sara' poi richiesta con il polling) se la ricevuta applicativa e' disabilitata
  1145.              altrimenti deve essere aspettata.
  1146.            - Non serve generare una risposta (la ricevuta e' gia' stata inviata) se la ricevuta applicativa e' disabilitata
  1147.              altrimenti bisogna generare un busta contenente la ricevuta
  1148.            AsincronoAsimmetrico (Polling):
  1149.            - Bisogna aspettare una risposta applicativa 'sincrona' comunque
  1150.            - Bisogna quindi generare un busta della risposta contenente il risultato del polling
  1151.            ConsegnaContenutiApplicativi:
  1152.            - Non serve aspettare una risposta applicativa
  1153.            - Non serve generare una risposta (e' la parte finale di consegna gia' della risposta)
  1154.            ------------- */
  1155.         boolean existsModuloInAttesaRispostaApplicativa = false;
  1156.         if(idMessaggioPreBehaviour!=null){
  1157.             existsModuloInAttesaRispostaApplicativa = false;
  1158.         }
  1159.         else if(Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ){
  1160.             existsModuloInAttesaRispostaApplicativa = true;
  1161.         }
  1162.         else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(scenarioCooperazione)){
  1163.             existsModuloInAttesaRispostaApplicativa = true;
  1164.         }
  1165.         else if (Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ||
  1166.                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ||
  1167.                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione)){
  1168.             existsModuloInAttesaRispostaApplicativa = portaDiTipoStateless || isRicevutaAsincrona;
  1169.         }
  1170.         else if( (richiestaApplicativa!=null) && Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) ){
  1171.             existsModuloInAttesaRispostaApplicativa = portaDiTipoStateless;
  1172.         }



  1176.         /* ------------------ Inizializzazione Contesto di gestione della Richiesta --------------- */
  1177.         msgDiag.mediumDebug("Inizializzo contesto per la gestione...");
  1178.         // EJBUtils (per eventuali errori)
  1179.         EJBUtils ejbUtils = null;
  1180.         try{
  1181.             String idMessaggioGestoreMessaggiRichiesta = idMessaggioConsegna;
  1182.             if(idMessaggioPreBehaviour!=null){
  1183.                 idMessaggioGestoreMessaggiRichiesta = bustaRichiesta.getID();
  1184.             }
  1185.             ejbUtils = new EJBUtils(identitaPdD,tipoPdD,ConsegnaContenutiApplicativi.ID_MODULO,idMessaggioConsegna,
  1186.                     idMessaggioGestoreMessaggiRichiesta,Costanti.INBOX,openspcoopstate,msgDiag,false,
  1187.                     consegnaContenutiApplicativiMsg.getImplementazionePdDSoggettoMittente(),
  1188.                     consegnaContenutiApplicativiMsg.getImplementazionePdDSoggettoDestinatario(),
  1189.                     profiloGestione,pddContext
  1190.             );
  1191.             ejbUtils.setServizioApplicativoErogatore(servizioApplicativo);
  1192.         }catch(Exception e){
  1193.             msgDiag.logErroreGenerico(e, "EJBUtils.new");
  1194.             openspcoopstate.releaseResource();
  1195.             esito.setEsitoInvocazione(false); 
  1196.             esito.setStatoInvocazioneErroreNonGestito(e);

  1198.             return esito;
  1199.         }
  1200.         
  1201.         // GestoriMessaggio
  1202.         msgDiag.mediumDebug("Inizializzo contesto per la gestione (GestoreMessaggio)...");
  1203.         String idMessaggioGestoreMessaggiRichiesta = idMessaggioConsegna;
  1204.         if(idMessaggioPreBehaviour!=null){
  1205.             idMessaggioGestoreMessaggiRichiesta = bustaRichiesta.getID();
  1206.         }
  1207.         GestoreMessaggi msgRequest = new GestoreMessaggi(openspcoopstate, true, idMessaggioGestoreMessaggiRichiesta,Costanti.INBOX,msgDiag,pddContext);
  1208.         OpenSPCoop2Message consegnaMessagePrimaTrasformazione = null;
  1209.         OpenSPCoop2Message consegnaResponseMessagePrimaTrasformazione = null;
  1210.         Context notificaTransactionContext = null;
  1211.         GestoreMessaggi msgResponse = null;
  1212.         msgRequest.setPortaDiTipoStateless(portaDiTipoStateless);
  1213.         
  1214.         // RequestInfo
  1215.         if( 
  1216.                 (requestInfo==null) 
  1217.                 || 
  1218.                 (requestInfoForMemoryOptimization) 
  1219.                 || 
  1220.                 (idTransazione==null)
  1221.             ) {
  1222.             // devo leggerlo dal messaggio
  1223.             try {
  1224.                 RequestInfo _requestInfoForMemoryOptimization = null;
  1225.                 if(requestInfoForMemoryOptimization) {
  1226.                     _requestInfoForMemoryOptimization = requestInfo;
  1227.                 }

  1229.                 if(transactionContext_notificaAsincrona) {
  1230.                     notificaTransactionContext = msgRequest.getSyncTransactionContext();
  1231.                     if(notificaTransactionContext!=null && !notificaTransactionContext.isEmpty()) {
  1232.                         pddContext.put(CostantiPdD.CONTESTO_RICHIESTA_MESSAGGIO_NOTIFICA, notificaTransactionContext);
  1233.                     }
  1234.                 }
  1235.                 
  1236.                 if(tipoMessaggioDaNotificare_notificaAsincrona!=null) {
  1237.                     switch (tipoMessaggioDaNotificare_notificaAsincrona) {
  1238.                     case RICHIESTA:
  1239.                         consegnaMessagePrimaTrasformazione = msgRequest.getMessage();
  1240.                         break;
  1241.                     case RISPOSTA:
  1242.                         consegnaMessagePrimaTrasformazione = msgRequest.getResponseMessage(true, true); //se deve essere consegnata solamente la risposta, questa deve esistere
  1243.                         break;
  1244.                     case ENTRAMBI:
  1245.                         consegnaMessagePrimaTrasformazione = msgRequest.getMessage();
  1246.                         consegnaResponseMessagePrimaTrasformazione = msgRequest.getResponseMessage(false, false); // secondo parametro false perchè la risposta può non esserci (es. vuota o errore di connessione) ma è stato indicato di inviare una notifica
  1247.                         break;
  1248.                     }
  1249.                 }
  1250.                 else {
  1251.                     consegnaMessagePrimaTrasformazione = msgRequest.getMessage();
  1252.                 }
  1253.                 //Devo farlo dopo aver applicato la trasformazione
  1254.                 //correctForwardPathNotifiche(transazioneApplicativoServer, consegnaMessagePrimaTrasformazione, protocolFactory);
  1255.                 if(
  1256.                         (requestInfo==null) 
  1257.                         || 
  1258.                         (requestInfoForMemoryOptimization)
  1259.                     ) {
  1260.                     Object o = consegnaMessagePrimaTrasformazione!=null ?
  1261.                             consegnaMessagePrimaTrasformazione.getContextProperty(org.openspcoop2.core.constants.Costanti.REQUEST_INFO) 
  1262.                             :
  1263.                             null;
  1264.                     if(o==null) {
  1265.                         throw new Exception("RequestInfo non presente nel contesto");
  1266.                     }
  1267.                     requestInfo = (RequestInfo) o;
  1268.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO,requestInfo);
  1269.                 }
  1270.                 if(idTransazione==null) {
  1271.                     Object o = consegnaMessagePrimaTrasformazione.getContextProperty(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1272.                     if(o==null) {
  1273.                         throw new Exception("IdTransazione non presente nel contesto");
  1274.                     }
  1275.                     idTransazione = (String) o;
  1276.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE,idTransazione);
  1277.                 }
  1278.                 
  1279.                 if(requestInfoForMemoryOptimization && _requestInfoForMemoryOptimization!=null) {
  1280.                     requestInfo.setRequestConfig(_requestInfoForMemoryOptimization.getRequestConfig());
  1281.                     requestInfo.setRequestThreadContext(_requestInfoForMemoryOptimization.getRequestThreadContext());
  1282.                     msgDiag.updateRequestInfo(requestInfo);
  1283.                 }
  1284.                 
  1285.             }catch(Exception e) {
  1286.                 msgDiag.logErroreGenerico(e, "LetturaMessaggioErrore (Recupero Dati)"); 
  1287.                 openspcoopstate.releaseResource();
  1288.                 esito.setEsitoInvocazione(false); 
  1289.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1290.                 return esito;
  1291.             }
  1292.         }
  1293.         
  1294.         RicezioneBusteExternalErrorGenerator generatoreErrorePA = null;
  1295.         try{
  1296.             generatoreErrorePA = new RicezioneBusteExternalErrorGenerator(this.log,
  1297.                     this.idModulo, requestInfo, openspcoopstate.getStatoRichiesta());
  1298.             generatoreErrorePA.updateInformazioniCooperazione(soggettoFruitore, idServizio);
  1299.             generatoreErrorePA.updateInformazioniCooperazione(servizioApplicativoFruitore);
  1300.             generatoreErrorePA.updateTipoPdD(TipoPdD.APPLICATIVA);
  1301.             ejbUtils.setGeneratoreErrorePortaApplicativa(generatoreErrorePA);
  1302.         }catch(Exception e){
  1303.             msgDiag.logErroreGenerico(e, "RicezioneBusteExternalErrorGenerator.instanziazione"); 
  1304.             openspcoopstate.releaseResource();
  1305.             esito.setEsitoInvocazione(false); 
  1306.             esito.setStatoInvocazioneErroreNonGestito(e);
  1307.             return esito;
  1308.         }

  1310.         // Oneway versione 11
  1311.         boolean oneWayVersione11 = consegnaContenutiApplicativiMsg.isOneWayVersione11();
  1312.         ejbUtils.setOneWayVersione11(oneWayVersione11);
  1313.         if(idMessaggioPreBehaviour!=null){
  1314.             ejbUtils.setOneWayVersione11(true); // per forzare l'update su db   
  1315.         }
  1316.         msgRequest.setOneWayVersione11(oneWayVersione11);







  1324.         OpenSPCoop2Message responseMessage = null;
  1325.         

  1327.         try{
  1328.             if(msgRequest.isRiconsegnaMessaggio(servizioApplicativo) == false){
  1329.                 openspcoopstate.releaseResource();
  1330.                 // Per i profili 'sincroni' dove vi e' un modulo in attesa non puo' sussistere una riconsegna del messaggio.
  1331.                 if(existsModuloInAttesaRispostaApplicativa==false){
  1332.                     msgDiag.logPersonalizzato("riconsegnaMessaggioPrematura");
  1333.                     esito.setEsitoInvocazione(false); 
  1334.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,msgDiag.getMessaggio_replaceKeywords("riconsegnaMessaggioPrematura"));
  1335.                 }else{
  1336.                     String message = null;
  1337.                     String posizione = null;
  1338.                     if( (richiestaApplicativa!=null) && Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario())){
  1339.                         message = "Messaggio eliminato durante il controllo di ri-consegna ("+servizioApplicativo+","+scenarioCooperazione+")";
  1340.                         posizione = "msgRequest.isRiconsegnaMessaggio("+servizioApplicativo+","+scenarioCooperazione+")";
  1341.                     }else{
  1342.                         message = "Messaggio eliminato durante il controllo di ri-consegna ("+servizioApplicativo+","+scenarioCooperazione+",STATELESS)";
  1343.                         posizione = "msgRequest.isRiconsegnaMessaggio("+servizioApplicativo+","+scenarioCooperazione+",STATELESS)";
  1344.                     }
  1345.                     msgDiag.logErroreGenerico(message,posizione);
  1346.                     esito.setEsitoInvocazione(true); 
  1347.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,message);
  1348.                 }
  1349.                 this.log.info(ConsegnaContenutiApplicativi.ID_MODULO + "Riconsegna messaggio prematura");

  1351.                 return esito;
  1352.             }
  1353.         }catch(Exception e){
  1354.             msgDiag.logErroreGenerico(e, "msgRequest.isRiconsegnaMessaggio("+servizioApplicativo+")");
  1355.             ejbUtils.rollbackMessage("Errore verifica riconsegna messaggio", servizioApplicativo, esito);
  1356.             openspcoopstate.releaseResource();
  1357.             esito.setEsitoInvocazione(false); 
  1358.             esito.setStatoInvocazioneErroreNonGestito(e);

  1360.             return esito;
  1361.         }

  1363.         // Funzionalita'
  1364.         ConsegnaInOrdine ordineConsegna = null;

  1366.         // Consegna da effettuare
  1367.         msgDiag.mediumDebug("Inizializzo contesto per la gestione (Consegna)...");
  1368.         ConnettoreMsg connettoreMsg = null;
  1369.         boolean consegnaPerRiferimento = false;
  1370.         boolean rispostaPerRiferimento = false;
  1371.         boolean integrationManager = false;
  1372.         ValidazioneContenutiApplicativi validazioneContenutoApplicativoApplicativo = null;
  1373.         List<Proprieta> proprietaPorta = null;
  1374.         if(Costanti.SCENARIO_CONSEGNA_CONTENUTI_APPLICATIVI.equals(scenarioCooperazione) ||
  1375.                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione) ){
  1376.             try{
  1377.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (getConsegnaRispostaAsincrona) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1378.                 connettoreMsg = configurazionePdDManager.getConsegnaRispostaAsincrona(sa,richiestaDelegata, requestInfo);
  1379.                 if(Costanti.SCENARIO_CONSEGNA_CONTENUTI_APPLICATIVI.equals(scenarioCooperazione)){
  1380.                     connettoreMsg.setCheckPresenzaHeaderPrimaSbustamento(true);
  1381.                 }
  1382.                 if(connettoreMsg!=null){
  1383.                     connettoreMsg.initPolicyGestioneToken(configurazionePdDManager, requestInfo);
  1384.                 }
  1385.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaConGetMessage) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1386.                 integrationManager = configurazionePdDManager.consegnaRispostaAsincronaConGetMessage(sa);
  1387.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (getTipoValidazioneContenutoApplicativo) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1388.                 validazioneContenutoApplicativoApplicativo = configurazionePdDManager.getTipoValidazioneContenutoApplicativo(pd,implementazionePdDMittente, false);
  1389.                 proprietaPorta = pd.getProprietaList();
  1390.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaPerRiferimento) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1391.                 consegnaPerRiferimento = configurazionePdDManager.consegnaRispostaAsincronaPerRiferimento(sa);
  1392.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaRispostaPerRiferimento) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1393.                 rispostaPerRiferimento = configurazionePdDManager.consegnaRispostaAsincronaRispostaPerRiferimento(sa);
  1394.             }catch(Exception e){
  1395.                 msgDiag.logErroreGenerico(e, "ConsegnaAsincrona.getDatiConsegna(sa:"+servizioApplicativo+")");
  1396.                 ejbUtils.rollbackMessage("[ConsegnaAsincrona] Connettore per consegna applicativa non definito:"+e.getMessage(),servizioApplicativo, esito);
  1397.                 esito.setEsitoInvocazione(false); 
  1398.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1399.                 return esito;
  1400.             }


  1403.         }
  1404.         else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(scenarioCooperazione)){
  1405.             try{
  1406.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (getConsegnaRispostaAsincrona) [AsincronoAsimmetricoPolling]...");
  1407.                 connettoreMsg = configurazionePdDManager.getConsegnaRispostaAsincrona(sa,richiestaApplicativa, requestInfo);
  1408.                 if(connettoreMsg!=null){
  1409.                     connettoreMsg.initPolicyGestioneToken(configurazionePdDManager, requestInfo);
  1410.                 }
  1411.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaConGetMessage) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1412.                 integrationManager = configurazionePdDManager.consegnaRispostaAsincronaConGetMessage(sa);
  1413.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (getTipoValidazioneContenutoApplicativo) [AsincronoAsimmetricoPolling]...");
  1414.                 validazioneContenutoApplicativoApplicativo = configurazionePdDManager.getTipoValidazioneContenutoApplicativo(pa,implementazionePdDMittente, false);
  1415.                 proprietaPorta = pa.getProprietaList();
  1416.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaPerRiferimento) [AsincronoAsimmetricoPolling]...");
  1417.                 consegnaPerRiferimento = configurazionePdDManager.consegnaRispostaAsincronaPerRiferimento(sa);
  1418.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaRispostaPerRiferimento) [AsincronoAsimmetricoPolling]...");
  1419.                 rispostaPerRiferimento = configurazionePdDManager.consegnaRispostaAsincronaRispostaPerRiferimento(sa);
  1420.             }catch(Exception e){
  1421.                 msgDiag.logErroreGenerico(e, "AsincronoSimmetricoPolling.getDatiConsegna(sa:"+servizioApplicativo+")");
  1422.                 ejbUtils.rollbackMessage("[AsincronoSimmetricoPolling] Connettore per consegna applicativa non definito:"+e.getMessage(),servizioApplicativo, esito);
  1423.                 esito.setEsitoInvocazione(false); 
  1424.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1425.                 return esito;
  1426.             }
  1427.         }else{
  1428.             try{
  1429.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (getInvocazioneServizio)...");
  1430.                 connettoreMsg = configurazionePdDManager.getInvocazioneServizio(sa,richiestaApplicativa, requestInfo);
  1431.                 if(connettoreMsg!=null){
  1432.                     connettoreMsg.initPolicyGestioneToken(configurazionePdDManager, requestInfo);
  1433.                 }
  1434.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (consegnaRispostaAsincronaConGetMessage) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  1435.                 integrationManager = configurazionePdDManager.invocazioneServizioConGetMessage(sa);
  1436.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (getTipoValidazioneContenutoApplicativo)...");
  1437.                 validazioneContenutoApplicativoApplicativo = configurazionePdDManager.getTipoValidazioneContenutoApplicativo(pa,implementazionePdDMittente, false);
  1438.                 proprietaPorta = pa.getProprietaList();
  1439.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (invocazioneServizioPerRiferimento)...");
  1440.                 consegnaPerRiferimento = configurazionePdDManager.invocazioneServizioPerRiferimento(sa);
  1441.                 msgDiag.mediumDebug("Inizializzo contesto per la gestione (invocazioneServizioRispostaPerRiferimento)...");
  1442.                 rispostaPerRiferimento = configurazionePdDManager.invocazioneServizioRispostaPerRiferimento(sa);
  1443.             }catch(Exception e){
  1444.                 msgDiag.logErroreGenerico(e, "InvocazioneServizio.getDatiConsegna(sa:"+servizioApplicativo+")");
  1445.                 ejbUtils.rollbackMessage("Connettore per consegna applicativa non definito:"+e.getMessage(),servizioApplicativo, esito);
  1446.                 esito.setEsitoInvocazione(false); 
  1447.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1448.                 return esito;
  1449.             }

  1451.         }
  1452.         msgDiag.mediumDebug("Check parametri...");
  1453.         if(connettoreMsg==null){
  1454.             msgDiag.logErroreGenerico("Connettore non definito nella configurazione (is null)", "getDatiConsegna(sa:"+servizioApplicativo+")");
  1455.             ejbUtils.rollbackMessage("Connettore per consegna applicativa non definito per il sa ["+servizioApplicativo+"]",servizioApplicativo, esito);
  1456.             esito.setEsitoInvocazione(false); 
  1457.             esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, "Connettore per consegna applicativa non definito per il sa ["+servizioApplicativo+"]");
  1458.             return esito;
  1459.         }
  1460.         connettoreMsg.setProtocolFactory(protocolFactory);
  1461.         connettoreMsg.setGestioneManifest(gestioneManifest);
  1462.         connettoreMsg.setProprietaManifestAttachments(proprietaManifestAttachments);
  1463.         connettoreMsg.setLocalForward(localForward);
  1464.         if(transazioneApplicativoServer!=null) {
  1465.             transazioneApplicativoServer.setConsegnaIntegrationManager(integrationManager);
  1466.             connettoreMsg.setTransazioneApplicativoServer(transazioneApplicativoServer);
  1467.             connettoreMsg.setIdPortaApplicativa(idPA);
  1468.             connettoreMsg.setDataConsegnaTransazioneApplicativoServer(dataConsegna);
  1469.         }
  1470.         ForwardProxy forwardProxy = null;
  1471.         if(configurazionePdDManager.isForwardProxyEnabled(requestInfo)) {
  1472.             try {
  1473.                 forwardProxy = configurazionePdDManager.getForwardProxyConfigErogazione(identitaPdD, idServizio, null, requestInfo);
  1474.             }catch(Exception e) {
  1475.                 msgDiag.logErroreGenerico(e, "Configurazione ForwardProxy (sa:"+servizioApplicativo+")");
  1476.                 ejbUtils.rollbackMessage("Configurazione del connettore errata per la funzionalità govway-proxy; sa ["+servizioApplicativo+"]",servizioApplicativo, esito);
  1477.                 esito.setEsitoInvocazione(false); 
  1478.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, "Configurazione del connettore errata per la funzionalità govway-proxy; sa ["+servizioApplicativo+"]");
  1479.                 return esito;
  1480.             }
  1481.         }
  1482.         connettoreMsg.setForwardProxy(forwardProxy);
  1483.         connettoreMsg.setIdAccordo(idAccordoServizio);

  1485.         // Identificativo di una risposta.
  1486.         String idMessageResponse = null;
  1487.         if(existsModuloInAttesaRispostaApplicativa){
  1488.             msgDiag.mediumDebug("Creazione id risposta...");
  1489.             try{
  1490.                 org.openspcoop2.protocol.engine.builder.Imbustamento imbustatore = 
  1491.                         new org.openspcoop2.protocol.engine.builder.Imbustamento(this.log,protocolFactory,openspcoopstate.getStatoRichiesta());
  1492.                 idMessageResponse = 
  1493.                     imbustatore.buildID(identitaPdD, 
  1494.                             (String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE),
  1495.                             this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  1496.                             this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  1497.                             RuoloMessaggio.RISPOSTA);
  1498.             }catch(Exception e){
  1499.                 msgDiag.logErroreGenerico(e, "imbustatore.buildID(idMessageResponse)");
  1500.                 //if(existsModuloInAttesaRispostaApplicativa) {
  1501.                 try{
  1502.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  1503.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1504.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_507_COSTRUZIONE_IDENTIFICATIVO),
  1505.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  1506.                             (consegnaMessagePrimaTrasformazione!=null ? consegnaMessagePrimaTrasformazione.getParseException() : null),
  1507.                             pddContext);
  1508.                     esito.setEsitoInvocazione(true); 
  1509.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "imbustatore.buildID(idMessageResponse)");
  1510.                 }catch(Exception sendError){
  1511.                     ejbUtils.rollbackMessage("Creazione id di risposta (sendRispostaApplicativa) fallita", esito);
  1512.                     esito.setStatoInvocazioneErroreNonGestito(sendError);
  1513.                     esito.setEsitoInvocazione(false);
  1514.                 }
  1515.                 //}else{
  1516.                 //  ejbUtils.rollbackMessage("Creazione id di risposta fallita", esito);
  1517.                 //  esito.setStatoInvocazioneErroreNonGestito(e);
  1518.                 //  esito.setEsitoInvocazione(false);
  1519.                 //}
  1520.                 openspcoopstate.releaseResource();

  1522.                 return esito;
  1523.             }

  1525.             // Aggiornamento Informazioni
  1526.             msgDiag.setIdMessaggioRisposta(idMessageResponse);
  1527.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, idMessageResponse);

  1529.         }


  1532.         msgDiag.mediumDebug("Inizializzo contesto per la gestione (Risposta)...");

  1534.         //  Modalita' gestione risposta (Sincrona/Fault/Ricevute...)
  1535.         // Per i profili diversi dal sincrono e' possibile impostare dove far ritornare l'errore
  1536.         boolean newConnectionForResponse = false; 
  1537.         if(Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione)){
  1538.             if( (consegnaContenutiApplicativiMsg.isStateless()==false) &&  (!existsModuloInAttesaRispostaApplicativa) ){
  1539.                 newConnectionForResponse = configurazionePdDManager.newConnectionForResponse();
  1540.             }
  1541.         }else if( (ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())==false) &&
  1542.                 (consegnaContenutiApplicativiMsg.isStateless()==false) ){
  1543.             newConnectionForResponse = configurazionePdDManager.newConnectionForResponse();
  1544.         }
  1545.         ejbUtils.setReplyOnNewConnection(newConnectionForResponse);


  1548.         // Gestione indirizzo telematico
  1549.         boolean gestioneIndirizzoTelematico = false;
  1550.         if(consegnaContenutiApplicativiMsg.isStateless()==false){
  1551.             gestioneIndirizzoTelematico = configurazionePdDManager.isUtilizzoIndirizzoTelematico();
  1552.         }
  1553.         ejbUtils.setUtilizzoIndirizzoTelematico(gestioneIndirizzoTelematico);

  1555.         IProtocolVersionManager protocolManager = null;
  1556.         boolean isBlockedTransaction_responseMessageWithTransportCodeError = false;
  1557.         try{
  1558.             protocolManager = protocolFactory.createProtocolVersionManager(profiloGestione);
  1559.             isBlockedTransaction_responseMessageWithTransportCodeError = 
  1560.                     protocolManager.isBlockedTransaction_responseMessageWithTransportCodeError();
  1561.         }catch(Exception e){
  1562.             msgDiag.logErroreGenerico(e, "ProtocolFactory.createProtocolManager("+profiloGestione+")");
  1563.             ejbUtils.rollbackMessage("ProtocolFactory.createProtocolManager("+profiloGestione+"):"+e.getMessage(),servizioApplicativo, esito);
  1564.             esito.setEsitoInvocazione(false); 
  1565.             esito.setStatoInvocazioneErroreNonGestito(e);
  1566.             return esito;
  1567.         }
  1568.         boolean consegnaInOrdine = false;
  1569.         // Sequenza: deve essere abilitata la consegna affidabile + la collaborazione e infine la consegna in ordine e non deve essere richiesto il profilo linee guida 1.0
  1570.         Busta bustaIndicazioneConsegnaInOrdine = null;
  1571.         if(Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione)){
  1572.             
  1573.             if(bustaRichiesta!=null) {
  1574.                 bustaIndicazioneConsegnaInOrdine = bustaRichiesta.newInstance();
  1575.             }
  1576.             else {
  1577.                 bustaIndicazioneConsegnaInOrdine = new Busta(protocolFactory.getProtocol());
  1578.             }
  1579.             bustaIndicazioneConsegnaInOrdine.setProfiloDiCollaborazione(profiloCollaborazione);
  1580.             
  1581.             switch (protocolManager.getConsegnaInOrdine(bustaIndicazioneConsegnaInOrdine)) {
  1582.             case ABILITATA:
  1583.                 consegnaInOrdine = true;
  1584.                 break;
  1585.             case DISABILITATA:
  1586.                 consegnaInOrdine = false;
  1587.                 break;
  1588.             default:
  1589.                 boolean gestioneConsegnaInOrdineAbilitata =  this.propertiesReader.isGestioneRiscontri(implementazionePdDMittente) && 
  1590.                 this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente) && 
  1591.                 this.propertiesReader.isGestioneConsegnaInOrdine(implementazionePdDMittente);   
  1592.                 consegnaInOrdine = gestioneConsegnaInOrdineAbilitata &&
  1593.                         bustaRichiesta!=null && bustaRichiesta.getSequenza()!=-1;
  1594.                 break;
  1595.             }
  1596.         }


  1599.         

  1601.         // Punto di inizio per la transazione.
  1602.         IConnettore connectorSenderForDisconnect = null;
  1603.         String location = "";
  1604.         OpenSPCoop2Message consegnaMessageTrasformato = null;
  1605.         long responseContentLength = -1;
  1606.         boolean useResponseForParseException = false;
  1607.         try{        


  1610.             /* ---------------- Check per consegna in ordine ----------------*/
  1611.             if(consegnaInOrdine){
  1612.                 if(oneWayVersione11 || openspcoopstate instanceof OpenSPCoopStateful){
  1613.                     msgDiag.mediumDebug("Controllo consegna in ordine...");
  1614.                     try{
  1615.                         ordineConsegna = new ConsegnaInOrdine(openspcoopstate.getStatoRichiesta(),protocolFactory);
  1616.                         if(ordineConsegna.isConsegnaInOrdine(bustaRichiesta, 
  1617.                                 this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  1618.                                 this.propertiesReader.getGestioneSerializableDBCheckInterval()) == false){
  1619.                             // congelamento busta
  1620.                             msgDiag.addKeyword(CostantiPdD.KEY_SEQUENZA_ATTESA, ordineConsegna.getSequenzaAttesa()+"");
  1621.                             if(ordineConsegna.getSequenzaAttesa()>bustaRichiesta.getSequenza()){
  1622.                                 msgDiag.logPersonalizzato("consegnaInOrdine.messaggioGiaConsegnato");
  1623.                                 ejbUtils.releaseInboxMessage(true);
  1624.                                 esito.setEsitoInvocazione(true); 
  1625.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, 
  1626.                                         msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.messaggioGiaConsegnato"));
  1627.                             }else{
  1628.                                 msgDiag.logPersonalizzato("consegnaInOrdine.messaggioFuoriOrdine");
  1629.                                 ejbUtils.rollbackMessage(msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.messaggioFuoriOrdine"), servizioApplicativo, esito);
  1630.                                 esito.setEsitoInvocazione(false);
  1631.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, 
  1632.                                         msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.messaggioFuoriOrdine"));
  1633.                             }
  1634.                             openspcoopstate.releaseResource();
  1635.                             return esito;
  1636.                         }
  1637.                     }catch(Exception e){
  1638.                         this.log.error("Riscontrato errore durante la gestione della sequenza per la consegna in ordine",e);
  1639.                         msgDiag.logErroreGenerico(e, "GetioneSequenzaInOrdine");
  1640.                         ejbUtils.rollbackMessage("Errore verifica consegna in ordine: "+e.getMessage(), servizioApplicativo, esito);
  1641.                         openspcoopstate.releaseResource();
  1642.                         esito.setEsitoInvocazione(false); 
  1643.                         esito.setStatoInvocazioneErroreNonGestito(e);
  1644.                         return esito;
  1645.                     }
  1646.                 }
  1647.             }





  1653.             /* ------------  Ricostruzione Messaggio Soap da spedire ------------- */
  1654.             msgDiag.mediumDebug("Ricostruzione SOAPEnvelope di richiesta/consegna..."); 
  1655.             try{
  1656.                 if(consegnaMessagePrimaTrasformazione==null) {
  1657.                     if(consegnaPerRiferimento==false){
  1658.                         if(tipoMessaggioDaNotificare_notificaAsincrona!=null) {
  1659.                             switch (tipoMessaggioDaNotificare_notificaAsincrona) {
  1660.                             case RICHIESTA:
  1661.                                 consegnaMessagePrimaTrasformazione = msgRequest.getMessage();
  1662.                                 break;
  1663.                             case RISPOSTA:
  1664.                                 consegnaMessagePrimaTrasformazione = msgRequest.getResponseMessage(true, true);  //se deve essere consegnata solamente la risposta, questa deve esistere
  1665.                                 break;
  1666.                             case ENTRAMBI:
  1667.                                 consegnaMessagePrimaTrasformazione = msgRequest.getMessage();
  1668.                                 consegnaResponseMessagePrimaTrasformazione = msgRequest.getResponseMessage(false, false); // secondo parametro false perchè la risposta può non esserci (es. vuota o errore di connessione) ma è stato indicato di inviare una notifica
  1669.                                 break;
  1670.                             }
  1671.                         }
  1672.                         else {
  1673.                             consegnaMessagePrimaTrasformazione = msgRequest.getMessage();
  1674.                         }
  1675.                         //Devo farlo dopo aver applicato la trasformazione
  1676.                         //correctForwardPathNotifiche(transazioneApplicativoServer, consegnaMessagePrimaTrasformazione, protocolFactory);
  1677.                     }else{
  1678.                         // consegnaMessage deve contenere il messaggio necessario all'invocazione del metodo pubblicaEvento
  1679.                         consegnaMessagePrimaTrasformazione = 
  1680.                             msgRequest.buildRichiestaPubblicazioneMessaggio_RepositoryMessaggi(soggettoFruitore, tipoServizio,servizio,azione);
  1681.                     }
  1682.                 }
  1683.             }catch(Exception e){
  1684.                 msgDiag.logErroreGenerico(e, "msgRequest.getMessage()");

  1686.                 if(existsModuloInAttesaRispostaApplicativa) {
  1687.                     
  1688.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  1689.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1690.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_509_READ_REQUEST_MSG),
  1691.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  1692.                             (consegnaMessagePrimaTrasformazione!=null ? consegnaMessagePrimaTrasformazione.getParseException() : null),
  1693.                             pddContext);
  1694.                     
  1695.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "msgRequest.getMessage()");
  1696.                     esito.setEsitoInvocazione(true);
  1697.                 }else{
  1698.                     ejbUtils.rollbackMessage("Ricostruzione del messaggio Soap da Spedire non riuscita.",servizioApplicativo, esito);
  1699.                     esito.setStatoInvocazioneErroreNonGestito(e);
  1700.                     esito.setEsitoInvocazione(false);
  1701.                 }
  1702.                 openspcoopstate.releaseResource();

  1704.                 return esito;
  1705.             }



  1709.             /* -----  Header Integrazione ------ */
  1710.             String originalID = bustaRichiesta!=null ? bustaRichiesta.getID() : null;
  1711.             if(idMessaggioPreBehaviour!=null){
  1712.                 bustaRichiesta.setID(idMessaggioPreBehaviour);
  1713.             }
  1714.             msgDiag.mediumDebug("Gestione header di integrazione per la richiesta...");
  1715.             HeaderIntegrazione headerIntegrazione = new HeaderIntegrazione(idTransazione);
  1716.             if(soggettoFruitoreHeaderIntegrazione!=null){
  1717.                 headerIntegrazione.getBusta().setTipoMittente(soggettoFruitoreHeaderIntegrazione.getTipo());
  1718.                 headerIntegrazione.getBusta().setMittente(soggettoFruitoreHeaderIntegrazione.getNome());
  1719.             }else if(soggettoFruitore!=null){
  1720.                 headerIntegrazione.getBusta().setTipoMittente(soggettoFruitore.getTipo());
  1721.                 headerIntegrazione.getBusta().setMittente(soggettoFruitore.getNome());
  1722.             }
  1723.             if(servizioHeaderIntegrazione!=null){
  1724.                 headerIntegrazione.getBusta().setTipoDestinatario(servizioHeaderIntegrazione.getSoggettoErogatore().getTipo());
  1725.                 headerIntegrazione.getBusta().setDestinatario(servizioHeaderIntegrazione.getSoggettoErogatore().getNome());
  1726.                 headerIntegrazione.getBusta().setTipoServizio(servizioHeaderIntegrazione.getTipo());
  1727.                 headerIntegrazione.getBusta().setServizio(servizioHeaderIntegrazione.getNome());
  1728.                 headerIntegrazione.getBusta().setVersioneServizio(servizioHeaderIntegrazione.getVersione());
  1729.                 headerIntegrazione.getBusta().setAzione(servizioHeaderIntegrazione.getAzione());
  1730.             }else{
  1731.                 headerIntegrazione.getBusta().setTipoDestinatario(idServizio.getSoggettoErogatore().getTipo());
  1732.                 headerIntegrazione.getBusta().setDestinatario(idServizio.getSoggettoErogatore().getNome());
  1733.                 headerIntegrazione.getBusta().setTipoServizio(idServizio.getTipo());
  1734.                 headerIntegrazione.getBusta().setServizio(idServizio.getNome());
  1735.                 headerIntegrazione.getBusta().setVersioneServizio(idServizio.getVersione());
  1736.                 headerIntegrazione.getBusta().setAzione(idServizio.getAzione());
  1737.             }
  1738.             if(bustaRichiesta!=null) {
  1739.                 headerIntegrazione.getBusta().setID(bustaRichiesta.getID());
  1740.                 headerIntegrazione.getBusta().setRiferimentoMessaggio(bustaRichiesta.getRiferimentoMessaggio());
  1741.                 headerIntegrazione.getBusta().setIdCollaborazione(bustaRichiesta.getCollaborazione());
  1742.                 headerIntegrazione.getBusta().setProfiloDiCollaborazione(bustaRichiesta.getProfiloDiCollaborazione());
  1743.             }
  1744.             headerIntegrazione.setIdApplicativo(idCorrelazioneApplicativa);
  1745.             headerIntegrazione.setServizioApplicativo(servizioApplicativoFruitore);
  1746.             if(servizioApplicativoToken!=null) {
  1747.                 headerIntegrazione.setServizioApplicativoToken(servizioApplicativoToken.getNome());
  1748.                 if(servizioApplicativoToken.getIdSoggettoProprietario()!=null) {
  1749.                     headerIntegrazione.setTipoSoggettoProprietarioApplicativoToken(servizioApplicativoToken.getIdSoggettoProprietario().getTipo());
  1750.                     headerIntegrazione.setNomeSoggettoProprietarioApplicativoToken(servizioApplicativoToken.getIdSoggettoProprietario().getNome());
  1751.                 }
  1752.                 if(servizioApplicativoFruitore==null && richiestaApplicativa!=null && Costanti.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
  1753.                     // inserisco come servizioApplicativoFruitore la stessa informazione del token. Sono lo stesso
  1754.                     headerIntegrazione.setServizioApplicativo(servizioApplicativoToken.getNome());
  1755.                 }
  1756.             }

  1758.             Map<String, List<String>> propertiesTrasporto = new HashMap<>();
  1759.             Map<String, List<String>> propertiesUrlBased = new HashMap<>();

  1761.             if(tipiIntegrazione==null){
  1762.                 if(ConsegnaContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePA.containsKey(protocolFactory.getProtocol())){
  1763.                     tipiIntegrazione = ConsegnaContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePA.get(protocolFactory.getProtocol());
  1764.                 }else{
  1765.                     tipiIntegrazione = ConsegnaContenutiApplicativi.defaultGestoriIntegrazionePA;
  1766.                 }
  1767.             }
  1768.             
  1769.             OutRequestPAMessage outRequestPAMessage = new OutRequestPAMessage();
  1770.             outRequestPAMessage.setBustaRichiesta(bustaRichiesta);
  1771.             outRequestPAMessage.setMessage(consegnaMessagePrimaTrasformazione);
  1772.             if(pa!=null)
  1773.                 outRequestPAMessage.setPortaApplicativa(pa);
  1774.             else
  1775.                 outRequestPAMessage.setPortaDelegata(pd);
  1776.             outRequestPAMessage.setHeaders(propertiesTrasporto);
  1777.             outRequestPAMessage.setParameters(propertiesUrlBased);
  1778.             if(servizioHeaderIntegrazione!=null){
  1779.                 outRequestPAMessage.setServizio(servizioHeaderIntegrazione);
  1780.             }else{
  1781.                 outRequestPAMessage.setServizio(idServizio);
  1782.             }
  1783.             if(soggettoFruitoreHeaderIntegrazione!=null){
  1784.                 outRequestPAMessage.setSoggettoMittente(soggettoFruitoreHeaderIntegrazione);
  1785.             }else{
  1786.                 outRequestPAMessage.setSoggettoMittente(soggettoFruitore);
  1787.             }
  1788.             for(int i=0; i<tipiIntegrazione.length;i++){
  1789.                 try{
  1790.                     IGestoreIntegrazionePA gestore = null;
  1791.                     try{
  1792.                         gestore = (IGestoreIntegrazionePA) this.pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazione[i]);
  1793.                     }catch(Exception e){
  1794.                         throw e;
  1795.                     }
  1796.                     if(gestore!=null){
  1797.                         String classType = null;
  1798.                         try {
  1799.                             classType = gestore.getClass().getName();
  1800.                             AbstractCore.init(gestore, pddContext, protocolFactory);
  1801.                         }catch(Exception e){
  1802.                             throw new Exception("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  1803.                                     "] da utilizzare per la gestione dell'integrazione delle erogazione di tipo ["+tipiIntegrazione[i]+"]: "+e.getMessage());
  1804.                         }
  1805.                         if(gestore instanceof IGestoreIntegrazionePASoap){
  1806.                             if(this.propertiesReader.processHeaderIntegrazionePARequest(false)){
  1807.                                 if(this.propertiesReader.deleteHeaderIntegrazioneRequestPA()){
  1808.                                     gestore.setOutRequestHeader(headerIntegrazione,outRequestPAMessage);
  1809.                                 }
  1810.                                 else{
  1811.                                     // gia effettuato l'update dell'header in RicezioneBuste
  1812.                                 }
  1813.                             }else{
  1814.                                 gestore.setOutRequestHeader(headerIntegrazione,outRequestPAMessage);
  1815.                             }
  1816.                         }else{
  1817.                             gestore.setOutRequestHeader(headerIntegrazione,outRequestPAMessage);
  1818.                         }
  1819.                     }else{
  1820.                         throw new Exception("Gestore non inizializzato");
  1821.                     }

  1823.                 }catch(Exception e){
  1824.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazione[i]);
  1825.                     msgDiag.addKeywordErroreProcessamento(e);
  1826.                     msgDiag.logPersonalizzato("headerIntegrazione.creazioneFallita");
  1827.                     this.log.error(msgDiag.getMessaggio_replaceKeywords("headerIntegrazione.creazioneFallita"), e);
  1828.                 }
  1829.             }






  1836.             
  1837.             
  1838.             
  1839.             
  1840.             
  1841.             
  1842.             /* ------------ Trasformazione Richiesta  -------------- */
  1843.             
  1844.             GestoreTrasformazioni gestoreTrasformazioni = null;
  1845.             consegnaMessageTrasformato = consegnaMessagePrimaTrasformazione;
  1846.             if(trasformazioni!=null) {
  1847.                 try {
  1848.                     if(richiestaApplicativa!=null && !localForward){
  1849.                         gestoreTrasformazioni = new GestoreTrasformazioni(this.log, msgDiag, idServizio, soggettoFruitore, servizioApplicativoFruitore, 
  1850.                                 trasformazioni, transactionNullable, pddContext, requestInfo, tipoPdD,
  1851.                                 generatoreErrorePA,
  1852.                                 configurazionePdDManager,
  1853.                                 idPA);
  1854.                     }
  1855.                     else {
  1856.                         gestoreTrasformazioni = new GestoreTrasformazioni(this.log, msgDiag, idServizio, soggettoFruitore, servizioApplicativoFruitore, 
  1857.                                 trasformazioni, transactionNullable, pddContext, requestInfo, tipoPdD,
  1858.                                 generatoreErrorePA,
  1859.                                 configurazionePdDManager,
  1860.                                 idPD);
  1861.                     }
  1862.                     if(transazioneApplicativoServer!=null) {
  1863.                         gestoreTrasformazioni.setNomeConnettore(nomeConnettoreMultiplo);
  1864.                         gestoreTrasformazioni.setNomeServizioApplicativoErogatore(nomeServizioApplicativoErogatoreConnettoreMultiplo);
  1865.                     }
  1866.                     else {
  1867.                         gestoreTrasformazioni.setNomeConnettore(nomeConnettoreAPIImplementation);
  1868.                         gestoreTrasformazioni.setNomeServizioApplicativoErogatore(nomeServizioApplicativoErogatoreAPIImplementation);
  1869.                     }
  1870.                     if(tipoMessaggioDaNotificare_notificaAsincrona!=null) {
  1871.                         consegnaMessageTrasformato = gestoreTrasformazioni.trasformazioneNotifica(consegnaMessagePrimaTrasformazione, bustaRichiesta,
  1872.                                 tipoMessaggioDaNotificare_notificaAsincrona, consegnaResponseMessagePrimaTrasformazione, notificaTransactionContext);
  1873.                         if(!gestoreTrasformazioni.isTrasformazioneContenutoRichiestaEffettuata() && consegnaResponseMessagePrimaTrasformazione!=null) {
  1874.                             // si entra in questo caso solo se è stato scelto ENTRAMBI e una trasformazione non ha modificato il messaggio
  1875.                             consegnaMessageTrasformato = GestoreTrasformazioniUtilities.buildRequestResponseArchive(this.log, consegnaMessagePrimaTrasformazione, consegnaResponseMessagePrimaTrasformazione, 
  1876.                                     this.propertiesReader.getNotificaRichiestaRisposta_consegnaContenutiApplicativi_archiveType());
  1877.                         }
  1878.                     }
  1879.                     else {
  1880.                         consegnaMessageTrasformato = gestoreTrasformazioni.trasformazioneRichiesta(consegnaMessagePrimaTrasformazione, bustaRichiesta);
  1881.                     }
  1882.                 }
  1883.                 catch(GestoreTrasformazioniException e) {
  1884.                     
  1885.                     msgDiag.addKeywordErroreProcessamento(e);
  1886.                     msgDiag.logPersonalizzato( tipoMessaggioDaNotificare_notificaAsincrona!=null ? "trasformazione.processamentoNotificaInErrore" : "trasformazione.processamentoRichiestaInErrore");
  1887.                     
  1888.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_TRASFORMAZIONE_RICHIESTA, "true");
  1889.                     
  1890.                     ErroreIntegrazione erroreIntegrazione = gestoreTrasformazioni.getErrore();
  1891.                     if(erroreIntegrazione==null) {
  1892.                         erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1893.                                 get5XX_ErroreProcessamento(e,CodiceErroreIntegrazione.CODICE_562_TRASFORMAZIONE);
  1894.                     }
  1895.                     
  1896.                     String msgErrore = e.getMessage();                  
  1897.                     if(existsModuloInAttesaRispostaApplicativa) {
  1898.                         IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.TRANSFORMATION_RULE_REQUEST_FAILED;
  1899.                         if(e.getOp2IntegrationFunctionError()!=null) {
  1900.                             integrationFunctionError = e.getOp2IntegrationFunctionError();
  1901.                         }
  1902.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  1903.                         if(localForwardEngine!=null) {
  1904.                             localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  1905.                         }
  1906.                         if(e.getOpenSPCoop2ErrorMessage()!=null) {
  1907.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  1908.                                     e.getOpenSPCoop2ErrorMessage(), msgErrore,
  1909.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore);
  1910.                         }
  1911.                         else {
  1912.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  1913.                                     erroreIntegrazione,
  1914.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  1915.                                     (consegnaMessagePrimaTrasformazione!=null ? consegnaMessagePrimaTrasformazione.getParseException() : null),
  1916.                                     pddContext);
  1917.                         }
  1918.                         esito.setEsitoInvocazione(true); 
  1919.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  1920.                     }else{
  1921.                         ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  1922.                         esito.setEsitoInvocazione(false); 
  1923.                         esito.setStatoInvocazioneErroreNonGestito(e);
  1924.                     }
  1925.                     openspcoopstate.releaseResource();
  1926.                     return esito;
  1927.                 }       
  1928.             }   
  1929.             
  1930.             
  1931.             
  1932.             
  1933.             
  1934.             
  1935.             
  1936.             
  1937.             
  1938.             
  1939.             





  1945.             /* ------------------- Definizione connettoreMsg -----------------------*/
  1946.                         
  1947.             // mapping in valori delle keyword delle proprieta di trasporto protocol-properties.
  1948.             msgDiag.mediumDebug("Impostazione messaggio del connettore...");
  1949.             mappingProtocolProperties(connettoreMsg.getPropertiesTrasporto(), propertiesTrasporto, 
  1950.                     soggettoFruitoreHeaderIntegrazione, servizioHeaderIntegrazione, soggettoFruitore, idServizio, bustaRichiesta, idCorrelazioneApplicativa);
  1951.             mappingProtocolProperties(connettoreMsg.getPropertiesUrlBased(), propertiesUrlBased, 
  1952.                     soggettoFruitoreHeaderIntegrazione, servizioHeaderIntegrazione, soggettoFruitore, idServizio, bustaRichiesta, idCorrelazioneApplicativa);

  1954.             // definizione connettore
  1955.             connettoreMsg.setRequestMessage(consegnaMessageTrasformato);
  1956.             connettoreMsg.setIdModulo(ConsegnaContenutiApplicativi.ID_MODULO);
  1957.             connettoreMsg.setPropertiesTrasporto(propertiesTrasporto);
  1958.             connettoreMsg.setPropertiesUrlBased(propertiesUrlBased);
  1959.             connettoreMsg.setBusta(bustaRichiesta);
  1960.             connettoreMsg.setMsgDiagnostico(msgDiag);
  1961.             connettoreMsg.setState(openspcoopstate.getStatoRichiesta());
  1962.             if(consegnaMessagePrimaTrasformazione!=null && consegnaMessagePrimaTrasformazione.getTransportRequestContext()!=null) {
  1963.                 connettoreMsg.setUrlInvocazionePorta(consegnaMessagePrimaTrasformazione.getTransportRequestContext().getUrlInvocazione_formBased());
  1964.             }

  1966.             if(bustaRichiesta!=null) {
  1967.                 bustaRichiesta.setID(originalID);
  1968.             }









  1978.             /* ------------------- Preparo Spedizione -----------------------*/
  1979.             msgDiag.mediumDebug("Inizializzazione connettore per la spedizione...");
  1980.             //  Connettore per consegna
  1981.             String tipoConnector = connettoreMsg.getTipoConnettore();
  1982.             if (pddContext.getObject(CostantiPdD.KEY_OVERRIDE_CONNETTORE) != null) {
  1983.                 tipoConnector = pddContext.get(CostantiPdD.KEY_OVERRIDE_CONNETTORE).toString();
  1984.             }
  1985.             
  1986.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_CONNETTORE, tipoConnector);
  1987.             IConnettore connectorSender = null;

  1989.             // mapping per forward token
  1990.             TokenForward tokenForward = null;
  1991.             Object oTokenForward = consegnaMessageTrasformato.getContextProperty(org.openspcoop2.pdd.core.token.Costanti.MSG_CONTEXT_TOKEN_FORWARD);
  1992.             if(oTokenForward!=null) {
  1993.                 tokenForward = (TokenForward) oTokenForward;
  1994.             }
  1995.             if(tokenForward!=null) {
  1996.                 /**Vengono inviati header doppi se non iniziano con GovWay-
  1997.                 if(tokenForward.getTrasporto()!=null && tokenForward.getTrasporto().size()>0) {
  1998.                     propertiesTrasporto.putAll(tokenForward.getTrasporto());
  1999.                 }
  2000.                 if(tokenForward.getUrl()!=null && tokenForward.getUrl().size()>0) {
  2001.                     propertiesUrlBased.putAll(tokenForward.getUrl());
  2002.                 }*/
  2003.                 tokenForward.add(consegnaMessageTrasformato);
  2004.             }
  2005.             
  2006.             // Risposte del connettore
  2007.             int codiceRitornato = -1;
  2008.             TransportResponseContext transportResponseContext = null;

  2010.             // Stato consegna tramite connettore
  2011.             boolean errorConsegna = false;
  2012.             boolean riconsegna = false;
  2013.             java.sql.Timestamp dataRiconsegna = null;
  2014.             String motivoErroreConsegna = null;
  2015.             boolean invokerNonSupportato = false;
  2016.             SOAPFault soapFault = null;
  2017.             ProblemRFC7807 restProblem = null;
  2018.             OpenSPCoop2MessageFactory faultMessageFactory = null;
  2019.             Exception eccezioneProcessamentoConnettore = null;

  2021.             // Carico connettore richiesto
  2022.             String connectorClass = null;
  2023.             Exception eInvokerNonSupportato = null;
  2024.             if(invokerNonSupportato==false){
  2025.                 try{
  2026.                     connectorSender = (IConnettore) this.pluginLoader.newConnettore(tipoConnector);
  2027.                 }
  2028.                 catch(Exception e){
  2029.                     msgDiag.logErroreGenerico(e,"Inizializzazione Connettore"); // l'errore contiene gia tutte le informazioni
  2030.                     invokerNonSupportato = true;
  2031.                     eInvokerNonSupportato = e;
  2032.                 }
  2033.                 if(connectorSender!=null) {
  2034.                     try {
  2035.                         connectorClass = connectorSender.getClass().getName();
  2036.                         AbstractCore.init(connectorSender, pddContext, protocolFactory);
  2037.                     }catch(Exception e){
  2038.                         msgDiag.logErroreGenerico(e,"IConnettore.newInstance(tipo:"+tipoConnector+" class:"+connectorClass+")");
  2039.                         invokerNonSupportato = true;
  2040.                         eInvokerNonSupportato = e;
  2041.                     }
  2042.                 }
  2043.                 if( (invokerNonSupportato == false) && (connectorSender == null)){
  2044.                     msgDiag.logErroreGenerico("ConnectorSender is null","IConnettore.newInstance(tipo:"+tipoConnector+" class:"+connectorClass+")");
  2045.                     invokerNonSupportato = true;
  2046.                 }
  2047.             }
  2048.             
  2049.             // correggo eventuali contesti e parametri della url nel caso di consegna di una notifica
  2050.             try {
  2051.                 correctForwardPathNotifiche(transazioneApplicativoServer, consegnaMessageTrasformato, protocolFactory);
  2052.             }catch(Exception e){
  2053.                 msgDiag.logErroreGenerico(e,"ConnettoreBaseHTTP.correctForwardPathNotifiche");
  2054.                 invokerNonSupportato = true;
  2055.                 eInvokerNonSupportato = e;
  2056.             }
  2057.             
  2058.             // Imposto tipo di richiesta
  2059.             HttpRequestMethod httpRequestMethod = null;
  2060.             if(connectorSender!=null){
  2061.                 try{
  2062.                     if(connectorSender instanceof ConnettoreBaseHTTP){
  2063.                         ConnettoreBaseHTTP baseHttp = (ConnettoreBaseHTTP) connectorSender;
  2064.                         
  2065.                         if(metodoHttpDaNotificare_notificaAsincrona!=null) {
  2066.                             baseHttp.setForceHttpMethod(metodoHttpDaNotificare_notificaAsincrona);
  2067.                         }
  2068.                         
  2069.                         baseHttp.setHttpMethod(consegnaMessageTrasformato);
  2070.                         
  2071.                         if(ServiceBinding.REST.equals(consegnaMessageTrasformato.getServiceBinding())){
  2072.                             httpRequestMethod = baseHttp.getHttpMethod();
  2073.                         }
  2074.                     }
  2075.                 }catch(Exception e){
  2076.                     msgDiag.logErroreGenerico(e,"ConnettoreBaseHTTP.setHttpMethod(tipo:"+tipoConnector+" class:"+connectorClass+")");
  2077.                     invokerNonSupportato = true;
  2078.                     eInvokerNonSupportato = e;
  2079.                 }
  2080.             }

  2082.             // Location
  2083.             location = ConnettoreUtils.getAndReplaceLocationWithBustaValues(connectorSender, connettoreMsg, bustaRichiesta, pddContext, protocolFactory,  this.log);
  2084.             if(location!=null){
  2085.                 String locationWithUrl = ConnettoreUtils.buildLocationWithURLBasedParameter(this.log, consegnaMessageTrasformato, connettoreMsg.getTipoConnettore(), connettoreMsg.getPropertiesUrlBased(), location,
  2086.                         protocolFactory, this.idModulo);
  2087.                 locationWithUrl = ConnettoreUtils.addProxyInfoToLocationForHTTPConnector(connettoreMsg.getTipoConnettore(), connettoreMsg.getConnectorProperties(), locationWithUrl);
  2088.                 locationWithUrl = ConnettoreUtils.addGovWayProxyInfoToLocationForHTTPConnector(connettoreMsg.getForwardProxy(),connectorSender, locationWithUrl);
  2089.                 msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, ConnettoreUtils.formatLocation(httpRequestMethod, locationWithUrl));
  2090.                 
  2091.                 pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_METHOD, httpRequestMethod);
  2092.                 pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_URL, locationWithUrl);
  2093.             }
  2094.             else{
  2095.                 msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, "N.D.");
  2096.             }

  2098.             // timeout di default
  2099.             if(connettoreMsg.getConnectorProperties()==null){
  2100.                 java.util.Map<String,String> propCon = new java.util.HashMap<>();
  2101.                 connettoreMsg.setConnectorProperties(propCon);
  2102.             }
  2103.             if(connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)==null ||
  2104.                     connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)==null){
  2105.                 DatiTempiRisposta datiTempiRisposta = ConnettoreUtilities.readDatiGlobaliTimeout(configurazionePdDManager, TipoPdD.APPLICATIVA, requestInfo, this.propertiesReader);
  2106.                 if(connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)==null){
  2107.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT,
  2108.                             "" + ((datiTempiRisposta!=null && datiTempiRisposta.getConnectionTimeout()!=null) ? datiTempiRisposta.getConnectionTimeout().intValue() : this.propertiesReader.getConnectionTimeout_consegnaContenutiApplicativi()));
  2109.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT_GLOBALE, "true" );
  2110.                 }
  2111.                 if(connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)==null){
  2112.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT,
  2113.                             "" + ((datiTempiRisposta!=null && datiTempiRisposta.getReadConnectionTimeout()!=null) ? datiTempiRisposta.getReadConnectionTimeout().intValue() : this.propertiesReader.getReadConnectionTimeout_consegnaContenutiApplicativi()));
  2114.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE, "true" );
  2115.                 }
  2116.             }

  2118.             // behaviourForwardToConfiguration
  2119.             if(behaviourForwardToConfiguration!=null){
  2120.                 if(behaviourForwardToConfiguration.getSbustamentoInformazioniProtocollo()!=null){
  2121.                     if(org.openspcoop2.pdd.core.behaviour.StatoFunzionalita.ABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoInformazioniProtocollo())){
  2122.                         connettoreMsg.setSbustamentoInformazioniProtocollo(true);
  2123.                     }
  2124.                     else if(org.openspcoop2.pdd.core.behaviour.StatoFunzionalita.DISABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoInformazioniProtocollo())){
  2125.                         connettoreMsg.setSbustamentoInformazioniProtocollo(false);
  2126.                     }
  2127.                 }
  2128.                 if(behaviourForwardToConfiguration.getSbustamentoSoap()!=null){
  2129.                     if(org.openspcoop2.pdd.core.behaviour.StatoFunzionalita.ABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoSoap())){
  2130.                         connettoreMsg.setSbustamentoSOAP(true);
  2131.                     }
  2132.                     else if(org.openspcoop2.pdd.core.behaviour.StatoFunzionalita.DISABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoSoap())){
  2133.                         connettoreMsg.setSbustamentoSOAP(false);
  2134.                     }
  2135.                 }
  2136.             }
  2137.             
  2138.             // GestioneErrore
  2139.             GestioneErrore gestioneConsegnaConnettore = null;
  2140.             if(gestioneErroreBehaviour!=null) {
  2141.                 gestioneConsegnaConnettore = gestioneErroreBehaviour;
  2142.             }
  2143.             else {
  2144.                 if(Costanti.SCENARIO_CONSEGNA_CONTENUTI_APPLICATIVI.equals(scenarioCooperazione) ||
  2145.                         Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione) ){
  2146.                     try{
  2147.                         msgDiag.mediumDebug("Inizializzo contesto per la gestione (getGestioneErroreConnettoreRispostaAsincrona) [ConsegnaContenuti/AsincronoSimmetricoRisposta]...");
  2148.                         gestioneConsegnaConnettore = configurazionePdDManager.getGestioneErroreConnettoreRispostaAsincrona(protocolFactory, consegnaMessageTrasformato.getServiceBinding(), sa);
  2149.                     }catch(Exception e){
  2150.                         msgDiag.logErroreGenerico(e, "ConsegnaAsincrona.getDatiConsegna(sa:"+servizioApplicativo+")");
  2151.                         ejbUtils.rollbackMessage("[ConsegnaAsincrona] Connettore per consegna applicativa non definito:"+e.getMessage(),servizioApplicativo, esito);
  2152.                         esito.setEsitoInvocazione(false); 
  2153.                         esito.setStatoInvocazioneErroreNonGestito(e);
  2154.                         return esito;
  2155.                     }
  2156.     
  2157.     
  2158.                 }
  2159.                 else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(scenarioCooperazione)){
  2160.                     try{
  2161.                         msgDiag.mediumDebug("Inizializzo contesto per la gestione (getGestioneErroreConnettoreRispostaAsincrona) [AsincronoAsimmetricoPolling]...");
  2162.                         gestioneConsegnaConnettore = configurazionePdDManager.getGestioneErroreConnettoreRispostaAsincrona(protocolFactory, consegnaMessageTrasformato.getServiceBinding(), sa);
  2163.                     }catch(Exception e){
  2164.                         msgDiag.logErroreGenerico(e, "AsincronoSimmetricoPolling.getDatiConsegna(sa:"+servizioApplicativo+")");
  2165.                         ejbUtils.rollbackMessage("[AsincronoSimmetricoPolling] Connettore per consegna applicativa non definito:"+e.getMessage(),servizioApplicativo, esito);
  2166.                         esito.setEsitoInvocazione(false); 
  2167.                         esito.setStatoInvocazioneErroreNonGestito(e);
  2168.                         return esito;
  2169.                     }
  2170.                 }else{
  2171.                     try{
  2172.                         gestioneConsegnaConnettore = configurazionePdDManager.getGestioneErroreConnettoreInvocazioneServizio(protocolFactory, consegnaMessageTrasformato.getServiceBinding(), sa);
  2173.                         msgDiag.mediumDebug("Inizializzo contesto per la gestione (invocazioneServizioPerRiferimento)...");
  2174.                     }catch(Exception e){
  2175.                         msgDiag.logErroreGenerico(e, "InvocazioneServizio.getDatiConsegna(sa:"+servizioApplicativo+")");
  2176.                         ejbUtils.rollbackMessage("Connettore per consegna applicativa non definito:"+e.getMessage(),servizioApplicativo, esito);
  2177.                         esito.setEsitoInvocazione(false); 
  2178.                         esito.setStatoInvocazioneErroreNonGestito(e);
  2179.                         return esito;
  2180.                     }
  2181.                 }
  2182.             }
  2183.             if(gestioneConsegnaConnettore==null){
  2184.                 msgDiag.logErroreGenerico("Gestore Errore di consegna non definito nella configurazione (is null)", "getDatiConsegna(sa:"+servizioApplicativo+")");
  2185.                 ejbUtils.rollbackMessage("Gestione Errore di consegna non definito per il sa ["+servizioApplicativo+"]",servizioApplicativo, esito);
  2186.                 esito.setEsitoInvocazione(false); 
  2187.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, "Gestione Errore di consegna non definito per il sa ["+servizioApplicativo+"]");
  2188.                 return esito;
  2189.             }
  2190.             
  2191.             
  2192.             
  2193.             
  2194.             
  2195.             
  2196.             
  2197.             /* ------------------- OutRequestHandler -----------------------*/
  2198.             OutRequestContext outRequestContext = null;
  2199.             try{
  2200.                 outRequestContext = new OutRequestContext(this.log,protocolFactory,openspcoopstate.getStatoRichiesta());
  2201.                 
  2202.                 // Informazioni connettore in uscita
  2203.                 InfoConnettoreUscita infoConnettoreUscita = new InfoConnettoreUscita();
  2204.                 infoConnettoreUscita.setLocation(location);
  2205.                 infoConnettoreUscita.setProperties(connettoreMsg.getConnectorProperties());
  2206.                 infoConnettoreUscita.setHeaders(connettoreMsg.getPropertiesTrasporto());
  2207.                 infoConnettoreUscita.setParameters(connettoreMsg.getPropertiesUrlBased());
  2208.                 infoConnettoreUscita.setSbustamentoSoap(connettoreMsg.isSbustamentoSOAP());
  2209.                 infoConnettoreUscita.setSbustamentoInformazioniProtocollo(connettoreMsg.isSbustamentoInformazioniProtocollo());
  2210.                 infoConnettoreUscita.setTipoAutenticazione(connettoreMsg.getAutenticazione());
  2211.                 infoConnettoreUscita.setCredenziali(connettoreMsg.getCredenziali());
  2212.                 infoConnettoreUscita.setTipoConnettore(connettoreMsg.getTipoConnettore());
  2213.                 outRequestContext.setConnettore(infoConnettoreUscita);
  2214.                 
  2215.                 // Informazioni messaggio
  2216.                 outRequestContext.setMessaggio(consegnaMessageTrasformato);
  2217.                 
  2218.                 // TransazioneApplicativoServer
  2219.                 outRequestContext.setTransazioneApplicativoServer(transazioneApplicativoServer);
  2220.                 
  2221.                 // Contesto
  2222.                 if(protocolContext==null) {
  2223.                     protocolContext = new ProtocolContext();
  2224.                 }
  2225.                 protocolContext.setIdRichiesta(idMessaggioConsegna);
  2226.                 if(idMessaggioPreBehaviour!=null){
  2227.                     protocolContext.setIdRichiesta(idMessaggioPreBehaviour);
  2228.                 }
  2229.                 protocolContext.setFruitore(soggettoFruitore);
  2230.                 if(bustaRichiesta!=null){
  2231.                     protocolContext.setIndirizzoFruitore(bustaRichiesta.getIndirizzoMittente());
  2232.                 }
  2233.                 if(idServizio!=null){
  2234.                     protocolContext.setErogatore(idServizio.getSoggettoErogatore());
  2235.                     if(bustaRichiesta!=null){
  2236.                         protocolContext.setIndirizzoErogatore(bustaRichiesta.getIndirizzoDestinatario());
  2237.                     }
  2238.                     protocolContext.setTipoServizio(idServizio.getTipo());
  2239.                     protocolContext.setServizio(idServizio.getNome());
  2240.                     protocolContext.setVersioneServizio(idServizio.getVersione());
  2241.                     protocolContext.setAzione(idServizio.getAzione());
  2242.                 }
  2243.                 if(idAccordoServizio!=null){
  2244.                     protocolContext.setIdAccordo(idAccordoServizio);
  2245.                 }
  2246.                 else if(idServizio!=null && idServizio.getUriAccordoServizioParteComune()!=null){
  2247.                     protocolContext.setIdAccordo(IDAccordoFactory.getInstance().getIDAccordoFromUri(idServizio.getUriAccordoServizioParteComune()));
  2248.                 }
  2249.                 String profiloCollorazioneValue = null;
  2250.                 if(bustaRichiesta!=null){
  2251.                     profiloCollorazioneValue = bustaRichiesta.getProfiloDiCollaborazioneValue();
  2252.                 }
  2253.                 protocolContext.setProfiloCollaborazione(profiloCollaborazione,profiloCollorazioneValue);
  2254.                 if(bustaRichiesta!=null){
  2255.                     protocolContext.setCollaborazione(bustaRichiesta.getCollaborazione());
  2256.                 }
  2257.                 protocolContext.setDominio(msgDiag.getDominio());
  2258.                 protocolContext.setScenarioCooperazione(scenarioCooperazione);
  2259.                 outRequestContext.setProtocollo(protocolContext);
  2260.                 
  2261.                 // Integrazione
  2262.                 if(integrationContext==null) {
  2263.                     integrationContext = new IntegrationContext();
  2264.                 }
  2265.                 integrationContext.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  2266.                 integrationContext.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  2267.                 integrationContext.addServizioApplicativoErogatore(servizioApplicativo);
  2268.                 integrationContext.setGestioneStateless(portaDiTipoStateless);
  2269.                 integrationContext.setIdPA(idPA);
  2270.                 integrationContext.setIdPD(idPD);
  2271.                 outRequestContext.setIntegrazione(integrationContext);
  2272.                 
  2273.                 // Altre informazioni
  2274.                 outRequestContext.setDataElaborazioneMessaggio(DateManager.getDate());
  2275.                 outRequestContext.setPddContext(pddContext);
  2276.                 outRequestContext.setTipoPorta(TipoPdD.APPLICATIVA);
  2277.                 outRequestContext.setIdModulo(this.idModulo);

  2279.                 // Invocazione handler
  2280.                 GestoreHandlers.outRequest(outRequestContext, msgDiag, this.log);
  2281.                 
  2282.                 // Riporto messaggio
  2283.                 consegnaMessageTrasformato = outRequestContext.getMessaggio();
  2284.                 
  2285.                 // Salvo handler
  2286.                 connettoreMsg.setOutRequestContext(outRequestContext);
  2287.                 
  2288.             }
  2289.             catch(Exception e){
  2290.                 String msgErrore = null;
  2291.                 if(e!=null && e.getMessage()!=null){
  2292.                     if(e.getMessage().length()>150){
  2293.                         msgErrore = e.getMessage().substring(0, 150);
  2294.                     }else{
  2295.                         msgErrore = e.getMessage();
  2296.                     }
  2297.                 }
  2298.                 ErroreIntegrazione erroreIntegrazione = null;
  2299.                 IntegrationFunctionError integrationFunctionError = null;
  2300.                 if(e instanceof HandlerException){
  2301.                     HandlerException he = (HandlerException) e;
  2302.                     if(he.isEmettiDiagnostico()){
  2303.                         msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  2304.                     }
  2305.                     msgErrore = ((HandlerException)e).getIdentitaHandler()+" error: "+msgErrore;
  2306.                     if(existsModuloInAttesaRispostaApplicativa) {
  2307.                         erroreIntegrazione = he.convertToErroreIntegrazione();
  2308.                         integrationFunctionError = he.getIntegrationFunctionError();
  2309.                     }
  2310.                 }else{
  2311.                     msgDiag.logErroreGenerico(e, "OutRequestHandler");
  2312.                     msgErrore = "OutRequestHandler error: "+msgErrore;
  2313.                 }
  2314.                 if(existsModuloInAttesaRispostaApplicativa) {
  2315.                     
  2316.                     if(erroreIntegrazione==null){
  2317.                         erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2318.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_543_HANDLER_OUT_REQUEST);
  2319.                     }
  2320.                     
  2321.                     if(integrationFunctionError!=null) {
  2322.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  2323.                         if(localForwardEngine!=null) {
  2324.                             localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  2325.                         }
  2326.                     }
  2327.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2328.                             erroreIntegrazione,
  2329.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  2330.                             (consegnaMessagePrimaTrasformazione!=null ? consegnaMessagePrimaTrasformazione.getParseException() : null),
  2331.                             pddContext);
  2332.                     
  2333.                     esito.setEsitoInvocazione(true); 
  2334.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  2335.                 }else{
  2336.                     ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  2337.                     esito.setEsitoInvocazione(false); 
  2338.                     esito.setStatoInvocazioneErroreNonGestito(e);
  2339.                 }
  2340.                 openspcoopstate.releaseResource();
  2341.                 return esito;
  2342.             }
  2343.             
  2344.             
  2345.             
  2346.             
  2347.             
  2348.             
  2349.             
  2350.             
  2351.             
  2352.             
  2353.             
  2354.             
  2355.             /* --------------- REFRESH LOCATION ----------------- */
  2356.             // L'handler puo' aggiornare le properties che contengono le proprieta' del connettore.
  2357.             location = ConnettoreUtils.getAndReplaceLocationWithBustaValues(connectorSender, connettoreMsg, bustaRichiesta, pddContext, protocolFactory, this.log);
  2358.             if(location!=null){
  2359.                 String locationWithUrl = ConnettoreUtils.buildLocationWithURLBasedParameter(this.log, consegnaMessageTrasformato, connettoreMsg.getTipoConnettore(), connettoreMsg.getPropertiesUrlBased(), location,
  2360.                         protocolFactory, this.idModulo);
  2361.                 locationWithUrl = ConnettoreUtils.addProxyInfoToLocationForHTTPConnector(connettoreMsg.getTipoConnettore(), connettoreMsg.getConnectorProperties(), locationWithUrl);
  2362.                 locationWithUrl = ConnettoreUtils.addGovWayProxyInfoToLocationForHTTPConnector(connettoreMsg.getForwardProxy(),connectorSender, locationWithUrl);
  2363.                 msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, ConnettoreUtils.formatLocation(httpRequestMethod, locationWithUrl));
  2364.                 
  2365.                 pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_METHOD, httpRequestMethod);
  2366.                 pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_URL, locationWithUrl);
  2367.             }
  2368.             else{
  2369.                 msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, "N.D.");
  2370.             }
  2371.             
  2372.             
  2373.             
  2374.             
  2375.             
  2376.             
  2377.             
  2378.             
  2379.             /* ------------------- add start parameter -----------------------*/
  2380.             if(CostantiPdD.isEnabledAddSWAStartParameterIfNotPresent(consegnaMessageTrasformato)) {
  2381.                 SoapUtils.addSWAStartParameterIfNotPresent(consegnaMessageTrasformato);
  2382.             }
  2383.             
  2384.             
  2385.             
  2386.             
  2387.             
  2388.             
  2389.             
  2390.             
  2391.             
  2392.             /* ------------------- Dump -----------------------*/
  2393.                 
  2394.             // Invoco il metodo getMessage del ConnettoreMsg per provocare l'eventuale sbustamento delle informazioni di protocollo
  2395.             connettoreMsg.getRequestMessage(requestInfo, pddContext);
  2396.             
  2397.             String idMessaggioDumpRichiesta = idMessaggioConsegna;
  2398.             if(idMessaggioPreBehaviour!=null){
  2399.                 idMessaggioDumpRichiesta = idMessaggioPreBehaviour;
  2400.             }
  2401.             
  2402.             Dump dumpApplicativoRichiesta = new Dump(identitaPdD,ConsegnaContenutiApplicativi.ID_MODULO,idMessaggioDumpRichiesta,
  2403.                     soggettoFruitore,idServizio,TipoPdD.APPLICATIVA,msgDiag.getPorta(),pddContext,
  2404.                     openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta(),
  2405.                     dumpConfig);
  2406.             if(transazioneApplicativoServer!=null) {
  2407.                 dumpApplicativoRichiesta.setTransazioneApplicativoServer(transazioneApplicativoServer, idPA, dataConsegna);
  2408.             }
  2409.             dumpApplicativoRichiesta.dumpRichiestaUscita(consegnaMessageTrasformato, outRequestContext.getConnettore());

  2411.             
  2412.             
  2413.             
  2414.             
  2415.             
  2416.             
  2417.             
  2418.             
  2419.             
  2420.             
  2421.             
  2422.             
  2423.             
  2424.             /* ------------------- 
  2425.                Rilascio Risorse (Le riprendero' dopo aver ottenuto la risposta, se necessario) 
  2426.                Le informazioni nel DB sono state utilizzate fino a questo punto solo in lettura.
  2427.                Eventuali spedizioni JMS sono state effettuate e le risorse gia' rilasciate (non arrivero a questo punto)
  2428.                -----------------------*/
  2429.             msgDiag.mediumDebug("Rilascio connessione al database...");
  2430.             openspcoopstate.releaseResource();
  2431.             
  2432.             
  2433.             
  2434.             
  2435.             
  2436.             
  2437.             

  2439.             // --------------------- spedizione --------------------------
  2440.                         
  2441.             Date dataPrimaInvocazioneConnettore = null;
  2442.             Date dataTerminataInvocazioneConnettore = null;
  2443.             if(invokerNonSupportato==false){
  2444.                 msgDiag.logPersonalizzato("consegnaInCorso");
  2445.                 
  2446.                 // se il tracciamento lo prevedo emetto un log
  2447.                 if(transazioneApplicativoServer==null) {
  2448.                     registraTracciaOutRequest(transactionNullable, outRequestContext, this.log, msgDiag);
  2449.                 }
  2450.                 
  2451.                 // utilizzo connettore
  2452.                 ejbUtils.setSpedizioneMsgIngresso(new Timestamp(outRequestContext.getDataElaborazioneMessaggio().getTime()));
  2453.                 dataPrimaInvocazioneConnettore = DateManager.getDate();
  2454.                 errorConsegna = !connectorSender.send(responseCachingConfig, connettoreMsg);
  2455.                 dataTerminataInvocazioneConnettore = DateManager.getDate();
  2456.             }
  2457.             
  2458.             
  2459.             
  2460.             Utilities.printFreeMemory("ConsegnaContenuti - Richiesta risorsa per la gestione della risposta...");
  2461.             
  2462.             
  2463.             
  2464.             
  2465.             /* ------------  Re-ottengo Connessione al DB -------------- */
  2466.             msgDiag.mediumDebug("Richiesta risorsa per la gestione della risposta...");
  2467.             try{
  2468.                 boolean gestioneAsincroniStateless = 
  2469.                     (ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(profiloCollaborazione) ||
  2470.                             ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(profiloCollaborazione))
  2471.                             && portaDiTipoStateless;
  2472.                 boolean oldGestioneConnessione = false;
  2473.                 if(gestioneAsincroniStateless || salvaRispostaPerNotifiche){
  2474.                     oldGestioneConnessione = ((OpenSPCoopStateless)openspcoopstate).isUseConnection();
  2475.                     ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  2476.                 }
  2477.                 openspcoopstate.updateResource(idTransazione);
  2478.                 if(gestioneAsincroniStateless){
  2479.                     ((OpenSPCoopStateless)openspcoopstate).setUseConnection(oldGestioneConnessione);
  2480.                 }
  2481.                 
  2482.                 // Aggiorno risorse
  2483.                 ejbUtils.updateOpenSPCoopState(openspcoopstate);
  2484.                 msgRequest.updateOpenSPCoopState(openspcoopstate);
  2485.                 
  2486.                 // POOL,TRANSACTIONISOLATION:
  2487.                 //connectionDB.setTransactionIsolation(DBManager.getTransactionIsolationLevel());
  2488.             }catch(Exception e){
  2489.                 msgDiag.logErroreGenerico(e,"openspcoopstate.updateResource()");
  2490.                 openspcoopstate.releaseResource();
  2491.                 esito.setEsitoInvocazione(false);   
  2492.                 esito.setStatoInvocazioneErroreNonGestito(e);
  2493.                 return esito;
  2494.             }
  2495.             
  2496.             
  2497.             
  2498.             /* ------------  Analisi Risposta -------------- */
  2499.             if(invokerNonSupportato==false){
  2500.             
  2501.                 try {
  2502.                     msgDiag.mediumDebug("Analisi Risposta");
  2503.                 
  2504.                     // nota per lo stato si intende un esito di errore connettore quando è proprio il connettore a restituire errore.
  2505.                     // se invece il connettore esce "bene" e restituisce poi un codice http e/o una risposta, si rientra nei casi sottostanti
  2506.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_UTILIZZO_CONNETTORE, errorConsegna);
  2507.                     
  2508.                     ejbUtils.setRicezioneMsgRisposta(DateManager.getTimestamp());
  2509.                     motivoErroreConsegna = connectorSender.getErrore();
  2510.                     eccezioneProcessamentoConnettore = connectorSender.getEccezioneProcessamento();
  2511.                     if(errorConsegna && motivoErroreConsegna==null){
  2512.                         motivoErroreConsegna = "Errore durante la consegna";
  2513.                     }
  2514.                     //  interpretazione esito consegna
  2515.                     GestoreErroreConnettore gestoreErrore = new GestoreErroreConnettore();
  2516.                     errorConsegna = !gestoreErrore.verificaConsegna(gestioneConsegnaConnettore,motivoErroreConsegna,eccezioneProcessamentoConnettore,connectorSender);
  2517.                     if(errorConsegna){
  2518.                         motivoErroreConsegna = gestoreErrore.getErrore();
  2519.                         riconsegna = gestoreErrore.isRiconsegna();
  2520.                         dataRiconsegna = gestoreErrore.getDataRispedizione();
  2521.                     }
  2522.                     // dopo aver verificato se siamo in un caso di errore, vediamo se l'errore è dovuto al codice di trasporto
  2523.                     // in tal caso rientriamo in un utilizzo del connettore con errore.
  2524.                     if(errorConsegna) {
  2525.                         if(connectorSender.getResponse()==null) {
  2526.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_UTILIZZO_CONNETTORE, errorConsegna);
  2527.                         }
  2528.                     }
  2529.                     if(transazioneApplicativoServer!=null) {
  2530.                         transazioneApplicativoServer.setConsegnaTerminata(!errorConsegna);
  2531.                     }
  2532.                     // raccolta risultati del connettore
  2533.                     soapFault = gestoreErrore.getFault();
  2534.                     restProblem = gestoreErrore.getProblem();
  2535.                     faultMessageFactory = connectorSender.getResponse()!=null ? connectorSender.getResponse().getFactory() : OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  2536.                     codiceRitornato = connectorSender.getCodiceTrasporto();
  2537.                     transportResponseContext = new TransportResponseContext(this.log, connectorSender.getCodiceTrasporto()+"", 
  2538.                             connectorSender.getHeaderTrasporto(), 
  2539.                             connectorSender.getContentLength(), 
  2540.                             motivoErroreConsegna, connectorSender.getEccezioneProcessamento());
  2541.                     responseMessage = connectorSender.getResponse();
  2542.                     useResponseForParseException = true;
  2543.                     if(responseMessage!=null){
  2544.                         responseMessage.setTransportRequestContext(consegnaMessagePrimaTrasformazione.getTransportRequestContext());
  2545.                         responseMessage.setTransportResponseContext(transportResponseContext);
  2546.                         responseContentLength = connectorSender.getContentLength();
  2547.                     }
  2548.                     // gestione connessione connettore
  2549.                     if(existsModuloInAttesaRispostaApplicativa) {
  2550.                         if(localForward){
  2551.                             RepositoryConnettori.salvaConnettorePD(
  2552.                                     //idMessaggioConsegna,
  2553.                                     idTransazione,
  2554.                                     connectorSender);
  2555.                         }else{
  2556.                             RepositoryConnettori.salvaConnettorePA(
  2557.                                     //idMessaggioConsegna, 
  2558.                                     idTransazione,
  2559.                                     connectorSender);
  2560.                         }
  2561.                     }else{
  2562.                         // Sono nella casistica di messaggio preso in carico.
  2563.                         // Non si deve chiudere immediatamente la connessione, poiche' nel resto del modulo, il messaggio puo' ancora essere utilizzato (es. dump)
  2564.                         connectorSenderForDisconnect = connectorSender;
  2565.                     }           
  2566.                     msgDiag.addKeyword(CostantiPdD.KEY_CODICE_CONSEGNA, codiceRitornato+"");
  2567.                     if(motivoErroreConsegna!=null)
  2568.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, motivoErroreConsegna);
  2569.                     
  2570.                     // Il Connettore potrebbe aggiungere informazioni alla location.
  2571.                     String tmpLocation = connectorSender.getLocation();
  2572.                     if(tmpLocation!=null){
  2573.                         
  2574.                         // salvo la request url originale, se la risposta non è letta dalla cache
  2575.                         boolean responseCached = false;
  2576.                         if(pddContext.containsKey(ConnettoreBase.RESPONSE_FROM_CACHE)) {
  2577.                             responseCached = (Boolean) pddContext.getObject(ConnettoreBase.RESPONSE_FROM_CACHE);
  2578.                         }
  2579.                         if(!responseCached) {
  2580.                             pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_METHOD, httpRequestMethod);
  2581.                             pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_URL, tmpLocation);
  2582.                         }
  2583.                         
  2584.                         // aggiorno
  2585.                         location = tmpLocation;
  2586.                         if(responseCached) {
  2587.                             msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, location);
  2588.                         }
  2589.                         else {
  2590.                             msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, ConnettoreUtils.formatLocation(httpRequestMethod, location));
  2591.                         }
  2592.                     }
  2593.                     
  2594.                     /* ------------ Check Charset ------------- */
  2595.                     try {
  2596.                         if(transportResponseContext!=null) {
  2597.                             boolean checkEnabled = false;
  2598.                             List<String> ctDefault = null;
  2599.                             if(consegnaMessageTrasformato!=null && ServiceBinding.SOAP.equals(consegnaMessageTrasformato.getServiceBinding())){
  2600.                                 if(this.propertiesReader.isControlloCharsetContentTypeAbilitatoRicezioneBusteSoap()) {
  2601.                                     checkEnabled = true;
  2602.                                     ctDefault = this.propertiesReader.getControlloCharsetContentTypeAbilitatoRicezioneBusteSoap();
  2603.                                 }
  2604.                             }
  2605.                             else {
  2606.                                 if(this.propertiesReader.isControlloCharsetContentTypeAbilitatoRicezioneBusteRest()) {
  2607.                                     checkEnabled = true;
  2608.                                     ctDefault = this.propertiesReader.getControlloCharsetContentTypeAbilitatoRicezioneBusteRest();
  2609.                                 }
  2610.                             }
  2611.                             if(checkEnabled) {
  2612.                                 if(transportResponseContext.getContentType()!=null) {
  2613.                                     ServicesUtils.checkCharset(transportResponseContext.getContentType(), ctDefault, msgDiag, false, TipoPdD.APPLICATIVA);
  2614.                                 }
  2615.                             }
  2616.                         }
  2617.                     }catch(Throwable t) {
  2618.                         String ct = null;
  2619.                         try {
  2620.                             if(transportResponseContext!=null) {
  2621.                                 ct = transportResponseContext.getContentType();
  2622.                             }
  2623.                         }catch(Throwable tRead) {
  2624.                             // ignore
  2625.                         }   
  2626.                         this.log.error("Avvenuto errore durante il controllo del charset della risposta (Content-Type: "+ct+"): "+t.getMessage(),t);
  2627.                     }
  2628.                     
  2629.                     // ------------- aggiungo gli Headers peer -----------------
  2630.                     if(transportResponseContext!=null) {
  2631.                         this.addHeadersPeer(pddContext, transportResponseContext, proprietaPorta);
  2632.                     }
  2633.                     
  2634.                 } catch (Exception e) {
  2635.                     msgDiag.addKeywordErroreProcessamento(e, "Analisi risposta fallita");
  2636.                     msgDiag.logErroreGenerico(e,"AnalisiRispostaConnettore");
  2637.                     String msgErrore = "Analisi risposta del connettore ha provocato un errore: "+e.getMessage();
  2638.                     this.log.error(msgErrore,e);
  2639.                     if(existsModuloInAttesaRispostaApplicativa) {
  2640.                         
  2641.                         this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2642.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2643.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  2644.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  2645.                                 (connectorSender!=null && connectorSender.getResponse()!=null ? connectorSender.getResponse().getParseException() : null),
  2646.                                 pddContext);
  2647.                         
  2648.                         esito.setEsitoInvocazione(true); 
  2649.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  2650.                     }else{
  2651.                         ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  2652.                         esito.setEsitoInvocazione(false); 
  2653.                         esito.setStatoInvocazioneErroreNonGestito(e);
  2654.                     }
  2655.                     openspcoopstate.releaseResource();
  2656.                     return esito;
  2657.                 }
  2658.             }

  2660.                 
  2661.             
  2662.             
  2663.             msgDiag.mediumDebug("Aggiungo informazioni di integrazione dinamica della risposta nel contesto ...");
  2664.                     
  2665.             try {
  2666.                 if(pa!=null && transportResponseContext!=null) {
  2667.                     configurazionePdDManager.setInformazioniIntegrazioneDinamiche(this.log, transportResponseContext, pddContext, pa);
  2668.                 }
  2669.             } 
  2670.             catch (Throwable e) {
  2671.                 msgDiag.addKeywordErroreProcessamento(e, "setInformazioniIntegrazioneDinamicheRisposta");
  2672.                 msgDiag.logErroreGenerico(e,"setInformazioniIntegrazioneDinamicheRisposta");
  2673.                 String msgErrore = "Lettura delle informazioni di integrazione dinamica della risposta ha provocato un errore: "+e.getMessage();
  2674.                 this.log.error(msgErrore,e);
  2675.                 if(existsModuloInAttesaRispostaApplicativa) {
  2676.                     
  2677.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2678.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2679.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  2680.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  2681.                             (connectorSender!=null && connectorSender.getResponse()!=null ? connectorSender.getResponse().getParseException() : null),
  2682.                             pddContext);
  2683.                     
  2684.                     esito.setEsitoInvocazione(true); 
  2685.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  2686.                 }else{
  2687.                     ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  2688.                     esito.setEsitoInvocazione(false); 
  2689.                     esito.setStatoInvocazioneErroreNonGestito(e);
  2690.                 }
  2691.                 openspcoopstate.releaseResource();
  2692.                 return esito;
  2693.             }



  2697.             
  2698.             
  2699.             if(salvaRispostaPerNotifiche && responseMessage!=null) {
  2700.                 try {
  2701.                     msgDiag.mediumDebug("Conservazione della risposta per il gestore delle notifiche");
  2702.                     
  2703.                     // TODO in futuro valutare se poter salvare la risposta già trasformata
  2704.                     // Poichè il campo a disposizione è uno solo per la risposta, e l'impostazione di cosa salvare viene dedotta da quanto indicato su ogni connettore
  2705.                     // la console dovrà poi consentire di indicare solamente 1 opzione tra risposta originale e risposta trasformata tra tutti i connettori multipli
  2706.                     
  2707.                     List<MapKey<String>> contextInResponse = new ArrayList<MapKey<String>>();
  2708.                     Iterator<MapKey<String>> it = responseMessage.keysContextProperty();
  2709.                     while (it.hasNext()) {
  2710.                         MapKey<String> key = (MapKey<String>) it.next();
  2711.                         contextInResponse.add(key);
  2712.                     }
  2713.                     
  2714.                     if(consegnaMessageTrasformato!=null) {
  2715.                         it = consegnaMessageTrasformato.keysContextProperty();
  2716.                         while (it.hasNext()) {
  2717.                             MapKey<String> key = (MapKey<String>) it.next();
  2718.                             if(!contextInResponse.contains(key)) {
  2719.                                 Object v = consegnaMessageTrasformato.getContextProperty(key);
  2720.                                 //System.out.println("ADD ["+key+"] ["+v.getClass().getName()+"] ["+v+"]");
  2721.                                 responseMessage.addContextProperty(key, v);
  2722.                             }
  2723.                         }
  2724.                         if(ServiceBinding.SOAP.equals(consegnaMessageTrasformato.getServiceBinding()) &&
  2725.                                 ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())) {
  2726.                             String soapAction = null;
  2727.                             if(consegnaMessageTrasformato.getTransportRequestContext()!=null && consegnaMessageTrasformato.getTransportRequestContext().getHeaders()!=null) {
  2728.                                 if(TransportUtils.containsKey(consegnaMessageTrasformato.getTransportRequestContext().getHeaders(), org.openspcoop2.message.constants.Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  2729.                                     soapAction = TransportUtils.getFirstValue(consegnaMessageTrasformato.getTransportRequestContext().getHeaders(), org.openspcoop2.message.constants.Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  2730.                                 }
  2731.                             }
  2732.                             if(soapAction==null) {
  2733.                                 soapAction = consegnaMessageTrasformato.castAsSoap().getSoapAction();
  2734.                             }
  2735.                             if(soapAction!=null) {
  2736.                                 responseMessage.castAsSoap().setSoapAction(soapAction);
  2737.                             }
  2738.                         }
  2739.                     }
  2740.                     
  2741.                     msgRequest.registraRisposta_statelessEngine(identificativoMessaggioDoveSalvareLaRisposta, responseMessage, false);
  2742.                                         
  2743.                 } catch (Exception e) {
  2744.                     msgDiag.addKeywordErroreProcessamento(e, "Conservazione risposta fallita");
  2745.                     msgDiag.logErroreGenerico(e,"ConservazioneRispostaConnettore");
  2746.                     String msgErrore = "Conservazione risposta del connettore ha provocato un errore: "+e.getMessage();
  2747.                     this.log.error(msgErrore,e);
  2748.                     if(existsModuloInAttesaRispostaApplicativa) {
  2749.                         
  2750.                         this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2751.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2752.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),
  2753.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  2754.                                 (connectorSender!=null && connectorSender.getResponse()!=null ? connectorSender.getResponse().getParseException() : null),
  2755.                                 pddContext);
  2756.                         
  2757.                         esito.setEsitoInvocazione(true); 
  2758.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  2759.                     }else{
  2760.                         ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  2761.                         esito.setEsitoInvocazione(false); 
  2762.                         esito.setStatoInvocazioneErroreNonGestito(e);
  2763.                     }
  2764.                     openspcoopstate.releaseResource();
  2765.                     return esito;
  2766.                 }
  2767.             }
  2768.             
  2769.             
  2770.             
  2771.             
  2772.             
  2773.             
  2774.             
  2775.             /* ------------ Trasformazione Risposta  -------------- */
  2776.             
  2777.             boolean dumpRispostaEffettuato = false;
  2778.             if(trasformazioni!=null && responseMessage!=null
  2779.                     && transazioneApplicativoServer==null // non ha senso per le notifiche asincrone
  2780.                     ) {
  2781.                 try {
  2782.                     
  2783.                     // prima effettuo dump applicativo
  2784.                     if(responseMessage!=null ){
  2785.                         
  2786.                         String idMessaggioDump = idMessaggioConsegna;
  2787.                         if(idMessaggioPreBehaviour!=null){
  2788.                             idMessaggioDump = idMessaggioPreBehaviour;
  2789.                         }
  2790.                         
  2791.                         Dump dumpApplicativo = new Dump(identitaPdD,ConsegnaContenutiApplicativi.ID_MODULO,idMessaggioDump,
  2792.                                 soggettoFruitore,idServizio,TipoPdD.APPLICATIVA,msgDiag.getPorta(),pddContext,
  2793.                                 openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta(),
  2794.                                 dumpConfig);
  2795.                         /*if(transazioneApplicativoServer!=null) {
  2796.                             dumpApplicativo.setTransazioneApplicativoServer(transazioneApplicativoServer, idPA, dataConsegna);
  2797.                         }*/
  2798.                         InfoConnettoreUscita infoConnettoreUscita = outRequestContext.getConnettore();
  2799.                         if(infoConnettoreUscita!=null){
  2800.                             infoConnettoreUscita.setLocation(location); // aggiorno location ottenuta dal connettore utilizzato
  2801.                         }
  2802.                         dumpApplicativo.dumpRispostaIngresso(responseMessage, infoConnettoreUscita, connectorSender.getHeaderTrasporto());
  2803.                         dumpRispostaEffettuato = true;
  2804.                     }
  2805.                     
  2806.                     MessageType messageTypePrimaTrasformazione = responseMessage.getMessageType();
  2807.                     
  2808.                     responseMessage = gestoreTrasformazioni.trasformazioneRisposta(responseMessage, bustaRichiesta);
  2809.                     
  2810.                     MessageType messageTypeDopoTrasformazione = (responseMessage!=null)  ? responseMessage.getMessageType() : null;
  2811.                     if(messageTypeDopoTrasformazione==null || messageTypePrimaTrasformazione.equals(messageTypeDopoTrasformazione)==false) {
  2812.                         soapFault = null;
  2813.                         restProblem = null;
  2814.                         if(messageTypeDopoTrasformazione!=null) {
  2815.                             if(responseMessage instanceof OpenSPCoop2SoapMessage){
  2816.                                 if(responseMessage.castAsSoap().hasSOAPFault()){
  2817.                                     SOAPBody body = responseMessage.castAsSoap().getSOAPBody();
  2818.                                     soapFault = body.getFault();
  2819.                                 }
  2820.                             }
  2821.                             else {
  2822.                                 if(responseMessage instanceof OpenSPCoop2RestJsonMessage ){
  2823.                                     OpenSPCoop2RestJsonMessage msg = responseMessage.castAsRestJson();
  2824.                                     if(msg.hasContent() && msg.isProblemDetailsForHttpApis_RFC7807()) {
  2825.                                         JsonDeserializer deserializer = new JsonDeserializer();
  2826.                                         restProblem = deserializer.fromString(msg.getContent(), false);
  2827.                                     }
  2828.                                 }
  2829.                                 else if(responseMessage instanceof OpenSPCoop2RestXmlMessage ){
  2830.                                     OpenSPCoop2RestXmlMessage msg = responseMessage.castAsRestXml();
  2831.                                     if(msg.hasContent() && msg.isProblemDetailsForHttpApis_RFC7807()) {
  2832.                                         XmlDeserializer deserializer = new XmlDeserializer();
  2833.                                         restProblem = deserializer.fromNode(msg.getContent(), false);
  2834.                                     }
  2835.                                 }
  2836.                             }
  2837.                         }
  2838.                     }
  2839.                 }
  2840.                 catch(Throwable e) {
  2841.                     
  2842.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_TRASFORMAZIONE_RISPOSTA, "true");
  2843.                     
  2844.                     // prima emetto diagnostico di fine connettore
  2845.                     emitDiagnostico(invokerNonSupportato, bustaRichiesta, msgDiag, errorConsegna);

  2847.                     
  2848.                     msgDiag.addKeywordErroreProcessamento(e);
  2849.                     msgDiag.logPersonalizzato("trasformazione.processamentoRispostaInErrore");
  2850.                     
  2851.                     ErroreIntegrazione erroreIntegrazione = gestoreTrasformazioni.getErrore();
  2852.                     if(erroreIntegrazione==null) {
  2853.                         erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2854.                                 get5XX_ErroreProcessamento(e,CodiceErroreIntegrazione.CODICE_562_TRASFORMAZIONE);
  2855.                     }
  2856.                     
  2857.                     String msgErrore = e.getMessage();                  
  2858.                     if(existsModuloInAttesaRispostaApplicativa) {
  2859.                         
  2860.                         IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.TRANSFORMATION_RULE_RESPONSE_FAILED;
  2861.                         if(e instanceof GestoreTrasformazioniException && (((GestoreTrasformazioniException)e).getOp2IntegrationFunctionError()!=null)) {
  2862.                             integrationFunctionError = ((GestoreTrasformazioniException)e).getOp2IntegrationFunctionError();
  2863.                         }
  2864.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  2865.                         if(localForwardEngine!=null) {
  2866.                             localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  2867.                         }
  2868.                         
  2869.                         if(e instanceof GestoreTrasformazioniException && (((GestoreTrasformazioniException)e).getOpenSPCoop2ErrorMessage()!=null)) {
  2870.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2871.                                     ((GestoreTrasformazioniException)e).getOpenSPCoop2ErrorMessage(), msgErrore,
  2872.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore);
  2873.                         }
  2874.                         else {
  2875.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2876.                                 erroreIntegrazione,
  2877.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  2878.                                 (connectorSender!=null && connectorSender.getResponse()!=null ? connectorSender.getResponse().getParseException() : null),
  2879.                                 pddContext);
  2880.                         }
  2881.                         
  2882.                         esito.setEsitoInvocazione(true); 
  2883.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  2884.                     }else{
  2885.                         ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  2886.                         esito.setEsitoInvocazione(false); 
  2887.                         esito.setStatoInvocazioneErroreNonGestito(e);
  2888.                     }
  2889.                     openspcoopstate.releaseResource();
  2890.                     return esito;
  2891.                 }       
  2892.             }
  2893.             
  2894.             
  2895.             
  2896.             
  2897.             
  2898.             
  2899.             
  2900.             
  2901.     

  2903.             
  2904.             /* -------- OpenSPCoop2Message Update ------------- */
  2905.             try {
  2906.                 if(transazioneApplicativoServer==null) { // non ha senso per le notifiche asincrone
  2907.                     msgDiag.mediumDebug("Aggiornamento del messaggio");
  2908.                     // NOTA la versione SOAP capirla da consegnaMessage, la risposta puo' essere null
  2909.                     NotifierInputStreamParams nParams = null;
  2910.                     if(invokerNonSupportato==false){
  2911.                         nParams = connectorSender.getNotifierInputStreamParamsResponse();
  2912.                     }
  2913.                     responseMessage = protocolFactory.createProtocolManager().updateOpenSPCoop2MessageResponse(responseMessage, 
  2914.                             bustaRichiesta, nParams,
  2915.                             consegnaMessagePrimaTrasformazione.getTransportRequestContext(),transportResponseContext,
  2916.                             protocolFactory.getCachedRegistryReader(openspcoopstate.getStatoRichiesta(), requestInfo),
  2917.                             true);
  2918.                 }
  2919.             } catch (Exception e) {
  2920.                 msgDiag.addKeywordErroreProcessamento(e, "Aggiornamento messaggio fallito");
  2921.                 msgDiag.logErroreGenerico(e,"ProtocolManager.updateOpenSPCoop2Message");
  2922.                 String msgErrore = "ProtocolManager.updateOpenSPCoop2Message error: "+e.getMessage();
  2923.                 this.log.error(msgErrore,e);
  2924.                 if(existsModuloInAttesaRispostaApplicativa) {
  2925.                     
  2926.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  2927.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2928.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  2929.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  2930.                             (responseMessage!=null ? responseMessage.getParseException() : null),
  2931.                             pddContext);
  2932.                     
  2933.                     esito.setEsitoInvocazione(true); 
  2934.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  2935.                 }else{
  2936.                     ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  2937.                     esito.setEsitoInvocazione(false); 
  2938.                     esito.setStatoInvocazioneErroreNonGestito(e);
  2939.                 }
  2940.                 openspcoopstate.releaseResource();
  2941.                 return esito;
  2942.             }
  2943.             
  2944.             
  2945.             
  2946.             
  2947.             
  2948.             
  2949.             
  2950.             
  2951.             
  2952.             
  2953.             
  2954.             /* ------------------- InResponseHandler -----------------------*/
  2955.             InResponseContext inResponseContext = null;
  2956.             if(invokerNonSupportato==false){
  2957.                 try{
  2958.                     inResponseContext = new InResponseContext(this.log,protocolFactory,openspcoopstate.getStatoRisposta());
  2959.                     
  2960.                     // Informazioni sul messaggio di riposta
  2961.                     if(responseMessage!=null){
  2962.                         inResponseContext.setMessaggio(responseMessage);                
  2963.                     }
  2964.                     
  2965.                     // TransazioneApplicativoServer
  2966.                     inResponseContext.setTransazioneApplicativoServer(transazioneApplicativoServer);
  2967.                     
  2968.                     // Informazioni sulla consegna
  2969.                     inResponseContext.setErroreConsegna(motivoErroreConsegna);
  2970.                     inResponseContext.setResponseHeaders(connectorSender.getHeaderTrasporto());
  2971.                     inResponseContext.setReturnCode(codiceRitornato);
  2972.                     
  2973.                     // Altre informazioni
  2974.                     if(outRequestContext.getConnettore()!=null){
  2975.                         outRequestContext.getConnettore().setLocation(location); // aggiorno location ottenuta dal connettore utilizzato
  2976.                     }
  2977.                     inResponseContext.setConnettore(outRequestContext.getConnettore());
  2978.                     inResponseContext.setDataPrimaInvocazioneConnettore(dataPrimaInvocazioneConnettore);
  2979.                     inResponseContext.setDataTerminataInvocazioneConnettore(dataTerminataInvocazioneConnettore);
  2980.                     inResponseContext.setDataRichiestaInoltrata(connectorSender.getDataRichiestaInoltrata());
  2981.                     inResponseContext.setDataAccettazioneRisposta(connectorSender.getDataAccettazioneRisposta());
  2982.                     inResponseContext.setDataElaborazioneMessaggio(ejbUtils.getRicezioneMsgRisposta());
  2983.                     inResponseContext.setProtocollo(outRequestContext.getProtocollo());
  2984.                     inResponseContext.setPddContext(pddContext);
  2985.                     inResponseContext.setIntegrazione(outRequestContext.getIntegrazione());
  2986.                     inResponseContext.setTipoPorta(outRequestContext.getTipoPorta());
  2987.                     
  2988.                     // Invocazione handler
  2989.                     GestoreHandlers.inResponse(inResponseContext, msgDiag, this.log);
  2990.                     
  2991.                 }
  2992.                 catch(Exception e){
  2993.                     String msgErrore = null;
  2994.                     if(e!=null && e.getMessage()!=null){
  2995.                         if(e.getMessage().length()>150){
  2996.                             msgErrore = e.getMessage().substring(0, 150);
  2997.                         }else{
  2998.                             msgErrore = e.getMessage();
  2999.                         }
  3000.                     }
  3001.                     ErroreIntegrazione erroreIntegrazione = null;
  3002.                     IntegrationFunctionError integrationFunctionError = null;
  3003.                     if(e instanceof HandlerException){
  3004.                         HandlerException he = (HandlerException) e;
  3005.                         if(he.isEmettiDiagnostico()){
  3006.                             msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  3007.                         }
  3008.                         msgErrore = ((HandlerException)e).getIdentitaHandler()+" error: "+msgErrore;
  3009.                         if(existsModuloInAttesaRispostaApplicativa) {
  3010.                             erroreIntegrazione = he.convertToErroreIntegrazione();
  3011.                             integrationFunctionError = he.getIntegrationFunctionError();
  3012.                         }
  3013.                     }else{
  3014.                         msgDiag.logErroreGenerico(e, "InResponseHandler");
  3015.                         msgErrore = "InResponseHandler error: "+msgErrore;
  3016.                     }
  3017.                     if(existsModuloInAttesaRispostaApplicativa) {
  3018.                         
  3019.                         if(erroreIntegrazione==null){
  3020.                             erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3021.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_544_HANDLER_IN_RESPONSE);
  3022.                         }
  3023.                         
  3024.                         if(integrationFunctionError!=null) {
  3025.                             ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  3026.                             if(localForwardEngine!=null) {
  3027.                                 localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  3028.                             }
  3029.                         }
  3030.                         this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3031.                                 erroreIntegrazione,
  3032.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  3033.                                 (responseMessage!=null ? responseMessage.getParseException() : null),
  3034.                                 pddContext);
  3035.                         
  3036.                         esito.setEsitoInvocazione(true); 
  3037.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErrore);
  3038.                     }else{
  3039.                         ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  3040.                         esito.setEsitoInvocazione(false); 
  3041.                         esito.setStatoInvocazioneErroreNonGestito(e);
  3042.                     }
  3043.                     openspcoopstate.releaseResource();
  3044.                     return esito;
  3045.                 }
  3046.             }
  3047.             
  3048.             
  3049.             
  3050.             
  3051.             
  3052.             
  3053.             
  3054.             
  3055.             
  3056.             
  3057.             
  3058.             
  3059.             /* ------------ Controllo che il messaggio non contenga una busta */
  3060.             msgDiag.mediumDebug("Controllo non esistenza di una busta ...");
  3061.             ValidazioneSintattica validatoreSintattico = new ValidazioneSintattica(pddContext, openspcoopstate.getStatoRichiesta(),responseMessage, protocolFactory);
  3062.             String msgErrore = null;
  3063.             try{
  3064.                 if(validatoreSintattico.verifyProtocolPresence(tipoPdD,profiloCollaborazione,RuoloMessaggio.RISPOSTA)){
  3065.                     throw new Exception("Rilevato ProtocolHeader nella risposta");
  3066.                 }
  3067.             } catch (Exception e){
  3068.                 msgDiag.logPersonalizzato("rispostaContenenteBusta");
  3069.                 this.log.error("CheckProtocolPresence",e);
  3070.                 if(existsModuloInAttesaRispostaApplicativa) {
  3071.                     
  3072.                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.INTEROPERABILITY_PROFILE_RESPONSE_ALREADY_EXISTS);
  3073.                     if(localForwardEngine!=null) {
  3074.                         localForwardEngine.setIntegrationFunctionError(IntegrationFunctionError.INTEROPERABILITY_PROFILE_RESPONSE_ALREADY_EXISTS);
  3075.                     }
  3076.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3077.                             ErroriIntegrazione.ERRORE_454_BUSTA_PRESENTE_RISPOSTA_APPLICATIVA.getErroreIntegrazione(),
  3078.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  3079.                             (responseMessage!=null ? responseMessage.getParseException() : null),
  3080.                             pddContext);
  3081.                     
  3082.                     esito.setEsitoInvocazione(true); 
  3083.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  3084.                             msgDiag.getMessaggio_replaceKeywords("rispostaContenenteBusta"));
  3085.                 }else{
  3086.                     ejbUtils.rollbackMessage(msgErrore,servizioApplicativo, esito);
  3087.                     esito.setEsitoInvocazione(false); 
  3088.                     esito.setStatoInvocazioneErroreNonGestito(e);
  3089.                 }
  3090.                 openspcoopstate.releaseResource();
  3091.                 return esito;
  3092.             }finally{
  3093.                 // *** GB ***
  3094.                 if(validatoreSintattico!=null){
  3095.                     validatoreSintattico.setHeaderSOAP(null);
  3096.                 }
  3097.                 validatoreSintattico = null;
  3098.                 // *** GB ***
  3099.             }

  3101.             
  3102.             
  3103.             
  3104.             
  3105.             
  3106.             
  3107.             
  3108.             
  3109.             
  3110.             
  3111.             
  3112.             
  3113.             // --------------------- Messaggio di Risposta + Dump --------------------------
  3114.             if(invokerNonSupportato==false){
  3115.                 
  3116.                 // Leggo informazioni di trasporto
  3117.                 codiceRitornato = inResponseContext.getReturnCode();
  3118.                 motivoErroreConsegna = inResponseContext.getErroreConsegna();
  3119.                 responseMessage = inResponseContext.getMessaggio();
  3120.                 
  3121.                 String idMessaggioDump = idMessaggioConsegna;
  3122.                 if(idMessaggioPreBehaviour!=null){
  3123.                     idMessaggioDump = idMessaggioPreBehaviour;
  3124.                 }
  3125.                 
  3126.                 //  dump applicativo
  3127.                 if(!dumpRispostaEffettuato && responseMessage!=null ){
  3128.                     Dump dumpApplicativo = new Dump(identitaPdD,ConsegnaContenutiApplicativi.ID_MODULO,idMessaggioDump,
  3129.                             soggettoFruitore,idServizio,TipoPdD.APPLICATIVA,msgDiag.getPorta(),pddContext,
  3130.                             openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta(),
  3131.                             dumpConfig);
  3132.                     if(transazioneApplicativoServer!=null) {
  3133.                         dumpApplicativo.setTransazioneApplicativoServer(transazioneApplicativoServer, idPA, dataConsegna);
  3134.                     }
  3135.                     dumpApplicativo.dumpRispostaIngresso(responseMessage, inResponseContext.getConnettore(), inResponseContext.getResponseHeaders());
  3136.                 }
  3137.                 
  3138.             }
  3139.             
  3140.             
  3141.             
  3142.             
  3143.             





  3149.             /* ------------------- MsgDiagnostico -----------------------*/
  3150.             
  3151.             emitDiagnostico(invokerNonSupportato, bustaRichiesta, msgDiag, errorConsegna);







  3159.             /* ------------------------- Gestione Notifica ---------------------------- */
  3160.             if(salvaRispostaPerNotifiche && responseMessage==null && MessaggioDaNotificare.RISPOSTA.equals(tipiMessaggiNotificabili)) {
  3161.                 try{
  3162.                     ConnettoreException e = null;
  3163.                     if(consegnaMessageTrasformato!=null && ServiceBinding.SOAP.equals(consegnaMessageTrasformato.getServiceBinding()) && !errorConsegna){
  3164.                         e = new ConnettoreException("Non essendo presente un payload nella risposta restituita dal backend, il salvataggio della risposta non può essere completato e nessuna notifica verrà generata");
  3165.                     }
  3166.                     else {
  3167.                         e = new ConnettoreException("Causa indisponibilità del backend, il salvataggio della risposta non può essere completato e nessuna notifica verrà generata");
  3168.                     }
  3169.                     msgDiag.addKeywordErroreProcessamento(e, "Conservazione risposta fallita");
  3170.                     msgDiag.logErroreGenerico(e,"Notifiche");
  3171.                     String msgErroreR = "Conservazione risposta fallita: "+e.getMessage();
  3172.                     this.log.error(msgErroreR,e);
  3173.                     pddContext.put(CostantiPdD.CONNETTORE_MULTIPLO_CONSEGNA_NOTIFICA_DISABILITATA, e);
  3174.                 }catch (Exception e){
  3175.                     this.log.error("Errore Salvataggio informazione di notifica disabilitata",e);
  3176.                 }
  3177.             }
  3178.             
  3179.             
  3180.             



  3184.             /* ------------------------- Gestione Errori Consegna ---------------------------- */
  3185.             msgDiag.mediumDebug("Gestione errore consegna della risposta...");
  3186.             // Invoker Non Supportato
  3187.             if( invokerNonSupportato == true  ){
  3188.                 String msgErroreConnettoreNonSupportato = "Connettore non supportato [tipo:"+tipoConnector+" class:"+connectorClass+"]";
  3189.                 if(existsModuloInAttesaRispostaApplicativa) {
  3190.                     
  3191.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3192.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3193.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_515_CONNETTORE_NON_REGISTRATO),
  3194.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, eInvokerNonSupportato,
  3195.                             (responseMessage!=null ? responseMessage.getParseException() : null),
  3196.                             pddContext);
  3197.                     
  3198.                     esito.setEsitoInvocazione(true); 
  3199.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErroreConnettoreNonSupportato);
  3200.                 }else{
  3201.                     ejbUtils.rollbackMessage(msgErroreConnettoreNonSupportato,servizioApplicativo, esito);
  3202.                     esito.setEsitoInvocazione(false); 
  3203.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, msgErroreConnettoreNonSupportato);
  3204.                 }
  3205.                 openspcoopstate.releaseResource();
  3206.                 return esito;

  3208.             }
  3209.             //  Errori avvenuti durante la consegna
  3210.             else if(errorConsegna){
  3211.                         
  3212.                 // Effettuo log dell'eventuale fault
  3213.                 if(soapFault!=null && 
  3214.                         ( 
  3215.                           (motivoErroreConsegna==null) ||
  3216.                           (!motivoErroreConsegna.toLowerCase().contains("faultCode") && !motivoErroreConsegna.toLowerCase().contains("faultActor") && !motivoErroreConsegna.toLowerCase().contains("faultString"))
  3217.                         ) 
  3218.                     ){
  3219.                     // Se non l'ho gia indicato nel motivo di errore, registro il fault
  3220.                     msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, SoapUtils.safe_toString(faultMessageFactory, soapFault, this.log));
  3221.                     msgDiag.logPersonalizzato("ricezioneSoapFault");
  3222.                 }
  3223.                 else if(restProblem!=null && 
  3224.                         ( 
  3225.                           (motivoErroreConsegna==null) ||
  3226.                           (!motivoErroreConsegna.toLowerCase().contains(ProblemConstants.CLAIM_TYPE))
  3227.                         ) 
  3228.                     ){
  3229.                     // Se non l'ho gia indicato nel motivo di errore, registro il fault
  3230.                     msgDiag.addKeyword(CostantiPdD.KEY_REST_PROBLEM, restProblem.getRaw());
  3231.                     msgDiag.logPersonalizzato("ricezioneRestProblem");
  3232.                 }
  3233.                 else{
  3234.                     
  3235.                     // Controllo Situazione Anomala ISSUE OP-7
  3236.                     if(responseMessage!=null && ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())){
  3237.                         OpenSPCoop2SoapMessage soapMessageResponse = responseMessage.castAsSoap();
  3238.                         if(soapMessageResponse.getSOAPPart()!=null && 
  3239.                                 soapMessageResponse.getSOAPPart().getEnvelope()!=null &&
  3240.                                 (soapMessageResponse.isSOAPBodyEmpty() || (!soapMessageResponse.hasSOAPFault()) )
  3241.                                 ) {
  3242.                             msgDiag.logPersonalizzato("comportamentoAnomalo.erroreConsegna.ricezioneMessaggioDiversoFault");
  3243.                             if(isBlockedTransaction_responseMessageWithTransportCodeError){
  3244.                                 String msgErroreSituazioneAnomale = msgDiag.getMessaggio_replaceKeywords("comportamentoAnomalo.erroreConsegna.ricezioneMessaggioDiversoFault");
  3245.                                 if(existsModuloInAttesaRispostaApplicativa) {
  3246.                                     
  3247.                                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.BAD_RESPONSE);
  3248.                                     if(localForwardEngine!=null) {
  3249.                                         localForwardEngine.setIntegrationFunctionError(IntegrationFunctionError.BAD_RESPONSE);
  3250.                                     }
  3251.                                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3252.                                             ErroriIntegrazione.ERRORE_559_RICEVUTA_RISPOSTA_CON_ERRORE_TRASPORTO.
  3253.                                                 get559_RicevutaRispostaConErroreTrasporto(msgErroreSituazioneAnomale),
  3254.                                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, eInvokerNonSupportato,
  3255.                                             (responseMessage!=null ? responseMessage.getParseException() : null),
  3256.                                             pddContext);
  3257.                                     
  3258.                                     esito.setEsitoInvocazione(true); 
  3259.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, msgErroreSituazioneAnomale);
  3260.                                 }else{
  3261.                                     ejbUtils.rollbackMessage(msgErroreSituazioneAnomale,servizioApplicativo, esito);
  3262.                                     esito.setEsitoInvocazione(false); 
  3263.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, msgErroreSituazioneAnomale);
  3264.                                 }
  3265.                                 openspcoopstate.releaseResource();
  3266.                                 return esito;
  3267.                             }
  3268.                         }
  3269.                     }
  3270.                 }
  3271.                 
  3272.                 String messaggioErroreConsegnaConnettore = "Consegna ["+tipoConnector+"] con errore: "+motivoErroreConsegna;
  3273.                 if(existsModuloInAttesaRispostaApplicativa) {
  3274.                     OpenSPCoop2Message connettoreMsgRequest = connettoreMsg.getRequestMessage(requestInfo, pddContext);
  3275.                     String requestReadTimeout = null;
  3276.                     String responseReadTimeout = null;
  3277.                     if(pddContext!=null && pddContext.containsKey(TimeoutInputStream.ERROR_MSG_KEY)) {
  3278.                         String timeoutMessage = PdDContext.getValue(TimeoutInputStream.ERROR_MSG_KEY, pddContext);
  3279.                         if(timeoutMessage!=null && timeoutMessage.startsWith(CostantiPdD.PREFIX_TIMEOUT_REQUEST)) {
  3280.                             requestReadTimeout = timeoutMessage;
  3281.                         }
  3282.                         else if(timeoutMessage!=null && timeoutMessage.startsWith(CostantiPdD.PREFIX_TIMEOUT_RESPONSE)) {
  3283.                             responseReadTimeout = timeoutMessage;
  3284.                         }
  3285.                     }
  3286.                     String requestLimitExceeded = null;
  3287.                     String responseLimitExceeded = null;
  3288.                     if(pddContext!=null && pddContext.containsKey(LimitedInputStream.ERROR_MSG_KEY)) {
  3289.                         String limitedExceededMessage = PdDContext.getValue(LimitedInputStream.ERROR_MSG_KEY, pddContext);
  3290.                         if(limitedExceededMessage!=null && limitedExceededMessage.startsWith(CostantiPdD.PREFIX_LIMITED_REQUEST)) {
  3291.                             requestLimitExceeded = limitedExceededMessage;
  3292.                         }
  3293.                         else if(limitedExceededMessage!=null && limitedExceededMessage.startsWith(CostantiPdD.PREFIX_LIMITED_RESPONSE)) {
  3294.                             responseLimitExceeded = limitedExceededMessage;
  3295.                         }
  3296.                     }
  3297.                     if(connettoreMsgRequest.getParseException() != null || 
  3298.                             requestReadTimeout!=null || 
  3299.                             requestLimitExceeded!=null){
  3300.                         
  3301.                         ParseException parseException = null;
  3302.                         Throwable tParsing = null;
  3303.                         String errorMsg = null;
  3304.                         if(requestReadTimeout != null) {
  3305.                             tParsing = (TimeoutIOException) pddContext.getObject(TimeoutInputStream.EXCEPTION_KEY);
  3306.                             errorMsg = tParsing.getMessage();
  3307.                         }
  3308.                         else if(requestLimitExceeded != null) {
  3309.                             tParsing = (LimitExceededIOException) pddContext.getObject(LimitedInputStream.EXCEPTION_KEY);
  3310.                             errorMsg = tParsing.getMessage();
  3311.                         }
  3312.                         else {
  3313.                             parseException = connettoreMsgRequest.getParseException();
  3314.                             tParsing = parseException.getParseException();
  3315.                             errorMsg = tParsing.getMessage();
  3316.                         }
  3317.                         
  3318.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  3319.                         IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  3320.                         if(requestReadTimeout!=null) {
  3321.                             integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  3322.                         }
  3323.                         else if(requestLimitExceeded!=null) {
  3324.                             integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  3325.                         }
  3326.                         else if(connettoreMsgRequest.getParseException().getSourceException()!=null &&
  3327.                                 TimeoutIOException.isTimeoutIOException(connettoreMsgRequest.getParseException().getSourceException())) {
  3328.                             integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  3329.                         }
  3330.                         else if(connettoreMsgRequest.getParseException().getSourceException()!=null &&
  3331.                                 LimitExceededIOException.isLimitExceededIOException(connettoreMsgRequest.getParseException().getSourceException())) {
  3332.                             integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  3333.                         }
  3334.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  3335.                         if(localForwardEngine!=null) {
  3336.                             localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  3337.                         }
  3338.                         this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3339.                                 ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.getErrore432_MessaggioRichiestaMalformato(tParsing),
  3340.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, 
  3341.                                 tParsing,parseException,
  3342.                                 pddContext);
  3343.                         
  3344.                         openspcoopstate.releaseResource();
  3345.                         esito.setEsitoInvocazione(true); 
  3346.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,errorMsg);
  3347.                         return esito;
  3348.                     } else if(responseMessage==null && 
  3349.                             !pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)){
  3350.                         // Genero una risposta di errore
  3351.                         IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.SERVICE_UNAVAILABLE;
  3352.                         if(eccezioneProcessamentoConnettore!=null && motivoErroreConsegna!=null) {
  3353.                             if(responseReadTimeout!=null) {
  3354.                                 integrationFunctionError = IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT;
  3355.                                 pddContext.removeObject(TimeoutInputStream.ERROR_MSG_KEY);
  3356.                                 pddContext.removeObject(TimeoutInputStream.EXCEPTION_KEY);
  3357.                             }
  3358.                             else if(responseLimitExceeded!=null) {
  3359.                                 integrationFunctionError = IntegrationFunctionError.RESPONSE_SIZE_EXCEEDED;
  3360.                                 pddContext.removeObject(LimitedInputStream.ERROR_MSG_KEY);
  3361.                                 pddContext.removeObject(LimitedInputStream.EXCEPTION_KEY);
  3362.                             }
  3363.                             else if(this.propertiesReader.isServiceUnavailableReadTimedOut(motivoErroreConsegna)){
  3364.                                 integrationFunctionError = IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT;
  3365.                             }
  3366.                         }
  3367.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  3368.                         if(localForwardEngine!=null) {
  3369.                             localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  3370.                         }
  3371.                         this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3372.                                 ErroriIntegrazione.ERRORE_516_CONNETTORE_UTILIZZO_CON_ERRORE.get516_ServizioApplicativoNonDisponibile(),
  3373.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, eccezioneProcessamentoConnettore,
  3374.                                 (responseMessage!=null ? responseMessage.getParseException() : null),
  3375.                                 pddContext);
  3376.                     
  3377.                         openspcoopstate.releaseResource();
  3378.                         esito.setEsitoInvocazione(true); 
  3379.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,messaggioErroreConsegnaConnettore);
  3380.                         return esito;
  3381.                     } else if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION) ||
  3382.                             responseMessage.getParseException() != null ||
  3383.                             responseReadTimeout!=null ||
  3384.                             responseLimitExceeded!=null){
  3385.                         
  3386.                         ParseException parseException = null;
  3387.                         Throwable tParsing = null;
  3388.                         String errorMsg = null;
  3389.                         if(responseReadTimeout != null) {
  3390.                             tParsing = (TimeoutIOException) pddContext.getObject(TimeoutInputStream.EXCEPTION_KEY);
  3391.                             errorMsg = tParsing.getMessage();
  3392.                         }
  3393.                         else if(responseLimitExceeded != null) {
  3394.                             tParsing = (LimitExceededIOException) pddContext.getObject(LimitedInputStream.EXCEPTION_KEY);
  3395.                             errorMsg = tParsing.getMessage();
  3396.                         }
  3397.                         else if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)){
  3398.                             parseException = (ParseException) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  3399.                             tParsing = parseException.getParseException();
  3400.                             errorMsg = tParsing.getMessage();
  3401.                         }
  3402.                         else {
  3403.                             parseException = responseMessage.getParseException();
  3404.                             tParsing = parseException.getParseException();
  3405.                             errorMsg = tParsing.getMessage();
  3406.                         }
  3407.                         
  3408.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  3409.                         IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT;
  3410.                         if(responseReadTimeout!=null) {
  3411.                             integrationFunctionError = IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT;
  3412.                         }
  3413.                         else if(responseLimitExceeded!=null) {
  3414.                             integrationFunctionError = IntegrationFunctionError.RESPONSE_SIZE_EXCEEDED;
  3415.                         }
  3416.                         else if(parseException.getSourceException()!=null &&
  3417.                                 TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  3418.                             integrationFunctionError = IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT;
  3419.                         }
  3420.                         else if(parseException.getSourceException()!=null &&
  3421.                                 LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  3422.                             integrationFunctionError = IntegrationFunctionError.RESPONSE_SIZE_EXCEEDED;
  3423.                         }
  3424.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  3425.                         if(localForwardEngine!=null) {
  3426.                             localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  3427.                         }
  3428.                         this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3429.                                 ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.getErrore440_MessaggioRispostaMalformato(tParsing),
  3430.                                 idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, 
  3431.                                 tParsing,parseException,
  3432.                                 pddContext);
  3433.                         
  3434.                         openspcoopstate.releaseResource();
  3435.                         esito.setEsitoInvocazione(true); 
  3436.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,errorMsg);
  3437.                         return esito;
  3438.                     }
  3439.                     
  3440.                 }else {
  3441.                     if(riconsegna){
  3442.                         ejbUtils.rollbackMessage(messaggioErroreConsegnaConnettore,dataRiconsegna,servizioApplicativo, esito);
  3443.                         esito.setEsitoInvocazione(false); 
  3444.                         esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,messaggioErroreConsegnaConnettore);
  3445.                     }else{
  3446.                         ejbUtils.releaseInboxMessage(true); 
  3447.                         esito.setEsitoInvocazione(true); 
  3448.                         esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,messaggioErroreConsegnaConnettore);
  3449.                     }
  3450.                     openspcoopstate.releaseResource();
  3451.                     this.log.info(ConsegnaContenutiApplicativi.ID_MODULO + " errore avvenuto durante la consegna");

  3453.                     return esito;
  3454.                 }
  3455.             }





























  3485.             /* ----------- Gestione della risposta applicativa da eseguire nei seguenti casi:
  3486.                AsincronoSimmetrico (InvocazioneServizio e ConsegnaRisposta):
  3487.                   se isRicevutaApplicativa
  3488.                      - Bisogna aspettare una risposta applicativa 
  3489.                      - Bisogna quindi generare un busta per la ricevuta asincrona
  3490.                   altrimenti
  3491.                      - Non serve aspettare una risposta applicativa 
  3492.                      - Se si riceve un Fault, il fault viene loggato.
  3493.                AsincronoAsimmetrico(InvocazioneServizio): 
  3494.                   se isRicevutaApplicativa
  3495.                      - Bisogna aspettare una risposta applicativa 
  3496.                      - Bisogna quindi generare un busta per la ricevuta asincrona
  3497.                   altrimenti
  3498.                      - Non serve aspettare una risposta applicativa 
  3499.                      - Se si riceve un Fault, il fault viene loggato.
  3500.                AsincronoAsimmetrico (Polling):
  3501.                   - Bisogna aspettare una risposta applicativa 'sincrona'
  3502.                   - Bisogna quindi generare un busta della risposta contenente il risultato del polling          
  3503.                Sincrono:
  3504.                   - Bisogna aspettare una risposta applicativa sincrona
  3505.                   - Bisogna quindi generare un busta della risposta  sincrona
  3506.                Altro (OneWay):
  3507.                   - Non bisogna aspettare una risposta applicativa
  3508.                   - Se si riceve un Fault, il fault viene loggato.
  3509.             ------------- */
  3510.             
  3511.             msgDiag.mediumDebug("Registrazione eventuale fault...");
  3512.             // Effettuo log del fault
  3513.             if(soapFault!=null){
  3514.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, SoapUtils.safe_toString(faultMessageFactory, soapFault, this.log));
  3515.                 msgDiag.logPersonalizzato("ricezioneSoapFault");
  3516.             }
  3517.             else if(restProblem!=null){
  3518.                 // Se non l'ho gia indicato nel motivo di errore, registro il fault
  3519.                 msgDiag.addKeyword(CostantiPdD.KEY_REST_PROBLEM, restProblem.getRaw());
  3520.                 msgDiag.logPersonalizzato("ricezioneRestProblem");
  3521.             }
  3522.             
  3523.             if(existsModuloInAttesaRispostaApplicativa){

  3525.                 if( !localForward && richiestaApplicativa!=null && Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario())){

  3527.                     // Oneway in modalita sincrona

  3529.                     boolean returnProtocolReply = false;        
  3530.                     Busta bustaHTTPReply = null;
  3531.                     
  3532.                     boolean consegnaAffidabile = false;
  3533.                     switch (protocolManager.getConsegnaAffidabile(bustaIndicazioneConsegnaInOrdine)) {
  3534.                     case ABILITATA:
  3535.                         consegnaAffidabile = true;
  3536.                         break;
  3537.                     case DISABILITATA:
  3538.                         consegnaAffidabile = false;
  3539.                         break;
  3540.                     default:
  3541.                         consegnaAffidabile = bustaRichiesta.isConfermaRicezione() &&
  3542.                             this.propertiesReader.isGestioneRiscontri(implementazionePdDMittente);
  3543.                         break;
  3544.                     }
  3545.                     
  3546.                     if(consegnaAffidabile){
  3547.                         msgDiag.mediumDebug("Gestione eventuali riscontri da inviare...");
  3548.                         if(ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) ) {   
  3549.                             TipoOraRegistrazione tipoOraRegistrazione = this.propertiesReader.getTipoTempoBusta(implementazionePdDMittente);
  3550.                             bustaHTTPReply = bustaRichiesta.invertiBusta(tipoOraRegistrazione,
  3551.                                     protocolFactory.createTraduttore().toString(tipoOraRegistrazione));

  3553.                             // Riscontro ad hoc
  3554.                             Riscontro r = new Riscontro();
  3555.                             r.setID(bustaRichiesta.getID());
  3556.                             r.setOraRegistrazione(bustaHTTPReply.getOraRegistrazione());
  3557.                             r.setTipoOraRegistrazione(this.propertiesReader.getTipoTempoBusta(implementazionePdDMittente));
  3558.                             bustaHTTPReply.addRiscontro(r);
  3559.                             bustaHTTPReply.setTipoServizioRichiedenteBustaDiServizio(bustaRichiesta.getTipoServizio());
  3560.                             bustaHTTPReply.setServizioRichiedenteBustaDiServizio(bustaRichiesta.getServizio());
  3561.                             bustaHTTPReply.setVersioneServizioRichiedenteBustaDiServizio(bustaRichiesta.getVersioneServizio());
  3562.                             bustaHTTPReply.setAzioneRichiedenteBustaDiServizio(bustaRichiesta.getAzione());

  3564.                             returnProtocolReply = true;
  3565.                         }
  3566.                     }

  3568.                     if( returnProtocolReply == false){

  3570.                         if(soapFault!=null || restProblem!=null){
  3571.                             // Devo ritornare il SoapFault
  3572.                             msgDiag.mediumDebug("Invio messaggio di fault a Ricezione/Consegna ContenutiApplicativi...");
  3573.                             msgResponse = ejbUtils.sendSOAPFault(richiestaApplicativa.getIdModuloInAttesa(),responseMessage);
  3574.                         }
  3575.                         else{
  3576.                             // Invio sblocco se e' attesa una risposta dal modulo
  3577.                             // Se non e' abilitato la risposta su di una nuova connessione, e l'indirizzo telematico 
  3578.                             // non e' abilitato o cmq non presente, allora devo inviare lo sblocco
  3579.                             msgDiag.mediumDebug("Invio messaggio di sblocco a RicezioneBuste...");
  3580.                             msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  3581.                         }
  3582.                     }
  3583.                     else{

  3585.                         // Invio risposta immediata in seguito alla richiesta ricevuta
  3586.                         if(soapFault!=null || restProblem!=null){
  3587.                             // Devo ritornare il SoapFault
  3588.                             msgDiag.mediumDebug("Invio messaggio di fault a Ricezione/Consegna ContenutiApplicativi...");
  3589.                             msgResponse = ejbUtils.sendSOAPFault(richiestaApplicativa.getIdModuloInAttesa(),responseMessage);
  3590.                         }
  3591.                         else{
  3592.                             msgDiag.mediumDebug("Invio messaggio a Ricezione/Consegna ContenutiApplicativi...");
  3593.                             msgResponse = ejbUtils.buildAndSendBustaRisposta(richiestaApplicativa.getIdModuloInAttesa(),bustaHTTPReply,
  3594.                                     MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  3595.                                             requestInfo.getProtocolRequestMessageType(), MessageRole.RESPONSE),profiloGestione,
  3596.                                     idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);
  3597.                         }
  3598.                     }
  3599.                 }
  3600.                 else{
  3601.                     /*-- analisi risposta per riferimento -- */
  3602.                     if(rispostaPerRiferimento && !errorConsegna){
  3603.                         msgDiag.mediumDebug("Gestione risposta per riferimento...");
  3604.                         boolean rilasciaRisorsa = false;
  3605.                         if(openspcoopstate instanceof OpenSPCoopStateless){
  3606.                             OpenSPCoopStateless state = (OpenSPCoopStateless) openspcoopstate;
  3607.                             // La risposta per riferimento ha bisogno della connessione.
  3608.                             if (state.resourceReleased()){
  3609.                                 // Risorsa e' rilasciata se siamo in RinegoziamentoConnessione
  3610.                                 state.setUseConnection(true);
  3611.                                 state.updateResource(idTransazione);
  3612.                                 rilasciaRisorsa = true;
  3613.                             }else{
  3614.                                 // Non siamo in RinegoziamentoConnessione, basta dire di utilizzare la connessione
  3615.                                 state.setUseConnection(true);
  3616.                             }
  3617.                         }
  3618.                         try{
  3619.                             if(MessageType.SOAP_11.equals(responseMessage.getMessageType())==false){
  3620.                                 throw new Exception("Tipo di messaggio ["+responseMessage.getMessageType()+"] non supportato");
  3621.                             }
  3622.                             
  3623.                             // 1. Read IDMessaggio
  3624.                             // L'id del messaggio deve essere prelevato dal messaggio di risposta ritornato dal gestore eventi.
  3625.                             Node prelevaMessaggioResponse = responseMessage.castAsSoap().getSOAPBody().getFirstChild();
  3626.                             if(prelevaMessaggioResponse==null)
  3627.                                 throw new Exception("Identificativo non presente [prelevaMessaggioResponse]");
  3628.                             Node prelevaMessaggioReturn = prelevaMessaggioResponse.getFirstChild();
  3629.                             if(prelevaMessaggioReturn==null)
  3630.                                 throw new Exception("Identificativo non presente [prelevaMessaggioReturn]");
  3631.                             Node idMessaggioPresenteNelRepositoryNode = prelevaMessaggioReturn.getFirstChild();
  3632.                             if(idMessaggioPresenteNelRepositoryNode==null)
  3633.                                 throw new Exception("Identificativo non presente [idMessaggioPresenteNelRepositoryNode]");
  3634.                             byte[] idMessaggioPresenteNelRepositoryByte = Base64Utilities.decode(idMessaggioPresenteNelRepositoryNode.getNodeValue());
  3635.                             String idMessaggioPresenteNelRepository = new String(idMessaggioPresenteNelRepositoryByte);
  3636.                             //if(idMessaggioPresenteNelRepository==null)
  3637.                             //  throw new Exception("Identificativo non presente");


  3640.                             // 2. get Messaggio dal Repository
  3641.                             GestoreMessaggi gestoreMsgFromRepository = new GestoreMessaggi(openspcoopstate, false, idMessaggioPresenteNelRepository,Costanti.INBOX,msgDiag,pddContext);
  3642.                             OpenSPCoop2Message msgFromRepository = gestoreMsgFromRepository.getMessage();
  3643.                             //if(idMessaggioPresenteNelRepository==null)
  3644.                             //  throw new Exception("Messaggio non presente nel repository");

  3646.                             // 3. prendo body applicativo
  3647.                             byte[] bodyApplicativoPrecedentementePubblicato = TunnelSoapUtils.sbustamentoMessaggio(msgFromRepository);

  3649.                             // 4. Inserimento dei byte del body applicativo al posto dell'ID,
  3650.                             //    nel msg ritornato dal GestoreEventi.
  3651.                             //    La variabile responseMessage deve contenere il messaggio Soap che sara' ritornato a chi ha richiesto un messaggio
  3652.                             responseMessage = gestoreMsgFromRepository.buildRispostaPrelevamentoMessaggio_RepositoryMessaggi(bodyApplicativoPrecedentementePubblicato,msgFromRepository.getMessageType());
  3653.                             
  3654.                         }catch(Exception e){
  3655.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, ("risposta per riferimento non costruita, "+e.getMessage()));
  3656.                             if(bustaRichiesta.getMittente()!=null && bustaRichiesta.getTipoMittente()!=null){
  3657.                                 msgDiag.logPersonalizzato("consegnaConErrore");
  3658.                             }
  3659.                             else{
  3660.                                 msgDiag.logPersonalizzato("consegnaConErrore.mittenteAnonimo");
  3661.                             }
  3662.                             
  3663.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3664.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3665.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_511_READ_RESPONSE_MSG),
  3666.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  3667.                                     (responseMessage!=null ? responseMessage.getParseException() : null),
  3668.                                     pddContext);
  3669.                         
  3670.                             esito.setEsitoInvocazione(true); 
  3671.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "risposta per riferimento non costruita, "+e.getMessage());
  3672.                             openspcoopstate.releaseResource();
  3673.                             return esito;
  3674.                         }finally{
  3675.                             if(openspcoopstate instanceof OpenSPCoopStateless){
  3676.                                 OpenSPCoopStateless state = (OpenSPCoopStateless) openspcoopstate;
  3677.                                 if(rilasciaRisorsa){
  3678.                                     state.releaseResource();
  3679.                                 }
  3680.                                 state.setUseConnection(false);
  3681.                             }
  3682.                         }
  3683.                     }

  3685.                     msgDiag.mediumDebug("Gestione risposta...");
  3686.                     boolean rispostaVuotaValidaPerAsincroniStateless_modalitaAsincrona = false;
  3687.                     if(responseMessage == null && 
  3688.                             !(localForward && richiestaApplicativa!=null && Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario())) ){

  3690.                         if( (Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ||
  3691.                                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ||
  3692.                                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione) ) 
  3693.                                 && portaDiTipoStateless
  3694.                                 && (!isRicevutaAsincrona) ){
  3695.                             rispostaVuotaValidaPerAsincroniStateless_modalitaAsincrona = true;
  3696.                             responseMessage = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  3697.                                     requestInfo.getProtocolRequestMessageType(), MessageRole.RESPONSE); // Costruisce messaggio vuoto per inserire busta (ricevuta asincrona)
  3698.                         }
  3699.                         else{
  3700.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, ("risposta applicativa attesa ma non ricevuta"));
  3701.                             if(bustaRichiesta.getMittente()!=null && bustaRichiesta.getTipoMittente()!=null){
  3702.                                 msgDiag.logPersonalizzato("consegnaConErrore");
  3703.                             }
  3704.                             else{
  3705.                                 msgDiag.logPersonalizzato("consegnaConErrore.mittenteAnonimo");
  3706.                             }
  3707.                             
  3708.                             ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.EXPECTED_RESPONSE_NOT_FOUND);
  3709.                             if(localForwardEngine!=null) {
  3710.                                 localForwardEngine.setIntegrationFunctionError(IntegrationFunctionError.EXPECTED_RESPONSE_NOT_FOUND);
  3711.                             }
  3712.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3713.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3714.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_517_RISPOSTA_RICHIESTA_NON_RITORNATA),
  3715.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, null,
  3716.                                     (responseMessage!=null ? responseMessage.getParseException() : null),
  3717.                                     pddContext);
  3718.                             
  3719.                             openspcoopstate.releaseResource();
  3720.                             esito.setEsitoInvocazione(true); 
  3721.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"risposta applicativa attesa ma non ricevuta");

  3723.                             return esito;
  3724.                         }

  3726.                     }
  3727.                     
  3728.                     if(rispostaVuotaValidaPerAsincroniStateless_modalitaAsincrona==false
  3729.                             && transazioneApplicativoServer==null // non ha senso per le notifiche asincrone tutte le operazioni presenti in questo corpo (validazione, correlazione, header di integrazione)
  3730.                             ){
  3731.                         
  3732.                         if(validazioneContenutoApplicativoApplicativo!=null && validazioneContenutoApplicativoApplicativo.getTipo()!=null){
  3733.                             String tipo = ValidatoreMessaggiApplicativi.getTipo(validazioneContenutoApplicativoApplicativo);
  3734.                             //this.msgContext.getIntegrazione().setTipoValidazioneContenuti(tipo);
  3735.                             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_CONTENUTI, tipo);
  3736.                             msgDiag.addKeyword(CostantiPdD.KEY_DETAILS_VALIDAZIONE_CONTENUTI,"");
  3737.                         }
  3738.                         
  3739.                         // Verifica xsd  (Se siamo in un caso di risposta applicativa presente)
  3740.                         if(
  3741.                                 (responseMessage!=null)
  3742.                                 &&
  3743.                                 (validazioneContenutoApplicativoApplicativo!=null) 
  3744.                                 &&
  3745.                                 (
  3746.                                         CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(validazioneContenutoApplicativoApplicativo.getStato())
  3747.                                         ||
  3748.                                         CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())
  3749.                                 ) 
  3750.                             ){

  3752.                             if(transactionNullable!=null) {
  3753.                                 transactionNullable.getTempiElaborazione().startValidazioneRisposta();
  3754.                             }
  3755.                             ByteArrayInputStream binXSD = null;
  3756.                             try{
  3757.                                 boolean hasContent = false;
  3758.                                 boolean isFault = false;
  3759.                                 if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())){
  3760.                                     OpenSPCoop2SoapMessage soapMsg = responseMessage.castAsSoap();
  3761.                                     hasContent = !soapMsg.isSOAPBodyEmpty();
  3762.                                     isFault = soapMsg.isFault();
  3763.                                 }
  3764.                                 else{
  3765.                                     //org.openspcoop2.message.OpenSPCoop2RestMessage<?> restMsg = responseMessage.castAsRest();
  3766.                                     //hasContent = restMsg.hasContent();
  3767.                                     hasContent = true; // devo controllare gli header etc...
  3768.                                     // fix: i problem detail devono far parte dell'interfaccia openapi
  3769.                                     //isFault = restMsg.isProblemDetailsForHttpApis_RFC7807() || MessageRole.FAULT.equals(responseMessage.getMessageRole());
  3770.                                     isFault = MessageRole.FAULT.equals(responseMessage.getMessageRole());
  3771.                                 }
  3772.                                 
  3773.                                 boolean validazioneAbilitata = true;
  3774.                                 if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())){
  3775.                                     validazioneAbilitata = hasContent && (isFault==false);
  3776.                                 }
  3777.                                 else {
  3778.                                     validazioneAbilitata = ValidatoreMessaggiApplicativiRest.isValidazioneAbilitata(this.log,proprietaPorta, responseMessage, codiceRitornato);
  3779.                                 }
  3780.                                 if( validazioneAbilitata ){
  3781.                                     
  3782.                                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaInCorso");
  3783.                                     
  3784.                                     boolean readInterface = CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo());
  3785.                                     IDServizio idSValidazioneXSD = idServizio;
  3786.                                     if(servizioHeaderIntegrazione!=null){
  3787.                                         idSValidazioneXSD = servizioHeaderIntegrazione;
  3788.                                     }
  3789.                                     
  3790.                                     if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())){
  3791.                                     
  3792.                                         // Accept mtom message
  3793.                                         List<MtomXomReference> xomReferences = null;
  3794.                                         if(StatoFunzionalita.ABILITATO.equals(validazioneContenutoApplicativoApplicativo.getAcceptMtomMessage())){
  3795.                                             msgDiag.mediumDebug("Validazione xsd della risposta (mtomFastUnpackagingForXSDConformance)...");
  3796.                                             xomReferences = responseMessage.castAsSoap().mtomFastUnpackagingForXSDConformance();
  3797.                                         }
  3798.                                         
  3799.                                         // Init Validatore
  3800.                                         msgDiag.mediumDebug("Validazione della risposta (initValidator)...");
  3801.                                         ValidatoreMessaggiApplicativi validatoreMessaggiApplicativi = 
  3802.                                             new ValidatoreMessaggiApplicativi(registroServiziManager,idSValidazioneXSD,
  3803.                                                     responseMessage,readInterface,
  3804.                                                     this.propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione(),
  3805.                                                     proprietaPorta,
  3806.                                                     pddContext);
  3807.     
  3808.                                         // Validazione WSDL 
  3809.                                         if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo()) 
  3810.                                                 ||
  3811.                                                 CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  3812.                                         ){
  3813.                                             msgDiag.mediumDebug("Validazione wsdl della risposta ...");
  3814.                                             validatoreMessaggiApplicativi.validateWithWsdlLogicoImplementativo(false);
  3815.                                         }
  3816.                                         
  3817.                                         // Validazione XSD
  3818.                                         msgDiag.mediumDebug("Validazione xsd della risposta ...");
  3819.                                         validatoreMessaggiApplicativi.validateWithWsdlDefinitorio(false);
  3820.                                         
  3821.                                         // Validazione WSDL (Restore Original Document)
  3822.                                         if (CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  3823.                                             || CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutoApplicativoApplicativo.getTipo())) {
  3824.                                             if(this.propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione() &&
  3825.                                                     this.propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione()){
  3826.                                                 msgDiag.mediumDebug("Ripristino elementi modificati per supportare validazione wsdl della risposta ...");
  3827.                                                 validatoreMessaggiApplicativi.restoreOriginalDocument(false);
  3828.                                             }
  3829.                                         }
  3830.                                         
  3831.                                         // Ripristino struttura messaggio con xom
  3832.                                         if(xomReferences!=null && xomReferences.size()>0){
  3833.                                             msgDiag.mediumDebug("Validazione xsd della risposta (mtomRestoreAfterXSDConformance)...");
  3834.                                             responseMessage.castAsSoap().mtomRestoreAfterXSDConformance(xomReferences);
  3835.                                         }
  3836.                                         
  3837.                                     }
  3838.                                     else {
  3839.                                         
  3840.                                         // Init Validatore
  3841.                                         msgDiag.mediumDebug("Validazione della risposta (initValidator)...");
  3842.                                         ValidatoreMessaggiApplicativiRest validatoreMessaggiApplicativi = 
  3843.                                             new ValidatoreMessaggiApplicativiRest(registroServiziManager, idSValidazioneXSD, responseMessage, readInterface, proprietaPorta, 
  3844.                                                     protocolFactory, pddContext);
  3845.                                         
  3846.                                         if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(validazioneContenutoApplicativoApplicativo.getTipo()) &&
  3847.                                                 responseMessage.castAsRest().hasContent()) {
  3848.                                             
  3849.                                             // Validazione XSD
  3850.                                             msgDiag.mediumDebug("Validazione xsd della risposta ...");
  3851.                                             validatoreMessaggiApplicativi.validateWithSchemiXSD(false);
  3852.                                             
  3853.                                         }
  3854.                                         else {
  3855.                                             
  3856.                                             // Validazione Interface
  3857.                                             validatoreMessaggiApplicativi.validateResponseWithInterface(consegnaMessagePrimaTrasformazione, true);
  3858.                                             
  3859.                                         }
  3860.                                         
  3861.                                     }

  3863.                                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaEffettuata");
  3864.                                 }
  3865.                                 else{
  3866.                                     if(hasContent==false){
  3867.                                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS_VALIDAZIONE_CONTENUTI,CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_VALIDAZIONE_SOAP_BODY_NON_PRESENTE);
  3868.                                         msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaDisabilitata");
  3869.                                     }
  3870.                                     else if (isFault ){
  3871.                                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS_VALIDAZIONE_CONTENUTI,CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_VALIDAZIONE_SOAP_FAULT_PRESENTE);
  3872.                                         msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaDisabilitata");
  3873.                                     }
  3874.                                 }

  3876.                             }catch(ValidatoreMessaggiApplicativiException ex){
  3877.                                 msgDiag.addKeywordErroreProcessamento(ex);
  3878.                                 this.log.error("[ValidazioneContenutiApplicativi Risposta] "+ex.getMessage(),ex);
  3879.                                 if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())) {
  3880.                                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaNonRiuscita.warningOnly");
  3881.                                 }
  3882.                                 else {
  3883.                                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaNonRiuscita");
  3884.                                 }
  3885.                                 if(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato()) == false){
  3886.                                     
  3887.                                     // validazione abilitata
  3888.                                     
  3889.                                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_RISPOSTA, "true");
  3890.                                     
  3891.                                     IntegrationFunctionError integrationFunctionError = null;
  3892.                                     if(ex.getErrore()!=null &&
  3893.                                             (
  3894.                                                     //CodiceErroreIntegrazione.CODICE_417_COSTRUZIONE_VALIDATORE_TRAMITE_INTERFACCIA_FALLITA.equals(ex.getErrore().getCodiceErrore()) ||
  3895.                                                     CodiceErroreIntegrazione.CODICE_419_VALIDAZIONE_RISPOSTA_TRAMITE_INTERFACCIA_FALLITA.equals(ex.getErrore().getCodiceErrore()) 
  3896.                                             )
  3897.                                         ){
  3898.                                         integrationFunctionError = IntegrationFunctionError.INVALID_RESPONSE_CONTENT;
  3899.                                     }
  3900.                                     else{
  3901.                                         integrationFunctionError = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  3902.                                     }
  3903.                                     
  3904.                                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  3905.                                     if(localForwardEngine!=null) {
  3906.                                         localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  3907.                                     }
  3908.                                     
  3909.                                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3910.                                             ex.getErrore(),
  3911.                                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, ex,
  3912.                                             (responseMessage!=null ? responseMessage.getParseException() : null),
  3913.                                             pddContext);
  3914.                                     
  3915.                                     openspcoopstate.releaseResource();
  3916.                                     esito.setEsitoInvocazione(true); 
  3917.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  3918.                                             msgDiag.getMessaggio_replaceKeywords("validazioneContenutiApplicativiNonRiuscita"));
  3919.                                     return esito;
  3920.                                 }
  3921.                             }catch(Exception ex){
  3922.                                 msgDiag.addKeywordErroreProcessamento(ex);
  3923.                                 this.log.error("Riscontrato errore durante la validazione xsd della risposta applicativa",ex);
  3924.                                 if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())) {
  3925.                                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaNonRiuscita.warningOnly");
  3926.                                 }
  3927.                                 else {
  3928.                                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaNonRiuscita");
  3929.                                 }
  3930.                                 if(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato()) == false){
  3931.                                     
  3932.                                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_RISPOSTA, "true");
  3933.                                     
  3934.                                     // validazione abilitata
  3935.                                     
  3936.                                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  3937.                                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3938.                                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_531_VALIDAZIONE_TRAMITE_INTERFACCIA_FALLITA),
  3939.                                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, ex,
  3940.                                             (responseMessage!=null ? responseMessage.getParseException() : null),
  3941.                                             pddContext);
  3942.                                 
  3943.                                     openspcoopstate.releaseResource();
  3944.                                     esito.setEsitoInvocazione(true); 
  3945.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  3946.                                             msgDiag.getMessaggio_replaceKeywords("validazioneContenutiApplicativiNonRiuscita")); 
  3947.                                     return esito;
  3948.                                 }
  3949.                             }finally{
  3950.                                 if(transactionNullable!=null) {
  3951.                                     transactionNullable.getTempiElaborazione().endValidazioneRisposta();
  3952.                                 }
  3953.                                 if(binXSD!=null){
  3954.                                     try{
  3955.                                         binXSD.close();
  3956.                                     }catch(Exception e){
  3957.                                         // close
  3958.                                     }   
  3959.                                 }
  3960.                             }
  3961.                         }
  3962.                         else{
  3963.                             msgDiag.logPersonalizzato("validazioneContenutiApplicativiRispostaDisabilitata");
  3964.                         }


  3967.                         
  3968.                         /* ------------  Header integrazione Risposta ------------- */
  3969.                         
  3970.                         HeaderIntegrazione headerIntegrazioneRisposta = new HeaderIntegrazione(idTransazione);      
  3971.                         InResponsePAMessage inResponsePAMessage = new InResponsePAMessage();
  3972.                         inResponsePAMessage.setBustaRichiesta(bustaRichiesta);
  3973.                         inResponsePAMessage.setMessage(responseMessage);
  3974.                         if(pa!=null)
  3975.                             inResponsePAMessage.setPortaApplicativa(pa);
  3976.                         else
  3977.                             inResponsePAMessage.setPortaDelegata(pd);
  3978.                         inResponsePAMessage.setHeaders(connectorSender.getHeaderTrasporto());
  3979.                         inResponsePAMessage.setServizio(outRequestPAMessage.getServizio());
  3980.                         inResponsePAMessage.setSoggettoMittente(outRequestPAMessage.getSoggettoMittente());
  3981.                         Utilities.printFreeMemory("ConsegnaContenutiApplicativi - Gestione Header Integrazione... ");                   
  3982.                         for(int i=0; i<tipiIntegrazione.length;i++){
  3983.                             try{
  3984.                                 IGestoreIntegrazionePA gestore = null;
  3985.                                 try{
  3986.                                     gestore = (IGestoreIntegrazionePA) this.pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazione[i]);
  3987.                                 }catch(Exception e){
  3988.                                     throw e;
  3989.                                 }
  3990.                                 if(gestore!=null){
  3991.                                     String classType = null;
  3992.                                     try {
  3993.                                         classType = gestore.getClass().getName();
  3994.                                         AbstractCore.init(gestore, pddContext, protocolFactory);
  3995.                                     }catch(Exception e){
  3996.                                         throw new Exception("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  3997.                                                 "] da utilizzare per la gestione dell'integrazione (Risposta) delle erogazione di tipo ["+tipiIntegrazione[i]+"]: "+e.getMessage());
  3998.                                     }
  3999.                                     if(responseMessage!=null){
  4000.                                         gestore.readInResponseHeader(headerIntegrazioneRisposta,inResponsePAMessage);
  4001.                                     }else if( ! (gestore instanceof IGestoreIntegrazionePASoap) ){
  4002.                                         gestore.readInResponseHeader(headerIntegrazioneRisposta,inResponsePAMessage);
  4003.                                     }
  4004.                                 }
  4005.                             } catch (Exception e) {
  4006.                                 this.log.debug("Errore durante la lettura dell'header di integrazione ["+ tipiIntegrazione[i]
  4007.                                         + "]: "+ e.getMessage(),e);
  4008.                                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazione[i]);
  4009.                                 msgDiag.addKeywordErroreProcessamento(e);
  4010.                                 msgDiag.logPersonalizzato("headerIntegrazione.letturaFallita");
  4011.                             }
  4012.                         }
  4013.                         
  4014.                         /* ------------  Correlazione Applicativa Risposta ------------- */
  4015.                         if(correlazioneApplicativaRisposta!=null){
  4016.                             Utilities.printFreeMemory("ConsegnaContenutiApplicativi - CorrelazioneApplicativa... ");    
  4017.                             GestoreCorrelazioneApplicativa gestoreCorrelazione = null;
  4018.                             try{
  4019.                                 
  4020.                                 GestoreCorrelazioneApplicativaConfig caConfig = new GestoreCorrelazioneApplicativaConfig();
  4021.                                 caConfig.setState(openspcoopstate.getStatoRisposta());
  4022.                                 caConfig.setAlog(this.log);
  4023.                                 caConfig.setSoggettoFruitore(soggettoFruitore);
  4024.                                 caConfig.setIdServizio(idServizio);
  4025.                                 caConfig.setBusta(bustaRichiesta);
  4026.                                 caConfig.setServizioApplicativo(servizioApplicativo);
  4027.                                 caConfig.setProtocolFactory(protocolFactory);
  4028.                                 caConfig.setTransaction(transactionNullable);
  4029.                                 caConfig.setPddContext(pddContext);
  4030.                                 
  4031.                                 if(pa!=null) {
  4032.                                     caConfig.setPa(pa);
  4033.                                     gestoreCorrelazione = new GestoreCorrelazioneApplicativa(caConfig);
  4034.                                 }
  4035.                                 else if(pd!=null) {
  4036.                                     caConfig.setPd(pd);
  4037.                                     gestoreCorrelazione = new GestoreCorrelazioneApplicativa(caConfig);
  4038.                                 }
  4039.                                 
  4040.                                 if(gestoreCorrelazione!=null){
  4041.                                     gestoreCorrelazione.verificaCorrelazioneRisposta(correlazioneApplicativaRisposta, responseMessage, headerIntegrazioneRisposta, false);
  4042.                                     
  4043.                                     idCorrelazioneApplicativaRisposta = gestoreCorrelazione.getIdCorrelazione();
  4044.                                     
  4045.                                     if(idCorrelazioneApplicativaRisposta!=null) {
  4046.                                         if(transactionNullable!=null) {
  4047.                                             transactionNullable.setCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  4048.                                         }
  4049.                                     }
  4050.                                     
  4051.                                     if(richiestaApplicativa!=null)
  4052.                                         richiestaApplicativa.setIdCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  4053.                                     else if(richiestaDelegata!=null)
  4054.                                         richiestaDelegata.setIdCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  4055.                                                             
  4056.                                     msgDiag.setIdCorrelazioneRisposta(idCorrelazioneApplicativaRisposta);
  4057.                                 }
  4058.                                 
  4059.                             }catch(Exception e){
  4060.                                 
  4061.                                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_CORRELAZIONE_APPLICATIVA_RISPOSTA, "true");
  4062.                                 
  4063.                                 msgDiag.logErroreGenerico(e,"CorrelazioneApplicativaRisposta");
  4064.                                 this.log.error("Riscontrato errore durante il controllo di correlazione applicativa della risposta: "+ e.getMessage(),e);
  4065.                                 
  4066.                                 ErroreIntegrazione errore = null;
  4067.                                 if(gestoreCorrelazione!=null){
  4068.                                     errore = gestoreCorrelazione.getErrore();
  4069.                                 }
  4070.                                 if(errore==null){
  4071.                                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4072.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_553_CORRELAZIONE_APPLICATIVA_RISPOSTA_NON_RIUSCITA);
  4073.                                 }
  4074.                                 
  4075.                                 ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.APPLICATION_CORRELATION_IDENTIFICATION_RESPONSE_FAILED);
  4076.                                 if(localForwardEngine!=null) {
  4077.                                     localForwardEngine.setIntegrationFunctionError(IntegrationFunctionError.APPLICATION_CORRELATION_IDENTIFICATION_RESPONSE_FAILED);
  4078.                                 }
  4079.                                 
  4080.                                 this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4081.                                         errore,
  4082.                                         idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4083.                                         (responseMessage!=null ? responseMessage.getParseException() : null),
  4084.                                         pddContext);
  4085.                                 
  4086.                                 esito.setEsitoInvocazione(true); 
  4087.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  4088.                                         "Riscontrato errore durante il controllo di correlazione applicativa della risposta: "+ e.getMessage());
  4089.                                 openspcoopstate.releaseResource();
  4090.                                 return esito;
  4091.                             }
  4092.                         }
  4093.                         
  4094.                         /* ------------  Header integrazione Risposta (Update/Delete) ------------- */
  4095.                         
  4096.                         Utilities.printFreeMemory("ConsegnaContenutiApplicativi - Update/Delete Header Integrazione... ");                  
  4097.                         for(int i=0; i<tipiIntegrazione.length;i++){
  4098.                             try{
  4099.                                 IGestoreIntegrazionePA gestore = null;
  4100.                                 try{
  4101.                                     gestore = (IGestoreIntegrazionePA) this.pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazione[i]);
  4102.                                 }catch(Exception e){
  4103.                                     throw e;
  4104.                                 }
  4105.                                 if(gestore!=null){
  4106.                                     String classType = null;
  4107.                                     try {
  4108.                                         classType = gestore.getClass().getName();
  4109.                                         AbstractCore.init(gestore, pddContext, protocolFactory);
  4110.                                     }catch(Exception e){
  4111.                                         throw new Exception("Riscontrato errore durante l'inizializzazione della classe ["+classType+
  4112.                                                 "] da utilizzare per la gestione dell'integrazione (Risposta Update/Delete) delle erogazione di tipo ["+tipiIntegrazione[i]+"]: "+e.getMessage());
  4113.                                     }
  4114.                                     if (responseMessage!=null && (gestore instanceof IGestoreIntegrazionePASoap) ) {
  4115.                                         if(this.propertiesReader.deleteHeaderIntegrazioneResponsePA()){
  4116.                                             ((IGestoreIntegrazionePASoap)gestore).deleteInResponseHeader(inResponsePAMessage);
  4117.                                         }else{
  4118.                                             ((IGestoreIntegrazionePASoap)gestore).updateInResponseHeader(inResponsePAMessage, idMessaggioConsegna, idMessageResponse, servizioApplicativoFruitore, 
  4119.                                                     idCorrelazioneApplicativaRisposta, idCorrelazioneApplicativa);
  4120.                                         }
  4121.                                     }
  4122.                                 }
  4123.                             } catch (Exception e) {
  4124.                                 this.log.debug("Errore durante la lettura dell'header di integrazione ["+ tipiIntegrazione[i]
  4125.                                         + "]: "+ e.getMessage(),e);
  4126.                                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazione[i]);
  4127.                                 msgDiag.addKeywordErroreProcessamento(e);
  4128.                                 msgDiag.logPersonalizzato("headerIntegrazione.letturaFallita");
  4129.                             }
  4130.                         }
  4131.                         
  4132.                         
  4133.                         /* ------------  Gestione Funzionalita' speciali per Attachments (Manifest) ------------- */    
  4134.                         // Funzionalita' necessaria solo per la consegna di un servizio
  4135.                         if(richiestaApplicativa!=null){
  4136.                             if(scartaBody){
  4137.                                 IntegrationFunctionError integrationFunctionError = null;
  4138.                                 try{
  4139.                                     if(responseMessage!=null){
  4140.                                         if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())==false){
  4141.                                             integrationFunctionError = IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL;
  4142.                                             throw new Exception("Funzionalita 'ScartaBody' valida solamente per Service Binding SOAP");
  4143.                                         }
  4144.                                         
  4145.                                         // E' permesso SOLO per messaggi con attachment
  4146.                                         if(responseMessage.castAsSoap().countAttachments() <= 0){
  4147.                                             throw new Exception("La funzionalita' e' permessa solo per messaggi SOAP With Attachments");
  4148.                                         }
  4149.                                     }
  4150.                                 }catch(Exception e){
  4151.                                     msgDiag.addKeywordErroreProcessamento(e);
  4152.                                     msgDiag.logPersonalizzato("funzionalitaScartaBodyNonRiuscita");
  4153.                                                                         
  4154.                                     if(integrationFunctionError==null) {
  4155.                                         integrationFunctionError = IntegrationFunctionError.BAD_RESPONSE;
  4156.                                     }
  4157.                                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  4158.                                     if(localForwardEngine!=null) {
  4159.                                         localForwardEngine.setIntegrationFunctionError(integrationFunctionError);
  4160.                                     }
  4161.                                     
  4162.                                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4163.                                             ErroriIntegrazione.ERRORE_425_SCARTA_BODY.getErrore425_ScartaBody(e.getMessage()),
  4164.                                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4165.                                             (responseMessage!=null ? responseMessage.getParseException() : null),
  4166.                                             pddContext);
  4167.                                     
  4168.                                     openspcoopstate.releaseResource();
  4169.                                     esito.setEsitoInvocazione(true); 
  4170.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  4171.                                             msgDiag.getMessaggio_replaceKeywords("funzionalitaScartaBodyNonRiuscita")); 
  4172.                                     return esito;
  4173.                                 }
  4174.                             }
  4175.                             if(allegaBody){
  4176.                                 try{
  4177.                                     if(responseMessage!=null){
  4178.                                         TunnelSoapUtils.allegaBody(responseMessage, this.propertiesReader.getHeaderSoapActorIntegrazione());
  4179.                                     }
  4180.                                 }catch(Exception e){
  4181.                                     msgDiag.addKeywordErroreProcessamento(e);
  4182.                                     msgDiag.logPersonalizzato("funzionalitaAllegaBodyNonRiuscita");
  4183.                                     
  4184.                                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.BAD_RESPONSE);
  4185.                                     if(localForwardEngine!=null) {
  4186.                                         localForwardEngine.setIntegrationFunctionError(IntegrationFunctionError.BAD_RESPONSE);
  4187.                                     }
  4188.                                     
  4189.                                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4190.                                             ErroriIntegrazione.ERRORE_424_ALLEGA_BODY.getErrore424_AllegaBody(e.getMessage()),
  4191.                                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4192.                                             (responseMessage!=null ? responseMessage.getParseException() : null),
  4193.                                             pddContext);
  4194.                                     
  4195.                                     openspcoopstate.releaseResource();
  4196.                                     esito.setEsitoInvocazione(true); 
  4197.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  4198.                                             msgDiag.getMessaggio_replaceKeywords("funzionalitaAllegaBodyNonRiuscita"));
  4199.                                     return esito;
  4200.                                 }
  4201.                             }
  4202.                         }
  4203.                     }
  4204.                     
  4205.                     
  4206.                     
  4207.                     // processResponse localforward
  4208.                     if(localForward){
  4209.                         
  4210.                         if( richiestaApplicativa!=null && Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) ){
  4211.                             // Per avere esattamente il solito comportamento dello scenario con protocollo.
  4212.                             if(soapFault==null && restProblem==null){
  4213.                                 // devo 'ignorare' la risposta anche se presente, essendo un profilo oneway.
  4214.                                 if(responseMessage!=null){
  4215.                                     if(ServiceBinding.SOAP.equals(responseMessage.getServiceBinding())){
  4216.                                         SOAPBody body = responseMessage.castAsSoap().getSOAPBody();
  4217.                                         if(body!=null)
  4218.                                             body.removeContents();  
  4219.                                     }
  4220.                                 }
  4221.                             }
  4222.                         }
  4223.                         
  4224.                         msgDiag.mediumDebug("Process response message for local forward...");
  4225.                         try{
  4226.                             if(localForwardEngine.processResponse(responseMessage)==false){
  4227.                                 localForwardEngine.sendErrore(localForwardEngine.getResponseMessageError());
  4228.                                 openspcoopstate.releaseResource();
  4229.                                 esito.setEsitoInvocazione(true); 
  4230.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"localForwardEngine.processResponse==false");
  4231.                                 return esito;
  4232.                             }
  4233.                             if(localForwardEngine.getResponseMessageAfterProcess()!=null){
  4234.                                 // Messaggio aggiornato
  4235.                                 responseMessage = localForwardEngine.getResponseMessageAfterProcess();
  4236.                             }
  4237.                         }catch(Exception e){
  4238.                             msgDiag.addKeywordErroreProcessamento(e);
  4239.                             msgDiag.logErroreGenerico(e, "localForwardProcessResponse");
  4240.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4241.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4242.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_556_LOCAL_FORWARD_PROCESS_RESPONSE_ERROR),
  4243.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4244.                                     (responseMessage!=null ? responseMessage.getParseException() : null),
  4245.                                     pddContext);
  4246.                             
  4247.                             openspcoopstate.releaseResource();
  4248.                             esito.setEsitoInvocazione(true); 
  4249.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  4250.                                     e.getMessage());
  4251.                             return esito;
  4252.                         }
  4253.                     }
  4254.                     
  4255.                     
  4256.                     
  4257.                     // Salvo messaggio ricevuto
  4258.                     msgDiag.mediumDebug("Registrazione messaggio di risposta nel RepositoryMessaggi...");
  4259.                     try{
  4260.                         msgResponse = new GestoreMessaggi(openspcoopstate, false, idMessageResponse,Costanti.OUTBOX,msgDiag,pddContext);
  4261.                         msgResponse.registraMessaggio(responseMessage,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta);
  4262.                         msgResponse.aggiornaRiferimentoMessaggio(idMessaggioConsegna);
  4263.                         msgResponse.aggiornaProprietarioMessaggio(ImbustamentoRisposte.ID_MODULO);
  4264.                         if(responseMessage!=null && responseMessage.getParseException()!= null)
  4265.                             throw responseMessage.getParseException().getSourceException(); // gestito nel cacth
  4266.                     }catch(Exception e){
  4267.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, ("salvataggio risposta, "+e.getMessage()));
  4268.                         if(bustaRichiesta.getMittente()!=null && bustaRichiesta.getTipoMittente()!=null){
  4269.                             msgDiag.logPersonalizzato("consegnaConErrore");
  4270.                         }
  4271.                         else{
  4272.                             msgDiag.logPersonalizzato("consegnaConErrore.mittenteAnonimo");
  4273.                         }
  4274.                         
  4275.                         msgResponse.deleteMessageFromFileSystem(); // elimino eventuale risposta salvata su fileSystem
  4276.                         msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  4277.                         if(responseMessage==null || responseMessage.getParseException() == null){
  4278.                             
  4279.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4280.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4281.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_510_SAVE_RESPONSE_MSG),
  4282.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4283.                                     (responseMessage!=null ? responseMessage.getParseException() : null),
  4284.                                     pddContext);
  4285.                             
  4286.                         } else {
  4287.                             
  4288.                             ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT);
  4289.                             if(localForwardEngine!=null) {
  4290.                                 localForwardEngine.setIntegrationFunctionError(IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT);
  4291.                             }
  4292.                             
  4293.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  4294.                             this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4295.                                     ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  4296.                                         getErrore440_MessaggioRispostaMalformato(responseMessage.getParseException().getParseException()),
  4297.                                     idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, 
  4298.                                     responseMessage.getParseException().getParseException(),
  4299.                                     responseMessage.getParseException(),
  4300.                                     pddContext);
  4301.                             
  4302.                         }
  4303.                         openspcoopstate.releaseResource();
  4304.                         esito.setEsitoInvocazione(true); 
  4305.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  4306.                                 "salvataggio risposta, "+e.getMessage());
  4307.                         return esito;
  4308.                     }

  4310.                     // Creazione messaggio di risposta
  4311.                     if(localForward){
  4312.                         
  4313.                         localForwardEngine.sendResponse(idMessageResponse);
  4314.                         
  4315.                     }
  4316.                     else{
  4317.                         
  4318.                         ImbustamentoRisposteMessage imbustamentoRisposteMSG = new ImbustamentoRisposteMessage();
  4319.                         imbustamentoRisposteMSG.setIDMessageResponse(idMessageResponse);
  4320.                         imbustamentoRisposteMSG.setRichiestaApplicativa(richiestaApplicativa);
  4321.                         imbustamentoRisposteMSG.setRichiestaDelegata(richiestaDelegata);
  4322.                         imbustamentoRisposteMSG.setBusta(bustaRichiesta);
  4323.                         imbustamentoRisposteMSG.setSpedizioneMsgIngresso(ejbUtils.getSpedizioneMsgIngresso());
  4324.                         imbustamentoRisposteMSG.setRicezioneMsgRisposta(ejbUtils.getRicezioneMsgRisposta());
  4325.                         imbustamentoRisposteMSG.setOneWayVersione11(oneWayVersione11);
  4326.                         imbustamentoRisposteMSG.setStateless(consegnaContenutiApplicativiMsg.isStateless());
  4327.                         imbustamentoRisposteMSG.setImplementazionePdDSoggettoMittente(consegnaContenutiApplicativiMsg.getImplementazionePdDSoggettoMittente());
  4328.                         imbustamentoRisposteMSG.setImplementazionePdDSoggettoDestinatario(consegnaContenutiApplicativiMsg.getImplementazionePdDSoggettoDestinatario());
  4329.                         imbustamentoRisposteMSG.setPddContext(pddContext);
  4330.                         
  4331.     
  4332.                         // Spedizione risposta al modulo 'ImbustamentoRisposte'
  4333.                         msgDiag.mediumDebug("Invio messaggio al modulo di ImbustamentoRisposte...");
  4334.                         if (openspcoopstate instanceof OpenSPCoopStateful){
  4335.                             try{
  4336.                                 ejbUtils.getNodeSender(this.propertiesReader, this.log).send(imbustamentoRisposteMSG, ImbustamentoRisposte.ID_MODULO, msgDiag, 
  4337.                                         identitaPdD,ConsegnaContenutiApplicativi.ID_MODULO, idMessaggioConsegna,msgResponse);
  4338.                             } catch (Exception e) {
  4339.                                 this.log.error("Spedizione->ImbustamentoRisposte non riuscita",e);  
  4340.                                 msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send(ImbustamentoRisposte)");
  4341.                                 msgResponse.deleteMessageFromFileSystem(); // elimino eventuale risposta salvata su fileSystem
  4342.                                 
  4343.                                 this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4344.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4345.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),
  4346.                                         idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4347.                                         (responseMessage!=null ? responseMessage.getParseException() : null),
  4348.                                         pddContext);
  4349.                                 
  4350.                                 openspcoopstate.releaseResource();
  4351.                                 esito.setEsitoInvocazione(true); 
  4352.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "Spedizione->ImbustamentoRisposte non riuscita"); 
  4353.                                 return esito;
  4354.                             }
  4355.                         }
  4356.                         else ((OpenSPCoopStateless)openspcoopstate).setMessageLib(imbustamentoRisposteMSG);
  4357.                     }

  4359.                 }

  4361.             }











  4373.             /* ---------- Aggiornamento numero di sequenza ---------------- */
  4374.             if(ordineConsegna!=null){               
  4375.                 if(oneWayVersione11 || openspcoopstate instanceof OpenSPCoopStateful){
  4376.                     msgDiag.mediumDebug("Aggiornamento numero sequenza per consegna in ordine...");

  4378.                     ordineConsegna.setNextSequenza_daRicevere(bustaRichiesta);
  4379.                 }
  4380.             }






  4387.             /* ---------- Gestione Transazione Modulo ---------------- */

  4389.             // messaggio finale
  4390.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_CONNETTORE, tipoConnector);
  4391.             msgDiag.logPersonalizzato("gestioneConsegnaTerminata");

  4393.             // Commit JDBC della risposta
  4394.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta...");
  4395.             openspcoopstate.commit();

  4397.             // Aggiornamento cache messaggio
  4398.             if(msgRequest!=null)
  4399.                 msgRequest.addMessaggiIntoCache_readFromTable(ConsegnaContenutiApplicativi.ID_MODULO, "richiesta");
  4400.             if(msgResponse!=null)
  4401.                 msgResponse.addMessaggiIntoCache_readFromTable(ConsegnaContenutiApplicativi.ID_MODULO, "risposta");

  4403.             // Aggiornamento cache proprietario messaggio
  4404.             if(msgRequest!=null)
  4405.                 msgRequest.addProprietariIntoCache_readFromTable(ConsegnaContenutiApplicativi.ID_MODULO, "richiesta",null,false);
  4406.             if(msgResponse!=null)
  4407.                 msgResponse.addProprietariIntoCache_readFromTable(ConsegnaContenutiApplicativi.ID_MODULO, "risposta",idMessaggioConsegna,false);


  4410.         }catch(Throwable e){
  4411.             this.log.error("ErroreGenerale",e);
  4412.             msgDiag.logErroreGenerico(e, "Generale");

  4414.             if ( msgResponse!=null ){
  4415.                 msgResponse.deleteMessageFromFileSystem(); // elimino eventuale risposta salvata su fileSystem
  4416.             }

  4418.             if(existsModuloInAttesaRispostaApplicativa) {
  4419.                 try{
  4420.                     
  4421.                     ParseException parseException = null;
  4422.                     if(useResponseForParseException) {
  4423.                         parseException = (responseMessage!=null ? responseMessage.getParseException() : null);
  4424.                     }
  4425.                     else {
  4426.                         parseException = (consegnaMessagePrimaTrasformazione!=null ? consegnaMessagePrimaTrasformazione.getParseException() : null);    
  4427.                     }
  4428.                     
  4429.                     this.sendErroreProcessamento(localForward, localForwardEngine, ejbUtils, 
  4430.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4431.                                 getErroreIntegrazione(),
  4432.                             idModuloInAttesa, bustaRichiesta, idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, e,
  4433.                             parseException,
  4434.                             pddContext);
  4435.                     
  4436.                     esito.setEsitoInvocazione(true); 
  4437.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "ErroreGenerale");
  4438.                 }catch(Exception er){
  4439.                     msgDiag.logErroreGenerico(er,"ejbUtils.sendErroreGenerale(profiloConRisposta)");
  4440.                     ejbUtils.rollbackMessage("Spedizione Errore al Mittente durante una richiesta con gestione della risposta non riuscita",servizioApplicativo, esito, false);
  4441.                     esito.setEsitoInvocazione(false); 
  4442.                     esito.setStatoInvocazioneErroreNonGestito(er);
  4443.                 }
  4444.             }else{
  4445.                 ejbUtils.rollbackMessage("ErroreGenerale:"+e.getMessage(), servizioApplicativo, esito, false);
  4446.                 esito.setEsitoInvocazione(false); 
  4447.                 esito.setStatoInvocazioneErroreNonGestito(e);
  4448.             }
  4449.             openspcoopstate.releaseResource();
  4450.             return esito;
  4451.         }finally{
  4452.             try {
  4453.                 if(transazioneApplicativoServer!=null) {
  4454.                     if(consegnaMessageTrasformato!=null) {
  4455.                         transazioneApplicativoServer.setRichiestaUscitaBytes(consegnaMessageTrasformato.getOutgoingMessageContentLength());
  4456.                     }
  4457.                     if(responseMessage!=null) {
  4458.                         long incomingResponseMessageContentLength = responseMessage.getIncomingMessageContentLength();
  4459.                         if(incomingResponseMessageContentLength<=0){
  4460.                             incomingResponseMessageContentLength = responseContentLength;
  4461.                             if(incomingResponseMessageContentLength<0){
  4462.                                 //System.out.println("FLUSH");
  4463.                                 // forzo la lettura del messaggio per impostare la dimensione della richiesta
  4464.                                 try{
  4465.                                     responseMessage.writeTo(NullOutputStream.INSTANCE, true);
  4466.                                 }catch(Exception eFlush){
  4467.                                     // ignore
  4468.                                 }
  4469.                                 incomingResponseMessageContentLength = responseMessage.getIncomingMessageContentLength();
  4470.                             }
  4471.                         }
  4472.                         transazioneApplicativoServer.setRispostaIngressoBytes(incomingResponseMessageContentLength);
  4473.                     }
  4474.                 }
  4475.             }catch(Throwable t) {
  4476.                 this.log.error("Errore durante la lettura delle dimensioni dei messaggi: "+t.getMessage(),t);
  4477.             }
  4478.             try{
  4479.                 if(connectorSenderForDisconnect!=null)
  4480.                     connectorSenderForDisconnect.disconnect();
  4481.             }catch(Exception e){
  4482.                 try{
  4483.                     if(msgDiag!=null)
  4484.                         msgDiag.logDisconnectError(e, location);
  4485.                 }catch(Exception eDisconnect){
  4486.                     this.log.error("Errore durante la chiusura delle connessione: "+eDisconnect.getMessage(),e);
  4487.                 }
  4488.             }
  4489.         }




  4494.         // Elimino SIL destinatario a cui ho consegnato il messaggio
  4495.         // a meno di consegna per riferimento
  4496.         //  if(connectionDB!=null){
  4497.         //      msgDiag.mediumDebug("Eliminazione SIL destinatario del messaggio nella tabelle MSG_SERVIZI_APPLICATIVI...");
  4498.         if(consegnaPerRiferimento==false){
  4499.             try{
  4500.                 String idMessaggioGestoreMessaggiRichiestaEliminazione = idMessaggioConsegna;
  4501.                 if(idMessaggioPreBehaviour!=null){
  4502.                     idMessaggioGestoreMessaggiRichiestaEliminazione = bustaRichiesta.getID();
  4503.                 }
  4504.                 
  4505.                 GestoreMessaggi gestoreEliminazioneDestinatario = new GestoreMessaggi(openspcoopstate, true, idMessaggioGestoreMessaggiRichiestaEliminazione,Costanti.INBOX,msgDiag,pddContext);
  4506.                 if(idMessaggioPreBehaviour!=null && !(openspcoopstate instanceof OpenSPCoopStateful) ){
  4507.                     gestoreEliminazioneDestinatario.setOneWayVersione11(true); // per forzare l'update su db    
  4508.                 }
  4509.                 else{
  4510.                     gestoreEliminazioneDestinatario.setOneWayVersione11(oneWayVersione11);      
  4511.                 }
  4512.                 gestoreEliminazioneDestinatario.eliminaDestinatarioMessaggio(servizioApplicativo, null, oraRegistrazione);
  4513.             }catch(Exception e){
  4514.                 msgDiag.logErroreGenerico(e,"gestoreEliminazioneDestinatario.eliminaDestinatarioMessaggio("+servizioApplicativo+",null)");
  4515.             }
  4516.         }

  4518.         //  Rilascio connessione al DB
  4519.         msgDiag.mediumDebug(ConsegnaContenutiApplicativi.ID_MODULO+ " Rilascio le risorse..");
  4520.         openspcoopstate.releaseResource();

  4522.         msgDiag.mediumDebug("Lavoro Terminato.");
  4523.         esito.setEsitoInvocazione(true); 
  4524.         esito.setStatoInvocazione(EsitoLib.OK,null);
  4525.         return esito; 

  4527.     }
  4528.     
  4529.         
  4530.     private void sendErroreProcessamento(boolean localForward,LocalForwardEngine localForwardEngine, EJBUtils ejbUtils, ErroreIntegrazione errore,
  4531.             String idModuloInAttesa,Busta bustaRichiesta,String idCorrelazioneApplicativa, String idCorrelazioneApplicativaRisposta,
  4532.             String servizioApplicativoFruitore, Throwable e, ParseException parseException,
  4533.             PdDContext pddContext) throws LocalForwardException, EJBUtilsException, ProtocolException{
  4534.         if(localForward){
  4535.             localForwardEngine.sendErrore(pddContext, errore,e,parseException);
  4536.         }else{
  4537.             ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  4538.                     errore, idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,parseException);
  4539.         }
  4540.     }
  4541.     
  4542.     private void sendErroreProcessamento(boolean localForward,LocalForwardEngine localForwardEngine, EJBUtils ejbUtils, OpenSPCoop2Message errorMessage, String errorDetail,
  4543.             String idModuloInAttesa,Busta bustaRichiesta,String idCorrelazioneApplicativa, String idCorrelazioneApplicativaRisposta,
  4544.             String servizioApplicativoFruitore) throws LocalForwardException, EJBUtilsException, ProtocolException{
  4545.         if(localForward){
  4546.             localForwardEngine.sendErrore(errorMessage);
  4547.         }else{
  4548.             ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  4549.                     idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,
  4550.                     errorMessage, errorDetail);
  4551.         }
  4552.     }

  4554.     private void mappingProtocolProperties(Map<String, List<String>> protocolProperties,Map<String, List<String>> propertiesDaImpostare,
  4555.             IDSoggetto soggettoFruitoreHeaderIntegrazione, IDServizio servizioHeaderIntegrazione,
  4556.             IDSoggetto soggettoFruitore,IDServizio idServizio,
  4557.             Busta bustaRichiesta, String idCorrelazioneApplicativa){
  4558.         // mapping in valori delle keyword delle proprieta di trasporto protocol-properties.
  4559.         if(protocolProperties != null){
  4560.             Iterator<String> keys = protocolProperties.keySet().iterator();
  4561.             while (keys.hasNext()) {
  4562.                 String key = (String) keys.next();
  4563.                 List<String> values = protocolProperties.get(key);
  4564.                 String value = TransportUtils.getFirstValue(values);
  4565.                 
  4566.                 if(ProprietaProtocolloValore.TIPO_MITTENTE.equals(value)){
  4567.                     if(soggettoFruitoreHeaderIntegrazione!=null && soggettoFruitoreHeaderIntegrazione.getTipo()!=null){
  4568.                         TransportUtils.setHeader(propertiesDaImpostare,key,soggettoFruitoreHeaderIntegrazione.getTipo());
  4569.                     }else if(soggettoFruitore!=null && soggettoFruitore.getTipo()!=null){
  4570.                         TransportUtils.setHeader(propertiesDaImpostare,key,soggettoFruitore.getTipo());
  4571.                     }else if(bustaRichiesta!=null && bustaRichiesta.getTipoMittente()!=null){
  4572.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getTipoMittente());
  4573.                     }
  4574.                 }
  4575.                 if(ProprietaProtocolloValore.MITTENTE.equals(value)){
  4576.                     if(soggettoFruitoreHeaderIntegrazione!=null && soggettoFruitoreHeaderIntegrazione.getNome()!=null){
  4577.                         TransportUtils.setHeader(propertiesDaImpostare,key,soggettoFruitoreHeaderIntegrazione.getNome());
  4578.                     }else if(soggettoFruitore!=null && soggettoFruitore.getNome()!=null){
  4579.                         TransportUtils.setHeader(propertiesDaImpostare,key,soggettoFruitore.getNome());
  4580.                     }else if(bustaRichiesta!=null && bustaRichiesta.getMittente()!=null){
  4581.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getMittente());
  4582.                     }
  4583.                 }
  4584.                 if(ProprietaProtocolloValore.IDENTIFICATIVO_PORTA_MITTENTE.equals(value)){
  4585.                     if(soggettoFruitoreHeaderIntegrazione!=null && soggettoFruitoreHeaderIntegrazione.getCodicePorta()!=null){
  4586.                         TransportUtils.setHeader(propertiesDaImpostare,key,soggettoFruitoreHeaderIntegrazione.getCodicePorta());
  4587.                     }else if(soggettoFruitore!=null && soggettoFruitore.getCodicePorta()!=null){
  4588.                         TransportUtils.setHeader(propertiesDaImpostare,key,soggettoFruitore.getCodicePorta());
  4589.                     }else if(bustaRichiesta!=null && bustaRichiesta.getIdentificativoPortaMittente()!=null){
  4590.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getIdentificativoPortaMittente());
  4591.                     }
  4592.                 }
  4593.                     
  4594.                 if(ProprietaProtocolloValore.TIPO_DESTINATARIO.equals(value)){
  4595.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getSoggettoErogatore()!=null &&
  4596.                             servizioHeaderIntegrazione.getSoggettoErogatore().getTipo()!=null){
  4597.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getSoggettoErogatore().getTipo());
  4598.                     }else if(idServizio!=null && idServizio.getSoggettoErogatore()!=null &&
  4599.                             idServizio.getSoggettoErogatore().getTipo()!=null){
  4600.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getSoggettoErogatore().getTipo());
  4601.                     }else if(bustaRichiesta!=null && bustaRichiesta.getTipoDestinatario()!=null){
  4602.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getTipoDestinatario());
  4603.                     }
  4604.                 }   
  4605.                 if(ProprietaProtocolloValore.DESTINATARIO.equals(value)){
  4606.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getSoggettoErogatore()!=null &&
  4607.                             servizioHeaderIntegrazione.getSoggettoErogatore().getNome()!=null){
  4608.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getSoggettoErogatore().getNome());
  4609.                     }else if(idServizio!=null && idServizio.getSoggettoErogatore()!=null &&
  4610.                             idServizio.getSoggettoErogatore().getNome()!=null){
  4611.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getSoggettoErogatore().getNome());
  4612.                     }else if(bustaRichiesta!=null && bustaRichiesta.getDestinatario()!=null){
  4613.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getDestinatario());
  4614.                     }
  4615.                 }
  4616.                 if(ProprietaProtocolloValore.IDENTIFICATIVO_PORTA_DESTINATARIO.equals(value)){
  4617.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getSoggettoErogatore()!=null && 
  4618.                             servizioHeaderIntegrazione.getSoggettoErogatore().getCodicePorta()!=null){
  4619.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getSoggettoErogatore().getCodicePorta());
  4620.                     }else if(idServizio!=null && idServizio.getSoggettoErogatore()!=null && 
  4621.                             idServizio.getSoggettoErogatore().getCodicePorta()!=null){
  4622.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getSoggettoErogatore().getCodicePorta());
  4623.                     }else if(bustaRichiesta!=null && bustaRichiesta.getIdentificativoPortaDestinatario()!=null){
  4624.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getIdentificativoPortaDestinatario());
  4625.                     }
  4626.                 }

  4628.                 if(ProprietaProtocolloValore.TIPO_SERVIZIO.equals(value)){
  4629.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getTipo()!=null){
  4630.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getTipo());
  4631.                     }else if(idServizio!=null && idServizio.getTipo()!=null){
  4632.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getTipo());
  4633.                     }else if(bustaRichiesta!=null && bustaRichiesta.getTipoServizio()!=null){
  4634.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getTipoServizio());
  4635.                     }
  4636.                 }
  4637.                 if(ProprietaProtocolloValore.SERVIZIO.equals(value)){
  4638.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getNome()!=null){
  4639.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getNome());
  4640.                     }else if(idServizio!=null && idServizio.getNome()!=null){
  4641.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getNome());
  4642.                     }else if(bustaRichiesta!=null && bustaRichiesta.getServizio()!=null){
  4643.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getServizio());
  4644.                     }
  4645.                 }
  4646.                 if(ProprietaProtocolloValore.VERSIONE_SERVIZIO.equals(value)){
  4647.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getVersione()!=null){
  4648.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getVersione().intValue()+"");
  4649.                     }else if(idServizio!=null && idServizio.getVersione()!=null){
  4650.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getVersione().intValue()+"");
  4651.                     }else if(bustaRichiesta!=null && bustaRichiesta.getVersioneServizio()!=null){
  4652.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getVersioneServizio().intValue()+"");
  4653.                     }
  4654.                 }
  4655.                 
  4656.                 if(ProprietaProtocolloValore.AZIONE.equals(value)){
  4657.                     if(servizioHeaderIntegrazione!=null && servizioHeaderIntegrazione.getAzione()!=null){
  4658.                         TransportUtils.setHeader(propertiesDaImpostare,key,servizioHeaderIntegrazione.getAzione());
  4659.                     }else if(idServizio!=null && idServizio.getAzione()!=null){
  4660.                         TransportUtils.setHeader(propertiesDaImpostare,key,idServizio.getAzione());
  4661.                     }else if(bustaRichiesta!=null && bustaRichiesta.getAzione()!=null){
  4662.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getAzione());
  4663.                     }
  4664.                 }
  4665.                 
  4666.                 if(ProprietaProtocolloValore.IDENTIFICATIVO.equals(value)){
  4667.                     if(bustaRichiesta!=null && bustaRichiesta.getID()!=null){
  4668.                         TransportUtils.setHeader(propertiesDaImpostare,key,bustaRichiesta.getID());
  4669.                     }
  4670.                 }

  4672.                 if(ProprietaProtocolloValore.IDENTIFICATIVO_CORRELAZIONE_APPLICATIVA.equals(value)){
  4673.                     if(idCorrelazioneApplicativa!=null){
  4674.                         TransportUtils.setHeader(propertiesDaImpostare,key,idCorrelazioneApplicativa);
  4675.                     }
  4676.                 }
  4677.             }
  4678.         }
  4679.     }
  4680.     
  4681.     
  4682.     private void emitDiagnostico(boolean invokerNonSupportato, Busta bustaRichiesta, MsgDiagnostico msgDiag, boolean errorConsegna) {
  4683.         if(invokerNonSupportato==false){
  4684.             if(bustaRichiesta.getMittente()!=null && bustaRichiesta.getTipoMittente()!=null){
  4685.                 if(errorConsegna){
  4686.                     msgDiag.logPersonalizzato("consegnaConErrore");
  4687.                 }else{
  4688.                     msgDiag.logPersonalizzato("consegnaEffettuata");
  4689.                 }
  4690.             }
  4691.             else{
  4692.                 if(errorConsegna){
  4693.                     msgDiag.logPersonalizzato("consegnaConErrore.mittenteAnonimo");
  4694.                 }else{
  4695.                     msgDiag.logPersonalizzato("consegnaEffettuata.mittenteAnonimo");
  4696.                 }
  4697.             }
  4698.         }
  4699.     }
  4700.     
  4701.     private void correctForwardPathNotifiche(TransazioneApplicativoServer transazioneApplicativoServer, OpenSPCoop2Message msg, IProtocolFactory<?> pf) throws ProtocolException {
  4702.         if(transazioneApplicativoServer!=null && ServiceBinding.REST.equals(msg.getServiceBinding())) {
  4703.             
  4704.             // non deve essere effettuato il forward del contesto nel path
  4705.             TransportRequestContext requestContext = msg.getTransportRequestContext();
  4706.             if(requestContext!=null) {
  4707.                 String resourcePath = requestContext.getFunctionParameters();
  4708.                 if(resourcePath!=null){
  4709.                     if(resourcePath.startsWith("/")){
  4710.                         resourcePath = resourcePath.substring(1);
  4711.                     }
  4712.                     if(requestContext.getInterfaceName()!=null) {
  4713.                         if(resourcePath.startsWith(requestContext.getInterfaceName())){
  4714.                             requestContext.setFunctionParameters(requestContext.getInterfaceName());
  4715.                         }       
  4716.                         else {
  4717.                             String normalizedInterfaceName = ConnettoreUtils.normalizeInterfaceName(msg, ConsegnaContenutiApplicativi.ID_MODULO, pf);
  4718.                             if(normalizedInterfaceName!=null && resourcePath.startsWith(normalizedInterfaceName)){
  4719.                                 requestContext.setFunctionParameters(normalizedInterfaceName);
  4720.                             }
  4721.                         }
  4722.                     }
  4723.                 }
  4724.             }
  4725.             
  4726.             // non deve essere effettuato il forward dei parametri
  4727.             if(requestContext!=null && requestContext.getParameters()!=null) {
  4728.                 requestContext.getParameters().clear();
  4729.             }
  4730.         }
  4731.     }
  4732.     
  4733.     @SuppressWarnings("unchecked")
  4734.     private List<String> readServiziApplicativiAbilitatiForwardTo(PdDContext pddContext) {
  4735.         List<String> serviziApplicativiAbilitatiForwardTo = null;
  4736.         if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_CONNETTORI_BY_SA)) {
  4737.             serviziApplicativiAbilitatiForwardTo = (List<String>) pddContext.getObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_CONNETTORI_BY_SA);
  4738.         }
  4739.         return serviziApplicativiAbilitatiForwardTo;
  4740.     }
  4741.     
  4742.     private void registraTracciaOutRequest(Transaction transactionNullable, OutRequestContext outRequestContext, Logger log, MsgDiagnostico msgDiag) throws HandlerException {

  4744.         try {
  4745.         
  4746.             if(transactionNullable==null) {
  4747.                 // comunicazione statefull
  4748.                 return;
  4749.             }
  4750.             
  4751.             TracciamentoManager tracciamentoManager = new TracciamentoManager(FaseTracciamento.OUT_REQUEST);
  4752.             if(!tracciamentoManager.isTransazioniEnabled()) {
  4753.                 return;
  4754.             }
  4755.                 
  4756.             InformazioniTransazione info = new InformazioniTransazione();
  4757.             info.setContext(outRequestContext.getPddContext());
  4758.             info.setTipoPorta(outRequestContext.getTipoPorta());
  4759.             info.setProtocolFactory(outRequestContext.getProtocolFactory());
  4760.             info.setProtocollo(outRequestContext.getProtocollo());
  4761.             info.setIntegrazione(outRequestContext.getIntegrazione());
  4762.             info.setIdModulo(outRequestContext.getIdModulo());
  4763.             
  4764.             TransportRequestContext transportRequestContext = null;
  4765.             if(outRequestContext.getMessaggio()!=null) {
  4766.                 transportRequestContext = outRequestContext.getMessaggio().getTransportRequestContext();
  4767.             }
  4768.             String esitoContext = EsitoBuilder.getTipoContext(transportRequestContext, EsitiProperties.getInstance(log, outRequestContext.getProtocolFactory()), log);
  4769.             
  4770.             tracciamentoManager.invoke(info, esitoContext, 
  4771.                     outRequestContext.getConnettore()!=null ? outRequestContext.getConnettore().getHeaders() : null,
  4772.                             msgDiag);
  4773.             
  4774.         }catch(Exception e) {
  4775.             ServicesUtils.processTrackingException(e, log, FaseTracciamento.OUT_REQUEST, outRequestContext.getPddContext());
  4776.         }
  4777.         
  4778.     }
  4779. }
Created with JaCoCo 0.8.8.202204050719