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



  20. package org.openspcoop2.pdd.services.core;


  21. import java.io.ByteArrayInputStream;
  22. import java.util.ArrayList;
  23. import java.util.Date;
  24. import java.util.Enumeration;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;

  28. import javax.servlet.http.HttpServletRequest;

  29. import org.apache.commons.lang.StringUtils;
  30. import org.openspcoop2.core.config.AttributeAuthority;
  31. import org.openspcoop2.core.config.CorsConfigurazione;
  32. import org.openspcoop2.core.config.DumpConfigurazione;
  33. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  34. import org.openspcoop2.core.config.PortaApplicativa;
  35. import org.openspcoop2.core.config.PortaDelegata;
  36. import org.openspcoop2.core.config.Proprieta;
  37. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  38. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  39. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  40. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  41. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  42. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  43. import org.openspcoop2.core.constants.TipoPdD;
  44. import org.openspcoop2.core.eccezione.details.DettaglioEccezione;
  45. import org.openspcoop2.core.eccezione.details.utils.XMLUtils;
  46. import org.openspcoop2.core.id.IDPortaApplicativa;
  47. import org.openspcoop2.core.id.IDPortaDelegata;
  48. import org.openspcoop2.core.id.IDServizio;
  49. import org.openspcoop2.core.id.IDServizioApplicativo;
  50. import org.openspcoop2.core.id.IDSoggetto;
  51. import org.openspcoop2.core.id.IdentificativiErogazione;
  52. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  53. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  54. import org.openspcoop2.core.registry.Resource;
  55. import org.openspcoop2.core.registry.Soggetto;
  56. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  57. import org.openspcoop2.core.registry.driver.DriverRegistroServiziAzioneNotFound;
  58. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  59. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  60. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  61. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  62. import org.openspcoop2.message.OpenSPCoop2Message;
  63. import org.openspcoop2.message.config.ServiceBindingConfiguration;
  64. import org.openspcoop2.message.constants.MessageRole;
  65. import org.openspcoop2.message.constants.ServiceBinding;
  66. import org.openspcoop2.message.exception.ParseException;
  67. import org.openspcoop2.message.soap.mtom.MtomXomReference;
  68. import org.openspcoop2.message.utils.MessageUtilities;
  69. import org.openspcoop2.pdd.config.ClassNameProperties;
  70. import org.openspcoop2.pdd.config.ConfigurazioneCanaliNodo;
  71. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  72. import org.openspcoop2.pdd.config.CostantiProprieta;
  73. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  74. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  75. import org.openspcoop2.pdd.config.RichiestaDelegata;
  76. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  77. import org.openspcoop2.pdd.core.AbstractCore;
  78. import org.openspcoop2.pdd.core.CORSFilter;
  79. import org.openspcoop2.pdd.core.CORSWrappedHttpServletResponse;
  80. import org.openspcoop2.pdd.core.CostantiPdD;
  81. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativa;
  82. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativaConfig;
  83. import org.openspcoop2.pdd.core.GestoreMessaggi;
  84. import org.openspcoop2.pdd.core.IntegrationContext;
  85. import org.openspcoop2.pdd.core.MTOMProcessor;
  86. import org.openspcoop2.pdd.core.PdDContext;
  87. import org.openspcoop2.pdd.core.ProtocolContext;
  88. import org.openspcoop2.pdd.core.StatoServiziPdD;
  89. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativi;
  90. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiException;
  91. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiRest;
  92. import org.openspcoop2.pdd.core.autorizzazione.GestoreAutorizzazione;
  93. import org.openspcoop2.pdd.core.autorizzazione.container.AutorizzazioneHttpServletRequest;
  94. import org.openspcoop2.pdd.core.autorizzazione.container.IAutorizzazioneSecurityContainer;
  95. import org.openspcoop2.pdd.core.autorizzazione.pa.DatiInvocazionePortaApplicativa;
  96. import org.openspcoop2.pdd.core.autorizzazione.pa.EsitoAutorizzazionePortaApplicativa;
  97. import org.openspcoop2.pdd.core.connettori.InfoConnettoreIngresso;
  98. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  99. import org.openspcoop2.pdd.core.credenziali.GestoreCredenzialiConfigurationException;
  100. import org.openspcoop2.pdd.core.credenziali.IGestoreCredenziali;
  101. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  102. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  103. import org.openspcoop2.pdd.core.handlers.HandlerException;
  104. import org.openspcoop2.pdd.core.handlers.InRequestContext;
  105. import org.openspcoop2.pdd.core.handlers.InRequestProtocolContext;
  106. import org.openspcoop2.pdd.core.handlers.OutResponseContext;
  107. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  108. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazioneBusta;
  109. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePA;
  110. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePASoap;
  111. import org.openspcoop2.pdd.core.integrazione.InRequestPAMessage;
  112. import org.openspcoop2.pdd.core.integrazione.OutResponsePAMessage;
  113. import org.openspcoop2.pdd.core.integrazione.UtilitiesIntegrazione;
  114. import org.openspcoop2.pdd.core.node.INodeReceiver;
  115. import org.openspcoop2.pdd.core.node.INodeSender;
  116. import org.openspcoop2.pdd.core.node.NodeTimeoutException;
  117. import org.openspcoop2.pdd.core.response_caching.HashGenerator;
  118. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  119. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  120. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  121. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  122. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  123. import org.openspcoop2.pdd.core.token.GestoreToken;
  124. import org.openspcoop2.pdd.core.token.InformazioniToken;
  125. import org.openspcoop2.pdd.core.token.TokenUtilities;
  126. import org.openspcoop2.pdd.core.token.attribute_authority.EsitoRecuperoAttributi;
  127. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  128. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  129. import org.openspcoop2.pdd.core.token.attribute_authority.pa.GestioneAttributeAuthority;
  130. import org.openspcoop2.pdd.core.transazioni.Transaction;
  131. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  132. import org.openspcoop2.pdd.logger.Dump;
  133. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  134. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  135. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  136. import org.openspcoop2.pdd.logger.Tracciamento;
  137. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  138. import org.openspcoop2.pdd.mdb.EsitoLib;
  139. import org.openspcoop2.pdd.mdb.GenericLibException;
  140. import org.openspcoop2.pdd.mdb.ImbustamentoRisposte;
  141. import org.openspcoop2.pdd.mdb.InoltroBuste;
  142. import org.openspcoop2.pdd.mdb.InoltroBusteMessage;
  143. import org.openspcoop2.pdd.mdb.InoltroRisposte;
  144. import org.openspcoop2.pdd.mdb.Sbustamento;
  145. import org.openspcoop2.pdd.mdb.SbustamentoMessage;
  146. import org.openspcoop2.pdd.services.DirectVMProtocolInfo;
  147. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  148. import org.openspcoop2.pdd.services.ServicesUtils;
  149. import org.openspcoop2.pdd.services.connector.messages.ConnectorInMessage;
  150. import org.openspcoop2.pdd.services.error.AbstractErrorGenerator;
  151. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  152. import org.openspcoop2.pdd.services.service.RicezioneBusteServiceUtils;
  153. import org.openspcoop2.pdd.services.skeleton.IntegrationManager;
  154. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  155. import org.openspcoop2.pdd.timers.TimerLock;
  156. import org.openspcoop2.pdd.timers.TimerMonitoraggioRisorseThread;
  157. import org.openspcoop2.pdd.timers.TimerThresholdThread;
  158. import org.openspcoop2.pdd.timers.TipoLock;
  159. import org.openspcoop2.protocol.basic.registry.IdentificazionePortaApplicativa;
  160. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  161. import org.openspcoop2.protocol.engine.builder.Imbustamento;
  162. import org.openspcoop2.protocol.engine.constants.Costanti;
  163. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  164. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  165. import org.openspcoop2.protocol.engine.mapping.IdentificazioneDinamicaException;
  166. import org.openspcoop2.protocol.engine.mapping.InformazioniServizioURLMapping;
  167. import org.openspcoop2.protocol.engine.validator.Validatore;
  168. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  169. import org.openspcoop2.protocol.sdk.Busta;
  170. import org.openspcoop2.protocol.sdk.BustaRawContent;
  171. import org.openspcoop2.protocol.sdk.Context;
  172. import org.openspcoop2.protocol.sdk.Eccezione;
  173. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  174. import org.openspcoop2.protocol.sdk.Integrazione;
  175. import org.openspcoop2.protocol.sdk.ProtocolException;
  176. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  177. import org.openspcoop2.protocol.sdk.SecurityInfo;
  178. import org.openspcoop2.protocol.sdk.Servizio;
  179. import org.openspcoop2.protocol.sdk.Trasmissione;
  180. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  181. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  182. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  183. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  184. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  185. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  186. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  187. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  188. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  189. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  190. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  191. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  192. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  193. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  194. import org.openspcoop2.protocol.sdk.constants.InitialIdConversationType;
  195. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  196. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  197. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  198. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  199. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  200. import org.openspcoop2.protocol.sdk.constants.StatoFunzionalitaProtocollo;
  201. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  202. import org.openspcoop2.protocol.sdk.dump.DumpException;
  203. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  204. import org.openspcoop2.protocol.sdk.state.StateMessage;
  205. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  206. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  207. import org.openspcoop2.protocol.sdk.tracciamento.EsitoElaborazioneMessaggioTracciato;
  208. import org.openspcoop2.protocol.sdk.tracciamento.TracciamentoException;
  209. import org.openspcoop2.protocol.sdk.validator.IValidatoreErrori;
  210. import org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica;
  211. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  212. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  213. import org.openspcoop2.protocol.utils.ModIUtils;
  214. import org.openspcoop2.protocol.utils.ModIValidazioneSemanticaProfiloSicurezza;
  215. import org.openspcoop2.security.message.MessageSecurityContext;
  216. import org.openspcoop2.security.message.MessageSecurityContextParameters;
  217. import org.openspcoop2.security.message.constants.SecurityConstants;
  218. import org.openspcoop2.security.message.engine.MessageSecurityFactory;
  219. import org.openspcoop2.utils.LoggerWrapperFactory;
  220. import org.openspcoop2.utils.MapKey;
  221. import org.openspcoop2.utils.Utilities;
  222. import org.openspcoop2.utils.date.DateManager;
  223. import org.openspcoop2.utils.resources.Loader;
  224. import org.openspcoop2.utils.transport.Credential;
  225. import org.openspcoop2.utils.transport.http.CORSRequestType;
  226. import org.openspcoop2.utils.transport.http.HttpConstants;
  227. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  228. import org.slf4j.Logger;


  229. /**
  230.  * Contiene la definizione del modulo 'RicezioneBuste', il quale e' un
  231.  * modulo dell'infrastruttura OpenSPCoop.
  232.  *
  233.  * @author Poli Andrea (apoli@link.it)
  234.  * @author $Author$
  235.  * @version $Rev$, $Date$
  236.  */

  237. public class RicezioneBuste {

  238.     /** Variabile che indica il Nome del modulo dell'architettura di OpenSPCoop rappresentato da questa classe */
  239.     public static final String ID_MODULO = "RicezioneBuste";

  240.     private static void logDebug(Logger logCore, String msg) {
  241.         logCore.debug(msg);
  242.     }
  243.     private static void logDebug(Logger logCore, String msg, Throwable e) {
  244.         logCore.debug(msg, e);
  245.     }
  246.     private static void logInfo(Logger logCore, String msg) {
  247.         logCore.info(msg);
  248.     }
  249.     private static void logError(Logger logCore, String msg) {
  250.         logCore.error(msg);
  251.     }
  252.     private static void logError(Logger logCore, String msg, Throwable e) {
  253.         logCore.error(msg,e);
  254.     }
  255.    
  256.    
  257.     /** Indicazione se sono state inizializzate le variabili del servizio */
  258.     public static boolean initializeService = false;

  259.     /** IGestoreIntegrazionePA: lista di gestori, ordinati per priorita' minore */
  260.     public static String[] defaultGestoriIntegrazionePA = null;
  261.     public static java.util.concurrent.ConcurrentHashMap<String, String[]> defaultPerProtocolloGestoreIntegrazionePA = null;
  262.    
  263.     /** IGestoreCredenziali: lista di gestori delle credenziali */
  264.     private static String [] tipiGestoriCredenziali = null;
  265.        
  266.     /**
  267.      * Inizializzatore del servizio RicezioneBuste
  268.      *
  269.      * @throws Exception
  270.      */
  271.     public static synchronized void initializeService(ConfigurazionePdDManager configReader,ClassNameProperties className,OpenSPCoop2Properties propertiesReader,Logger logCore) throws Exception{
  272.         if(RicezioneBuste.initializeService)
  273.             return; // inizializzato da un altro thread

  274.         Loader loader = Loader.getInstance();
  275.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  276.        
  277.         // Inizializzazione NodeSender
  278.         String classTypeNodeSender = className.getNodeSender(propertiesReader.getNodeSender());
  279.         try{
  280.             INodeSender nodeSender = (INodeSender) loader.newInstance(classTypeNodeSender);
  281.             nodeSender.toString();
  282.             logInfo(logCore, "Inizializzazione gestore NodeSender di tipo "+classTypeNodeSender+" effettuata.");
  283.         }catch(Exception e){
  284.             throw new Exception("Riscontrato errore durante il caricamento della classe ["+classTypeNodeSender+
  285.                     "] da utilizzare per la spedizione nell'infrastruttura: "+e.getMessage());
  286.         }

  287.         // Inizializzazione NodeReceiver
  288.         String classType = className.getNodeReceiver(propertiesReader.getNodeReceiver());
  289.         try{
  290.             INodeReceiver nodeReceiver = (INodeReceiver) loader.newInstance(classType);
  291.             nodeReceiver.toString();
  292.             logInfo(logCore, "Inizializzazione gestore NodeReceiver di tipo "+classType+" effettuata.");
  293.         }catch(Exception e){
  294.             throw new Exception("Riscontrato errore durante il caricamento della classe ["+classType+
  295.                     "] da utilizzare per la ricezione dall'infrastruttura: "+e.getMessage());
  296.         }

  297.         // Inizializzo IGestoreIntegrazionePA list
  298.         String [] tipiIntegrazioneDefault = propertiesReader.getTipoIntegrazionePA();
  299.         List<String> s = new ArrayList<>();
  300.         for (int i = 0; i < tipiIntegrazioneDefault.length; i++) {
  301.             try {
  302.                 IGestoreIntegrazionePA gestore = pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazioneDefault[i]);
  303.                 gestore.toString();
  304.                 s.add(tipiIntegrazioneDefault[i]);
  305.                 logCore .info("Inizializzazione gestore dati di integrazione per le erogazioni di tipo "
  306.                         + tipiIntegrazioneDefault[i]    + " effettuata.");
  307.             } catch (Exception e) {
  308.                 throw new Exception(e.getMessage(),e);
  309.             }
  310.         }
  311.         if(s.size()>0){
  312.             RicezioneBuste.defaultGestoriIntegrazionePA = s.toArray(new String[1]);
  313.         }
  314.        
  315.         // Inizializzo IGestoreIntegrazionePA per protocollo
  316.         RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA = new java.util.concurrent.ConcurrentHashMap<String, String[]>();
  317.         Enumeration<String> enumProtocols = ProtocolFactoryManager.getInstance().getProtocolNames();
  318.         while (enumProtocols.hasMoreElements()) {
  319.             String protocol = (String) enumProtocols.nextElement();
  320.             String [] tipiIntegrazionePA = propertiesReader.getTipoIntegrazionePA(protocol);
  321.             if(tipiIntegrazionePA!=null && tipiIntegrazionePA.length>0){
  322.                 List<String> tipiIntegrazionePerProtocollo = new ArrayList<>();
  323.                 for (int i = 0; i < tipiIntegrazionePA.length; i++) {
  324.                     try {
  325.                         IGestoreIntegrazionePA gestore = pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazionePA[i]);
  326.                         gestore.toString();
  327.                         tipiIntegrazionePerProtocollo.add(tipiIntegrazionePA[i]);
  328.                         logCore .info("Inizializzazione gestore dati di integrazione (protocollo: "+protocol+") per le erogazioni di tipo "
  329.                                 + tipiIntegrazionePA[i] + " effettuata.");
  330.                     } catch (Exception e) {
  331.                         throw new Exception(e.getMessage(),e);
  332.                     }
  333.                 }
  334.                 if(tipiIntegrazionePerProtocollo.size()>0){
  335.                     RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.put(protocol, tipiIntegrazionePerProtocollo.toArray(new String[1]));
  336.                 }
  337.             }
  338.         }
  339.        
  340.         // Inizializzo GestoriCredenziali PA
  341.         RicezioneBuste.tipiGestoriCredenziali = propertiesReader.getTipoGestoreCredenzialiPA();
  342.         if(RicezioneBuste.tipiGestoriCredenziali!=null){
  343.             for (int i = 0; i < RicezioneBuste.tipiGestoriCredenziali.length; i++) {
  344.                 classType = className.getGestoreCredenziali(RicezioneBuste.tipiGestoriCredenziali[i]);
  345.                 try {
  346.                     IGestoreCredenziali gestore = (IGestoreCredenziali)loader.newInstance(classType);
  347.                     gestore.toString();
  348.                     logCore .info("Inizializzazione gestore credenziali di tipo "
  349.                             + RicezioneBuste.tipiGestoriCredenziali[i]  + " effettuata.");
  350.                 } catch (Exception e) {
  351.                     throw new Exception(
  352.                             "Riscontrato errore durante il caricamento della classe ["+ classType
  353.                             + "] da utilizzare per la gestione delle credenziali di tipo ["
  354.                             + RicezioneBuste.tipiGestoriCredenziali[i]+ "]: " + e.getMessage());
  355.                 }
  356.             }
  357.         }

  358.         RicezioneBuste.initializeService = true;
  359.     }


  360.     /** Generatore Errori */
  361.     private RicezioneBusteExternalErrorGenerator generatoreErrore;
  362.    
  363.     /** Contesto della richiesta */
  364.     private RicezioneBusteContext msgContext;
  365.    
  366.     public RicezioneBuste(RicezioneBusteContext context,
  367.             RicezioneBusteExternalErrorGenerator generatoreErrore){
  368.         this.msgContext = context;
  369.         this.generatoreErrore = generatoreErrore;
  370.     }


  371.     public void process(Object ... params){

  372.        
  373.        

  374.         // ------------- dati generali -----------------------------

  375.         // Context
  376.         PdDContext context = this.msgContext.getPddContext();
  377.        
  378.         // Logger
  379.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  380.         if(logCore==null){
  381.             logCore = LoggerWrapperFactory.getLogger(RicezioneBuste.ID_MODULO);
  382.         }
  383.    
  384.         // MsgDiagnostico
  385.         MsgDiagnostico msgDiag = this.msgContext.getMsgDiagnostico();
  386.        
  387.         // Messaggio
  388.         OpenSPCoop2Message requestMessage = this.msgContext.getMessageRequest();
  389.         if(requestMessage==null){
  390.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore, msgDiag, new Exception("Request message is null"), "LetturaMessaggioRichiesta");
  391.         }

  392.        
  393.        
  394.        
  395.        
  396.        
  397.         // ------------- in-handler -----------------------------
  398.        
  399.         IProtocolFactory<?> protocolFactory = null;
  400.         try{
  401.             if(context==null) {
  402.                 throw new Exception("Context is null");
  403.             }
  404.             protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String)context.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  405.         }catch(Exception e){
  406.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, logCore, msgDiag, e, "ProtocolFactoryInstance");
  407.             return;
  408.         }
  409.         InRequestContext inRequestContext = new InRequestContext(logCore,protocolFactory,null);
  410.         // TipoPorta
  411.         inRequestContext.setTipoPorta(TipoPdD.APPLICATIVA);
  412.         inRequestContext.setIdModulo(this.msgContext.getIdModulo());
  413.         // Informazioni connettore ingresso
  414.         InfoConnettoreIngresso connettore = new InfoConnettoreIngresso();
  415.         connettore.setCredenziali(this.msgContext.getCredenziali());
  416.         if(this.msgContext.getUrlProtocolContext()!=null &&
  417.                 this.msgContext.getUrlProtocolContext().getHttpServletRequest()!=null){
  418.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance(); // Puo' non essere inizializzato
  419.             if(properties!=null){
  420.                 String tipo = properties.getRealContainerCustom();
  421.                 if(tipo!=null) {
  422.                     try {
  423.                         ClassNameProperties className = ClassNameProperties.getInstance();
  424.                         Loader loader = Loader.getInstance();
  425.                         // Check tipi registrati
  426.                         String tipoClass = className.getRealmContainerCustom(tipo);
  427.                         IAutorizzazioneSecurityContainer authEngine = (IAutorizzazioneSecurityContainer) loader.newInstance(tipoClass);
  428.                         authEngine.init(this.msgContext.getUrlProtocolContext().getHttpServletRequest(),
  429.                                 context, protocolFactory);
  430.                         AutorizzazioneHttpServletRequest httpServletRequestAuth = new AutorizzazioneHttpServletRequest(this.msgContext.getUrlProtocolContext().getHttpServletRequest(), authEngine);
  431.                         this.msgContext.getUrlProtocolContext().updateHttpServletRequest(httpServletRequestAuth);                  
  432.                     }catch(Exception e){
  433.                         setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore, msgDiag, e, "AutorizzazioneSecurityContainerInstance");
  434.                         return;
  435.                     }
  436.                 }
  437.             }
  438.         }
  439.         connettore.setUrlProtocolContext(this.msgContext.getUrlProtocolContext());  
  440.         if(requestMessage!=null && ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())){
  441.             try{
  442.                 connettore.setSoapAction(requestMessage.castAsSoap().getSoapAction());
  443.             }catch(Exception e){
  444.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore,msgDiag, e, "LetturaSoapAction");
  445.                 return;
  446.             }
  447.         }
  448.         connettore.setFromLocation(this.msgContext.getSourceLocation());
  449.         inRequestContext.setConnettore(connettore);
  450.         // Data accettazione richiesta
  451.         inRequestContext.setDataAccettazioneRichiesta(this.msgContext.getDataAccettazioneRichiesta());
  452.         // Data ingresso richiesta
  453.         inRequestContext.setDataElaborazioneMessaggio(this.msgContext.getDataIngressoRichiesta());
  454.         // PddContext
  455.         inRequestContext.setPddContext(context);
  456.         // Dati Messaggio
  457.         inRequestContext.setMessaggio(requestMessage);
  458.         // Invoke handler
  459.         try{
  460.             GestoreHandlers.inRequest(inRequestContext, msgDiag, logCore);
  461.         }catch(HandlerException e){
  462.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore,msgDiag, e, e.getIdentitaHandler());
  463.             return;
  464.         }catch(Exception e){
  465.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore,msgDiag, e, "InvocazioneInRequestHandler");
  466.             return;
  467.         }

  468.        
  469.        
  470.        
  471.        
  472.        
  473.        
  474.         // ------------- process -----------------------------
  475.         HashMap<String, Object> internalObjects = new HashMap<>();
  476.         try{
  477.             process_engine(inRequestContext,internalObjects,params);
  478.         } catch(TracciamentoException tracciamentoException){
  479.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, tracciamentoException, "TracciamentoNonRiuscito");
  480.             return;
  481.         } catch(DumpException e){
  482.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "DumpNonRiuscito");
  483.             return;
  484.         } catch(ProtocolException protocolException){
  485.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, protocolException, "ProtocolFactoryNonInstanziata");
  486.             return;
  487.         }
  488.        
  489.         try{
  490.             if(context!=null  && this.msgContext.getIntegrazione()!=null){
  491.                 if(context.containsKey(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RICHIESTA)){
  492.                     this.msgContext.getIntegrazione().setTipoProcessamentoMtomXopRichiesta(
  493.                             (String)context.getObject(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RICHIESTA));
  494.                 }
  495.                 if(context.containsKey(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RISPOSTA)){
  496.                     this.msgContext.getIntegrazione().setTipoProcessamentoMtomXopRisposta(
  497.                             (String)context.getObject(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RISPOSTA));
  498.                 }
  499.                 if(context.containsKey(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RICHIESTA)){
  500.                     this.msgContext.getIntegrazione().setTipoMessageSecurityRichiesta(
  501.                             (String)context.getObject(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RICHIESTA));
  502.                 }
  503.                 if(context.containsKey(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RISPOSTA)){
  504.                     this.msgContext.getIntegrazione().setTipoMessageSecurityRisposta(
  505.                             (String)context.getObject(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RISPOSTA));
  506.                 }
  507.             }
  508.         }catch(Exception e){
  509.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "FinalizeIntegrationContextRicezioneBuste");
  510.             return;
  511.         }
  512.        
  513.        
  514.        
  515.        
  516.        
  517.        
  518.        
  519.         // ------------- Dump richiesta in ingresso -----------------------------
  520.         if(!internalObjects.containsKey(CostantiPdD.DUMP_RICHIESTA_EFFETTUATO) &&
  521.             Dump.isSistemaDumpDisponibile()){
  522.             try{
  523.                 ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();  
  524.                
  525.                 if(!internalObjects.containsKey(CostantiPdD.DUMP_CONFIG)) {
  526.                     URLProtocolContext urlProtocolContext = this.msgContext.getUrlProtocolContext();
  527.                     if(urlProtocolContext!=null && urlProtocolContext.getInterfaceName()!=null) {
  528.                         IDPortaApplicativa identificativoPortaApplicativa = new IDPortaApplicativa();
  529.                         identificativoPortaApplicativa.setNome(urlProtocolContext.getInterfaceName());
  530.                         PortaApplicativa portaApplicativa = configurazionePdDReader.getPortaApplicativaSafeMethod(identificativoPortaApplicativa, this.msgContext.getRequestInfo());
  531.                         if(portaApplicativa!=null) {
  532.                             DumpConfigurazione dumpConfig = configurazionePdDReader.getDumpConfigurazione(portaApplicativa);
  533.                             internalObjects.put(CostantiPdD.DUMP_CONFIG, dumpConfig);
  534.                         }
  535.                     }
  536.                 }
  537.                
  538.                 OpenSPCoop2Message msgRichiesta = inRequestContext.getMessaggio();
  539.                 if (msgRichiesta!=null) {
  540.                    
  541.                     Dump dumpApplicativo = getDump(configurazionePdDReader, protocolFactory, internalObjects, msgDiag.getPorta());
  542.                     dumpApplicativo.dumpRichiestaIngresso(msgRichiesta,
  543.                             inRequestContext.getConnettore().getUrlProtocolContext());
  544.                 }
  545.             }catch(DumpException dumpException){
  546.                 setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, dumpException, "DumpNonRiuscito");
  547.                 return;
  548.             }catch(Exception e){
  549.                 // Se non riesco ad accedere alla configurazione sicuramente gia' nel messaggio di risposta e' presente l'errore di PdD non correttamente inizializzata
  550.             }
  551.         }
  552.        
  553.        
  554.        
  555.        
  556.        
  557.        
  558.        
  559.        
  560.         // ------------- out-handler -----------------------------
  561.         OutResponseContext outResponseContext = new OutResponseContext(logCore,protocolFactory,null);
  562.         // TipoPorta
  563.         outResponseContext.setTipoPorta(this.msgContext.getTipoPorta());
  564.         outResponseContext.setIdModulo(this.msgContext.getIdModulo());
  565.         // DataUscitaMessaggio
  566.         outResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  567.         // PddContext
  568.         outResponseContext.setPddContext(inRequestContext.getPddContext());
  569.         // Informazioni busta e di integrazione
  570.         outResponseContext.setProtocollo(this.msgContext.getProtocol());
  571.         outResponseContext.setIntegrazione(this.msgContext.getIntegrazione());
  572.         // Header di trasporto della risposta
  573.         outResponseContext.setResponseHeaders(this.msgContext.getResponseHeaders());
  574.         // Messaggio
  575.         OpenSPCoop2Message msgResponse = this.msgContext.getMessageResponse();
  576.         outResponseContext.setMessaggio(msgResponse);
  577.         // Invoke handler
  578.         try{
  579.             GestoreHandlers.outResponse(outResponseContext, msgDiag, logCore);
  580.         }catch(HandlerException e){
  581.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, e.getIdentitaHandler());
  582.             return;
  583.         }catch(Exception e){
  584.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "InvocazioneOutResponseHandler");
  585.             return;
  586.         }
  587.        
  588.        
  589.        
  590.        
  591.        
  592.         // ---------------- fine gestione ------------------------------
  593.         OpenSPCoop2Message msgRisposta = null;
  594.        
  595.         try{
  596.             msgRisposta = outResponseContext.getMessaggio();
  597.             boolean rispostaPresente = true;
  598.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance(); // Puo' non essere inizializzato
  599.             if(properties!=null){
  600.                 rispostaPresente = ServicesUtils.verificaRispostaRelazioneCodiceTrasporto202(protocolFactory,OpenSPCoop2Properties.getInstance(), msgRisposta,true);
  601.             }
  602.             if(rispostaPresente){
  603.                 this.msgContext.setMessageResponse(msgRisposta);
  604.             }else{
  605.                 this.msgContext.setMessageResponse(null);
  606.                 msgRisposta = null;
  607.             }
  608.         }catch(Exception e){
  609.             setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "FineGestioneRicezioneBuste");
  610.             return;
  611.         }
  612.    
  613.        
  614.        
  615.        
  616.        
  617.        
  618.        
  619.        
  620.        
  621.        
  622.         // ------------- Dump risposta in uscita-----------------------------
  623.         if(Dump.isSistemaDumpDisponibile()){
  624.             try{
  625.                 ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();  
  626.                 if (msgRisposta!=null) {
  627.                    
  628.                     Dump dumpApplicativo = getDump(configurazionePdDReader, protocolFactory, internalObjects, msgDiag.getPorta());
  629.                     if(outResponseContext.getResponseHeaders()==null) {
  630.                         outResponseContext.setResponseHeaders(new HashMap<>());
  631.                     }
  632.                     Map<String, List<String>> propertiesTrasporto = outResponseContext.getResponseHeaders();
  633.                     ServiceBinding sb = requestMessage!=null ? requestMessage.getServiceBinding() : this.msgContext.getRequestInfo().getProtocolServiceBinding();
  634.                     ServicesUtils.setGovWayHeaderResponse(sb,
  635.                             msgRisposta, OpenSPCoop2Properties.getInstance(),
  636.                             propertiesTrasporto, logCore, false, outResponseContext.getPddContext(), this.msgContext.getRequestInfo());
  637.                     dumpApplicativo.dumpRispostaUscita(msgRisposta,
  638.                             inRequestContext.getConnettore().getUrlProtocolContext(),
  639.                             outResponseContext.getResponseHeaders());
  640.                 }
  641.             }catch(DumpException dumpException){
  642.                 setSOAPFault_processamento(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, dumpException, "DumpNonRiuscito");
  643.             }catch(Exception e){
  644.                 logError(logCore, e.getMessage(),e);
  645.                 // Se non riesco ad accedere alla configurazione sicuramente gia' nel messaggio di risposta e' presente l'errore di PdD non correttamente inizializzata
  646.             }
  647.         }

  648.     }
  649.    
  650.     private Dump getDump(ConfigurazionePdDManager configurazionePdDReader,
  651.             IProtocolFactory<?> protocolFactory,
  652.             HashMap<String, Object> internalObjects,
  653.             String nomePorta) throws DumpException, DriverRegistroServiziException {
  654.         DumpConfigurazione dumpConfig = null;
  655.         if(internalObjects.containsKey(CostantiPdD.DUMP_CONFIG)) {
  656.             dumpConfig = (DumpConfigurazione) internalObjects.get(CostantiPdD.DUMP_CONFIG); // dovrebbe essere stata impostata per la pd/pa specifica
  657.         }
  658.         else {
  659.             dumpConfig = configurazionePdDReader.getDumpConfigurazionePortaApplicativa();
  660.         }
  661.        
  662.         ProtocolContext protocolContext = this.msgContext.getProtocol();
  663.         URLProtocolContext urlProtocolContext = this.msgContext.getUrlProtocolContext();
  664.         IDSoggetto soggettoErogatore = null;
  665.         IDServizio idServizio = null;
  666.         IDSoggetto fruitore = null;
  667.         IDSoggetto dominio = null;
  668.         String idRichiesta = null;
  669.         if(protocolContext!=null) {
  670.             if(protocolContext.getTipoServizio()!=null && protocolContext.getServizio()!=null && protocolContext.getVersioneServizio()!=null &&
  671.                 protocolContext.getErogatore()!=null && protocolContext.getErogatore().getTipo()!=null && protocolContext.getErogatore().getNome()!=null) {
  672.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(protocolContext.getTipoServizio(), protocolContext.getServizio(),
  673.                         protocolContext.getErogatore(), protocolContext.getVersioneServizio());
  674.             }
  675.             dominio = protocolContext.getDominio();
  676.             idRichiesta = protocolContext.getIdRichiesta();
  677.             if(protocolContext.getFruitore()!=null && protocolContext.getFruitore().getTipo()!=null && protocolContext.getFruitore().getNome()!=null) {
  678.                 fruitore = protocolContext.getFruitore();
  679.             }
  680.         }
  681.        
  682.         if(dominio == null || fruitore==null || idServizio == null) {
  683.             if(urlProtocolContext!=null && urlProtocolContext.getInterfaceName()!=null) {
  684.                 IDPortaApplicativa identificativoPortaApplicativa = new IDPortaApplicativa();
  685.                 identificativoPortaApplicativa.setNome(urlProtocolContext.getInterfaceName());
  686.                 PortaApplicativa portaApplicativa = null;
  687.                 try {
  688.                     portaApplicativa = configurazionePdDReader.getPortaApplicativaSafeMethod(identificativoPortaApplicativa, this.msgContext.getRequestInfo());
  689.                 }catch(Exception e) {
  690.                     // ignore
  691.                 }
  692.                 if(portaApplicativa!=null) {
  693.                     // Aggiorno tutti
  694.                     soggettoErogatore = new IDSoggetto(portaApplicativa.getTipoSoggettoProprietario(), portaApplicativa.getNomeSoggettoProprietario());
  695.                     if(portaApplicativa.getServizio()!=null) {
  696.                         idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(portaApplicativa.getServizio().getTipo(),portaApplicativa.getServizio().getNome(),
  697.                                     soggettoErogatore, portaApplicativa.getServizio().getVersione());
  698.                     }
  699.                     dominio = new IDSoggetto(portaApplicativa.getTipoSoggettoProprietario(), portaApplicativa.getNomeSoggettoProprietario());
  700.                     try {
  701.                         dominio.setCodicePorta(RegistroServiziManager.getInstance().getDominio(dominio, null, protocolFactory, this.msgContext.getRequestInfo()));
  702.                     }catch(Exception e) {
  703.                         dominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory.getProtocol(), this.msgContext.getRequestInfo());
  704.                     }
  705.                 }
  706.             }
  707.         }
  708.         if(idServizio!=null) {
  709.             if(protocolContext!=null && protocolContext.getAzione()!=null) {
  710.                 idServizio.setAzione(protocolContext.getAzione());
  711.             }
  712.             else if(this.msgContext.getRequestInfo()!=null &&
  713.                     this.msgContext.getRequestInfo().getIdServizio()!=null && this.msgContext.getRequestInfo().getIdServizio().getAzione()!=null) {
  714.                 idServizio.setAzione(this.msgContext.getRequestInfo().getIdServizio().getAzione());
  715.             }
  716.         }
  717.         if(dominio==null) {
  718.             dominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory.getProtocol(), this.msgContext.getRequestInfo());
  719.         }
  720.        
  721.         Dump dumpApplicativo = null;
  722.         if(protocolContext!=null){
  723.             dumpApplicativo = new Dump(dominio,
  724.                     this.msgContext.getIdModulo(),
  725.                     idRichiesta, fruitore, idServizio,
  726.                     this.msgContext.getTipoPorta(),nomePorta,this.msgContext.getPddContext(),
  727.                     null,null,
  728.                     dumpConfig);
  729.         }else{
  730.             dumpApplicativo = new Dump(dominio,
  731.                     this.msgContext.getIdModulo(),this.msgContext.getTipoPorta(),nomePorta,this.msgContext.getPddContext(),
  732.                     null,null,
  733.                     dumpConfig);
  734.         }
  735.         return dumpApplicativo;
  736.     }
  737.    
  738.     // processamento quando non sono disponibili le risorse (es. MsgDiagnostico)
  739.     private void setSOAPFault_processamento(IntegrationFunctionError integrationFunctionError, ErroreIntegrazione erroreIntegrazione){
  740.         setSOAPFault_engine(integrationFunctionError, null, null, null, null, erroreIntegrazione, null, false);
  741.     }
  742.     private void setSOAPFault_processamento(IntegrationFunctionError integrationFunctionError, ErroreIntegrazione erroreIntegrazione, Exception e){
  743.         setSOAPFault_engine(integrationFunctionError, null, null, e, null, erroreIntegrazione, null, false);
  744.     }
  745.     // processamento
  746.     private void setSOAPFault_processamento(IntegrationFunctionError integrationFunctionError, Logger logCore, MsgDiagnostico msgDiag, Exception e, String posizione){
  747.         setSOAPFault_engine(integrationFunctionError, logCore, msgDiag, e, null, null, posizione, false);
  748.     }
  749.     private void setSOAPFault_processamento(IntegrationFunctionError integrationFunctionError, Logger logCore, MsgDiagnostico msgDiag, ErroreIntegrazione erroreIntegrazione, Exception e, String posizione){
  750.         setSOAPFault_engine(integrationFunctionError, logCore, msgDiag, e, null, erroreIntegrazione, posizione, false);
  751.     }
  752.     // intestazione
  753.     private void setSOAPFault_intestazione(IntegrationFunctionError integrationFunctionError, ErroreCooperazione erroreCooperazione){
  754.         setSOAPFault_engine(integrationFunctionError, null, null, null, erroreCooperazione, null, null, true);
  755.     }
  756.     @SuppressWarnings("unused")
  757.     private void setSOAPFault_intestazione(IntegrationFunctionError integrationFunctionError, ErroreIntegrazione erroreIntegrazione){
  758.         setSOAPFault_engine(integrationFunctionError, null, null, null, null, erroreIntegrazione, null, true);
  759.     }
  760.    
  761.     private void setSOAPFault_engine(IntegrationFunctionError integrationFunctionError, Logger logCore, MsgDiagnostico msgDiag, Exception e,
  762.             ErroreCooperazione erroreCooperazione, ErroreIntegrazione erroreIntegrazione, String posizioneErrore,
  763.             boolean validazione) {
  764.                
  765.         HandlerException he = null;
  766.         if(e!=null && (e instanceof HandlerException)){
  767.             he = (HandlerException) e;
  768.         }
  769.        
  770.         Context context = this.msgContext.getPddContext();
  771.        
  772.         if(msgDiag!=null){
  773.             if(he!=null){
  774.                 if(he.isEmettiDiagnostico()){
  775.                     msgDiag.logErroreGenerico(e, posizioneErrore);
  776.                 }
  777.             }else{
  778.                 String descrizioneErrore = null;
  779.                 if(erroreCooperazione != null){
  780.                     try{
  781.                         descrizioneErrore = erroreCooperazione.getDescrizione(this.generatoreErrore.getProtocolFactory());
  782.                     }catch(Throwable t){
  783.                         // ignore
  784.                     }
  785.                 }
  786.                 if(descrizioneErrore==null && erroreIntegrazione!=null) {
  787.                     try{
  788.                         descrizioneErrore = erroreIntegrazione.getDescrizione(this.generatoreErrore.getProtocolFactory());
  789.                     }catch(Throwable t){
  790.                         // ignore
  791.                     }
  792.                 }
  793.                 if(descrizioneErrore==null) {
  794.                     descrizioneErrore = posizioneErrore;
  795.                 }
  796.                 msgDiag.logErroreGenerico(descrizioneErrore, posizioneErrore); // nota: non emette informazioni sul core
  797.                 if(logCore!=null){
  798.                     if(e!=null) {
  799.                         logError(logCore, descrizioneErrore+": "+e.getMessage(),e);
  800.                     }
  801.                     else {
  802.                         logError(logCore, descrizioneErrore);
  803.                     }
  804.                 }
  805.             }
  806.         }
  807.         else if(logCore!=null){
  808.             if(e!=null) {
  809.                 logError(logCore, posizioneErrore+": "+e.getMessage(),e);
  810.             }
  811.             else {
  812.                 logError(logCore, posizioneErrore);
  813.             }
  814.         }
  815.         if (this.msgContext.isGestioneRisposta()) {
  816.             OpenSPCoop2Message messageFault = null;
  817.             if(validazione){
  818.                 if(erroreCooperazione != null){
  819.                     String descrizioneErrore = null;
  820.                     try{
  821.                         descrizioneErrore = erroreCooperazione.getDescrizione(this.generatoreErrore.getProtocolFactory());
  822.                         messageFault = this.generatoreErrore.buildErroreIntestazione(context, integrationFunctionError,
  823.                                 erroreCooperazione.getCodiceErrore(), descrizioneErrore);
  824.                     }catch(Exception eP){
  825.                         messageFault = this.generatoreErrore.buildFault(eP, context);
  826.                     }
  827.                 }else{
  828.                     messageFault = this.generatoreErrore.buildErroreIntestazione(context,integrationFunctionError,
  829.                             erroreIntegrazione);
  830.                 }
  831.             }else{
  832.                 if(erroreIntegrazione!=null){
  833.                     messageFault = this.generatoreErrore.buildErroreProcessamento(context,integrationFunctionError,
  834.                             erroreIntegrazione,e);
  835.                 }
  836.                 else if(e!=null){
  837.                     IntegrationFunctionError ifError = integrationFunctionError;
  838.                     ErroreIntegrazione erroreIntegrazioneGenerato = null;
  839.                     if(he!=null){
  840.                         erroreIntegrazioneGenerato = he.convertToErroreIntegrazione();
  841.                         if(he.getIntegrationFunctionError()!=null) {
  842.                             ifError = he.getIntegrationFunctionError();
  843.                         }
  844.                     }
  845.                     if(erroreIntegrazioneGenerato==null) {
  846.                         erroreIntegrazioneGenerato = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(posizioneErrore);
  847.                     }
  848.                     messageFault = this.generatoreErrore.buildErroreProcessamento(context,ifError,
  849.                             erroreIntegrazioneGenerato,e);
  850.                     if(he!=null){
  851.                         he.customized(messageFault);
  852.                     }
  853.                 }else{
  854.                     messageFault = this.generatoreErrore.buildErroreProcessamento(context,integrationFunctionError,
  855.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(posizioneErrore));
  856.                 }
  857.             }
  858.             // Lo imposto sempre, perche' puo' servire nell'handler
  859.             this.msgContext.setMessageResponse(messageFault);
  860.         }
  861.     }
  862.    
  863.    
  864.     private boolean checkInizializzazione(Logger logCore, ConfigurazionePdDManager configurazionePdDReader, RegistroServiziManager registroServiziReader) {
  865.         if( !OpenSPCoop2Startup.initialize){
  866.             String msgErrore = "Inizializzazione di GovWay non correttamente effettuata";
  867.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore);
  868.             try{
  869.                 // provo ad emetter un diagnostico
  870.                 if(this.msgContext.getMsgDiagnostico()!=null){
  871.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"InizializzazioneGovWay");
  872.                 }
  873.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  874.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_NOT_INITIALIZED,
  875.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  876.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA));
  877.             return false;
  878.         }
  879.         if( !TimerMonitoraggioRisorseThread.isRisorseDisponibili()){
  880.             String msgErrore = "Risorse di sistema non disponibili: "+ TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage();
  881.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore,TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  882.             try{
  883.                 // provo ad emetter un diagnostico
  884.                 if(this.msgContext.getMsgDiagnostico()!=null){
  885.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"InizializzazioneRisorseGovWay");
  886.                 }
  887.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  888.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  889.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  890.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_532_RISORSE_NON_DISPONIBILI));
  891.             return false;
  892.         }
  893.         if( !TimerThresholdThread.freeSpace){
  894.             String msgErrore = "Non sono disponibili abbastanza risorse per la gestione della richiesta";
  895.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore);
  896.             try{
  897.                 // provo ad emetter un diagnostico
  898.                 if(this.msgContext.getMsgDiagnostico()!=null){
  899.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"DisponibilitaRisorseGovWay");
  900.                 }
  901.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  902.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  903.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  904.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_533_RISORSE_DISPONIBILI_LIVELLO_CRITICO));
  905.             return false;
  906.         }
  907.         if( !Tracciamento.tracciamentoDisponibile){
  908.             String msgErrore = "Tracciatura non disponibile: "+ Tracciamento.motivoMalfunzionamentoTracciamento.getMessage();
  909.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore,Tracciamento.motivoMalfunzionamentoTracciamento);
  910.             try{
  911.                 // provo ad emetter un diagnostico
  912.                 if(this.msgContext.getMsgDiagnostico()!=null){
  913.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"Tracciamento");
  914.                 }
  915.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  916.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  917.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  918.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_545_TRACCIATURA_NON_FUNZIONANTE));
  919.             return false;
  920.         }
  921.         if( !MsgDiagnostico.gestoreDiagnosticaDisponibile){
  922.             String msgErrore = "Sistema di diagnostica non disponibile: "+ MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage();
  923.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore,MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  924.             try{
  925.                 // provo ad emetter un diagnostico lo stesso (molto probabilmente non ci riuscirà essendo proprio la risorsa diagnostica non disponibile)
  926.                 if(this.msgContext.getMsgDiagnostico()!=null){
  927.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"Diagnostica");
  928.                 }
  929.             }catch(Throwable t){logDebug(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  930.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  931.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  932.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_546_DIAGNOSTICA_NON_FUNZIONANTE));
  933.             return false;
  934.         }
  935.         if( !Dump.isSistemaDumpDisponibile()){
  936.             String msgErrore = "Sistema di dump dei contenuti applicativi non disponibile: "+ Dump.getMotivoMalfunzionamentoDump().getMessage();
  937.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore,Dump.getMotivoMalfunzionamentoDump());
  938.             try{
  939.                 // provo ad emetter un diagnostico
  940.                 if(this.msgContext.getMsgDiagnostico()!=null){
  941.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"Dump");
  942.                 }
  943.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  944.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  945.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  946.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_547_DUMP_CONTENUTI_APPLICATIVI_NON_FUNZIONANTE));
  947.             return false;
  948.         }
  949.         // Check Configurazione (XML)
  950.         try{
  951.             configurazionePdDReader.verificaConsistenzaConfigurazione();
  952.         }catch(Exception e){
  953.             String msgErrore = "Riscontrato errore durante la verifica della consistenza della configurazione";
  954.             logError(logCore, "["+RicezioneBuste.ID_MODULO+"]  "+msgErrore,e);
  955.             try{
  956.                 // provo ad emetter un diagnostico
  957.                 if(this.msgContext.getMsgDiagnostico()!=null){
  958.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"CheckConfigurazioneGovWay");
  959.                 }
  960.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  961.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  962.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  963.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e);
  964.             return false;
  965.         }
  966.         // Check RegistroServizi (XML)
  967.         try{
  968.             registroServiziReader.verificaConsistenzaRegistroServizi();
  969.         }catch(Exception e){
  970.             String msgErrore = "Riscontrato errore durante la verifica del registro dei servizi";
  971.             logError(logCore, "["+ RicezioneBuste.ID_MODULO+ "]  "+msgErrore,e);
  972.             try{
  973.                 // provo ad emetter un diagnostico
  974.                 if(this.msgContext.getMsgDiagnostico()!=null){
  975.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"CheckRegistroServizi");
  976.                 }
  977.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  978.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,
  979.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  980.                     get5XX_ErroreProcessamento(msgErrore,CodiceErroreIntegrazione.CODICE_534_REGISTRO_DEI_SERVIZI_NON_DISPONIBILE),e);
  981.             return false;
  982.         }
  983.        
  984.         return true;
  985.     }
  986.    
  987.     private void process_engine(InRequestContext inRequestContext,HashMap<String, Object> internalObjects,Object ... params)
  988.             throws TracciamentoException, DumpException, ProtocolException {
  989.        

  990.         /* ------------ Lettura parametri della richiesta ------------- */
  991.    
  992.         // Messaggio di ingresso
  993.         OpenSPCoop2Message requestMessage = inRequestContext.getMessaggio();
  994.        
  995.         // Logger
  996.         Logger logCore = inRequestContext.getLogCore();
  997.        
  998.         // Data Ingresso Richiesta
  999.         Date dataIngressoRichiesta = this.msgContext.getDataIngressoRichiesta();
  1000.        
  1001.         // ID Transazione
  1002.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, inRequestContext.getPddContext());
  1003.        
  1004.         // Loader
  1005.         Loader loader = Loader.getInstance();
  1006.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1007.        
  1008.         // RequestInfo
  1009.         RequestInfo requestInfo = this.msgContext.getRequestInfo();
  1010.        
  1011.        
  1012.         /* ------------ Controllo inizializzazione OpenSPCoop  ------------------ */
  1013.         ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();
  1014.         RegistroServiziManager registroServiziReader = RegistroServiziManager.getInstance();
  1015.         if(!checkInizializzazione(logCore, configurazionePdDReader, registroServiziReader)) {
  1016.             return;
  1017.         }





  1018.         /* ------------- Inizializzazione Risorse  ------------------- */

  1019.         // Credenziali utilizzate nella richiesta
  1020.         Credenziali credenziali = this.msgContext.getCredenziali();


  1021.         // OpenSPCoop Properties
  1022.         OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  1023.        
  1024.         // Classi registrate
  1025.         ClassNameProperties className = ClassNameProperties.getInstance();

  1026.         if(requestInfo==null) {
  1027.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,null,
  1028.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1029.                     get5XX_ErroreProcessamento("RequesInfo is null"),null,
  1030.                     "InizializzazioneRisorseServizioRicezioneBuste");
  1031.             return;
  1032.         }
  1033.        
  1034.         //  IdentificativoPdD
  1035.         IDSoggetto identitaPdD = requestInfo.getIdentitaPdD();

  1036.        
  1037.         // ConnectorInMessage
  1038.         ConnectorInMessage connectorInMessage = null;
  1039.         if(params!=null){
  1040.             for (int i = 0; i < params.length; i++) {
  1041.                 if(params[i]!=null && (params[i] instanceof ConnectorInMessage) ){
  1042.                     connectorInMessage = (ConnectorInMessage) params[i];
  1043.                     break;
  1044.                 }
  1045.             }
  1046.         }
  1047.        
  1048.         // ProtocolFactory
  1049.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  1050.         PdDContext pddContext = inRequestContext.getPddContext();
  1051.         ITraduttore traduttore = protocolFactory.createTraduttore();
  1052.        
  1053.         //  Logger dei messaggi diagnostici
  1054.         String nomePorta = null;
  1055.         if(requestInfo.getProtocolContext().getInterfaceName()!=null){
  1056.             nomePorta = requestInfo.getProtocolContext().getInterfaceName();
  1057.         }
  1058.         else{
  1059.             nomePorta = inRequestContext.getConnettore().getUrlProtocolContext().getFunctionParameters() + "_urlInvocazione("+ inRequestContext.getConnettore().getUrlProtocolContext().getUrlInvocazione_formBased() + ")";
  1060.         }
  1061.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.APPLICATIVA,identitaPdD,this.msgContext.getIdModulo(),nomePorta,requestInfo,configurazionePdDReader);
  1062.         if(msgDiag==null) {
  1063.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_NOT_INITIALIZED,logCore,null,
  1064.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1065.                     get5XX_ErroreProcessamento("MsgDiagnostico is null",CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),null,
  1066.                     "InizializzazioneRisorseServizioRicezioneBuste");
  1067.             return;
  1068.         }
  1069.         this.msgContext.setMsgDiagnostico(msgDiag); // aggiorno msg diagnostico
  1070.         msgDiag.setPddContext(inRequestContext.getPddContext(), protocolFactory);
  1071.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  1072.            
  1073.         // Parametri della porta applicativa invocata
  1074.         URLProtocolContext urlProtocolContext = this.msgContext.getUrlProtocolContext();
  1075.        
  1076.         // setCredenziali
  1077.         setCredenziali(credenziali, msgDiag);
  1078.        
  1079.         // inizializzazione risorse statiche
  1080.         try{
  1081.             if(RicezioneBuste.initializeService==false){
  1082.                 msgDiag.mediumDebug("Inizializzazione risorse statiche...");
  1083.                 RicezioneBuste.initializeService(configurazionePdDReader, className, propertiesReader,logCore);
  1084.             }
  1085.         }catch(Exception e){
  1086.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_NOT_INITIALIZED,logCore,msgDiag,
  1087.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1088.                     get5XX_ErroreProcessamento(e,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),e,
  1089.                     "InizializzazioneRisorseServizioRicezioneBuste");
  1090.             return;
  1091.         }
  1092.        
  1093.         // Imposto header di risposta
  1094.         Map<String, List<String>> headerRisposta = new HashMap<>();
  1095.         UtilitiesIntegrazione utilitiesHttpRisposta = UtilitiesIntegrazione.getInstancePAResponse(logCore);
  1096.         try{
  1097.             utilitiesHttpRisposta.setInfoProductTransportProperties(headerRisposta);
  1098.         }catch(Exception e){
  1099.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1100.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1101.                     get5XX_ErroreProcessamento(e),e,
  1102.                     "InizializzazioneHeaderRisposta");
  1103.             return;
  1104.         }
  1105.         this.msgContext.setResponseHeaders(headerRisposta);

  1106.         // OPENSPCOOPSTATE
  1107.         OpenSPCoopState openspcoopstate = null;
  1108.         try{ // finally in fondo, vedi  #try-finally-openspcoopstate#

  1109.         // Messaggio di libreria
  1110.         SbustamentoMessage sbustamentoMSG = new SbustamentoMessage();
  1111.         InoltroBusteMessage inoltroMSG = new InoltroBusteMessage();

  1112.         // Context di risposta
  1113.         this.msgContext.setProtocol(new ProtocolContext());
  1114.         this.msgContext.getProtocol().setDominio(this.msgContext.getIdentitaPdD());
  1115.         this.msgContext.setIntegrazione(new IntegrationContext());
  1116.        

  1117.         // DBManager
  1118.         msgDiag.mediumDebug("Richiesta connessione al database...");
  1119.         try{
  1120.             openspcoopstate = new OpenSPCoopStateful();
  1121.             openspcoopstate.setUseConnection(false); // gestione stateless per default
  1122.             openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(),idTransazione);
  1123.         }catch(Exception e){
  1124.             setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,logCore,msgDiag,
  1125.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1126.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION),e,
  1127.                     "initDatabaseResource");
  1128.             return;
  1129.         }
  1130.        
  1131.         // Refresh reader
  1132.         registroServiziReader = registroServiziReader.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  1133.         configurazionePdDReader = configurazionePdDReader.refreshState(registroServiziReader);
  1134.         msgDiag.updateState(configurazionePdDReader);

  1135.         // Dati precedentemente raccolti
  1136.         String servizioApplicativoFruitore = null;
  1137.         String correlazioneApplicativa = null;
  1138.         if(this.msgContext.isTracciamentoAbilitato()==false){
  1139.             // e' gia stata effettuata un'analisi precedentemente
  1140.             servizioApplicativoFruitore = this.msgContext.getIdentitaServizioApplicativoFruitore();
  1141.             this.msgContext.getIntegrazione().setServizioApplicativoFruitore(servizioApplicativoFruitore);
  1142.             correlazioneApplicativa = this.msgContext.getIdCorrelazioneApplicativa();
  1143.             msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, servizioApplicativoFruitore);
  1144.             msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, correlazioneApplicativa);
  1145.             this.generatoreErrore.updateInformazioniCooperazione(servizioApplicativoFruitore);
  1146.         }

  1147.         // Transaction
  1148.         Transaction transaction = null;
  1149.         try{
  1150.             transaction = TransactionContext.getTransaction(idTransazione);
  1151.         }catch(Exception e){
  1152.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1153.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1154.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),e,
  1155.                     "getTransaction");
  1156.             return;
  1157.         }
  1158.        
  1159.        
  1160.        
  1161.        
  1162.         // Messaggio di generazione Errore Protocollo
  1163.         RicezioneBusteParametriGenerazioneBustaErrore parametriGenerazioneBustaErrore = new RicezioneBusteParametriGenerazioneBustaErrore();
  1164.         parametriGenerazioneBustaErrore.setOpenspcoop(openspcoopstate);
  1165.         parametriGenerazioneBustaErrore.setIdentitaPdD(identitaPdD);
  1166.         parametriGenerazioneBustaErrore.setMsgDiag(msgDiag);
  1167.         parametriGenerazioneBustaErrore.setPropertiesReader(propertiesReader);
  1168.         parametriGenerazioneBustaErrore.setLogCore(logCore);
  1169.         parametriGenerazioneBustaErrore.setCorrelazioneApplicativa(correlazioneApplicativa);
  1170.         parametriGenerazioneBustaErrore.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  1171.         parametriGenerazioneBustaErrore.setImplementazionePdDMittente(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1172.         parametriGenerazioneBustaErrore.setImplementazionePdDDestinatario(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1173.        
  1174.        
  1175.         // Messaggio di invio Errore Protocollo
  1176.         RicezioneBusteParametriInvioBustaErrore parametriInvioBustaErrore = new RicezioneBusteParametriInvioBustaErrore();
  1177.         parametriInvioBustaErrore.setOpenspcoop(openspcoopstate);
  1178.         parametriInvioBustaErrore.setIdentitaPdD(identitaPdD);
  1179.         parametriInvioBustaErrore.setMsgDiag(msgDiag);
  1180.         parametriInvioBustaErrore.setPropertiesReader(propertiesReader);
  1181.         parametriInvioBustaErrore.setLogCore(logCore);
  1182.         parametriInvioBustaErrore.setCorrelazioneApplicativa(correlazioneApplicativa);
  1183.         parametriInvioBustaErrore.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  1184.         parametriInvioBustaErrore.setImplementazionePdDMittente(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1185.         parametriInvioBustaErrore.setImplementazionePdDDestinatario(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  1186.        
  1187.         parametriInvioBustaErrore.setNewConnectionForResponse(false);
  1188.         parametriInvioBustaErrore.setUtilizzoIndirizzoTelematico(false);
  1189.         parametriInvioBustaErrore.setFunctionAsRouter(false);
  1190.         parametriInvioBustaErrore.setOnewayVersione11(false);
  1191.         parametriInvioBustaErrore.setPddContext(inRequestContext.getPddContext());
  1192.        
  1193.         // RicezioneBusteUtils
  1194.         RicezioneBusteUtils ricezioneBusteUtils = new RicezioneBusteUtils();
  1195.        
  1196.        

  1197.        
  1198.        

  1199.        
  1200.        
  1201.        
  1202.        
  1203.        
  1204.        
  1205.        
  1206.        
  1207.        
  1208.         /* ------------ Identificazione IDServizio  ------------- */    
  1209.        
  1210.         msgDiag.mediumDebug("Identificazione IDServizio ...");
  1211.        
  1212.         IDServizio idServizio = requestInfo.getIdServizio();
  1213.         PortaApplicativa pa = null;
  1214.         if(idServizio==null){
  1215.             // avviene solamente se abbiamo invocazioni speciali con contextURL
  1216.             // provo ad individuarlo con il protocollo
  1217.             String idBusta = null;
  1218.             String profiloBusta = null;
  1219.             try{
  1220.                 Busta busta = protocolFactory.createValidazioneSintattica(openspcoopstate.getStatoRichiesta()).getBusta_senzaControlli(requestMessage);
  1221.                 if(busta==null){
  1222.                     throw new Exception("Protocollo non individuato nel messaggio");
  1223.                 }
  1224.                 idBusta = busta.getID();
  1225.                 profiloBusta = busta.getProfiloDiCollaborazioneValue();
  1226.                
  1227.                 if(busta.getTipoDestinatario()==null){
  1228.                     throw new Exception("TipoDestinatario non individuato nel messaggio");
  1229.                 }
  1230.                 if(busta.getDestinatario()==null){
  1231.                     throw new Exception("Destinatario non individuato nel messaggio");
  1232.                 }
  1233.                 if(busta.getTipoServizio()==null){
  1234.                     throw new Exception("TipoServizio non individuato nel messaggio");
  1235.                 }
  1236.                 if(busta.getServizio()==null){
  1237.                     throw new Exception("Servizio non individuato nel messaggio");
  1238.                 }
  1239.                 if(busta.getVersioneServizio()==null){
  1240.                     throw new Exception("VersioneServizio non individuato nel messaggio");
  1241.                 }
  1242.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(),
  1243.                         busta.getTipoDestinatario(), busta.getDestinatario(),
  1244.                         busta.getVersioneServizio());
  1245.                 idServizio.getSoggettoErogatore().setCodicePorta(registroServiziReader.getDominio(idServizio.getSoggettoErogatore(), null, protocolFactory, requestInfo));
  1246.                 idServizio.setAzione(busta.getAzione());
  1247.                 requestInfo.setIdServizio(idServizio);
  1248.                
  1249.                 List<PortaApplicativa> listPa = configurazionePdDReader.getPorteApplicative(idServizio, false);
  1250. //              if(listPa.size()<=0){
  1251. //                  throw new Exception("Non esiste alcuna porta applicativa indirizzabile tramite il servizio ["+idServizio+"]");
  1252. //              }
  1253.                 // NOTA: la pa potra' essere null nei casi di profili asincroni
  1254.                 if(listPa.size()>0){
  1255.                     if(listPa.size()>1)
  1256.                         throw new Exception("Esiste più di una porta applicativa indirizzabile tramite il servizio ["+idServizio+"]");
  1257.                     pa = listPa.get(0);
  1258.                    
  1259.                     IDPortaApplicativa idPA = new IDPortaApplicativa();
  1260.                     idPA.setNome(pa.getNome());
  1261.                     idPA.setIdentificativiErogazione(new IdentificativiErogazione());
  1262.                     idPA.getIdentificativiErogazione().setIdServizio(idServizio);
  1263.                     RicezioneBusteServiceUtils.updatePortaApplicativaRequestInfo(requestInfo, logCore,
  1264.                             requestMessage,
  1265.                             this.generatoreErrore,
  1266.                             ServicesUtils.getServiceIdentificationReader(logCore, requestInfo, registroServiziReader, configurazionePdDReader), msgDiag,
  1267.                             urlProtocolContext, idPA,
  1268.                             pddContext);
  1269.                     //requestInfo.getProtocolContext().setInterfaceName(pa.getNome());
  1270.                 }
  1271.                
  1272.             }catch(Exception e){
  1273.                
  1274.                 logDebug(logCore, e.getMessage(),e); // lascio come debug puo' essere utile
  1275.                
  1276. //              boolean checkAsSecondaFaseAsincrono = false;
  1277. //              try{
  1278. //                  if(idServizio!=null){
  1279. //                      IProtocolConfiguration config = protocolFactory.createProtocolConfiguration();
  1280. //                      if(config.isSupportato(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO) ||
  1281. //                              config.isSupportato(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO)    ) {
  1282. //                          Busta busta = protocolFactory.createValidazioneSintattica().getBusta_senzaControlli(requestMessage);
  1283. //                          if(busta!=null && busta.getProfiloDiCollaborazione()!=null) {
  1284. //                              if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ||
  1285. //                                      org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione())
  1286. //                                  ) {
  1287. //                                  if(busta.getRiferimentoMessaggio()!=null) {
  1288. //                                      checkAsSecondaFaseAsincrono = true;
  1289. //                                  }
  1290. //                              }
  1291. //                          }
  1292. //                      }
  1293. //                  }
  1294. //              }catch(Exception eAsincronoCheck){
  1295. //                  logError(logCore, "Errore durante il controllo della presenza di un profilo asincrono: "+eAsincronoCheck.getMessage(),eAsincronoCheck);
  1296. //              }
  1297. //              
  1298. //              if(checkAsSecondaFaseAsincrono==false) {
  1299.                
  1300.                 ServiceBindingConfiguration bindingConfig = requestInfo.getBindingConfig();
  1301.                 if(bindingConfig.existsContextUrlMapping()==false){
  1302.                     IntegrationFunctionError integrationFunctionError = null;
  1303.                     if(idServizio!=null){
  1304.                         msgDiag.addKeywords(idServizio);
  1305.                         if(idServizio.getAzione()==null){
  1306.                             msgDiag.addKeyword(CostantiPdD.KEY_AZIONE_BUSTA_RICHIESTA, "-");
  1307.                         }
  1308.                         msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idBusta!=null ? idBusta : "-");
  1309.                         msgDiag.addKeyword(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, profiloBusta!=null ? profiloBusta : "-");
  1310.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente.identificazionePerServizio");
  1311.                         integrationFunctionError = IntegrationFunctionError.NOT_FOUND;
  1312.                     }
  1313.                     else{
  1314.                         msgDiag.addKeywordErroreProcessamento(e);
  1315.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  1316.                         integrationFunctionError = IntegrationFunctionError.API_IN_UNKNOWN;
  1317.                     }
  1318.                    
  1319.                     // passo volutamente null come msgDiag poichè ho generato prima il diagnostico
  1320.                     setSOAPFault_processamento(integrationFunctionError,logCore,null,
  1321.                             ErroriIntegrazione.ERRORE_450_PA_INESISTENTE.getErroreIntegrazione(),e,
  1322.                             "IdentificazioneIDServizio");
  1323.                     openspcoopstate.releaseResource();
  1324.                     return;
  1325.                 }
  1326.             }
  1327.         }
  1328.         else{
  1329.             // L'interface name DEVE essere presente in questo caso
  1330.             try{
  1331.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  1332.                 idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  1333.                 pa = configurazionePdDReader.getPortaApplicativaSafeMethod(idPA, requestInfo);
  1334.                 // NOTA: la pa potra' essere null nei casi di profili asincroni
  1335.             }catch(Exception e){
  1336.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1337.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1338.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1339.                             "getPA");
  1340.                 openspcoopstate.releaseResource();
  1341.                 return;
  1342.             }
  1343.         }
  1344.         if(pa!=null){
  1345.             msgDiag.updatePorta(pa.getNome(), requestInfo);
  1346.         }

  1347.        
  1348.        
  1349.        
  1350.        
  1351.        
  1352.        
  1353.        
  1354.         /* ------------ Identificazione Router Function  ------------- */  
  1355.        
  1356.         // PdD Function: router o normale PdD
  1357.         boolean functionAsRouter = false;
  1358.         boolean soggettoVirtuale = false;
  1359.         msgDiag.mediumDebug("Esamina modalita' di ricezione (PdD/Router/SoggettoVirtuale)...");
  1360.         boolean existsSoggetto = false;
  1361.         try{
  1362.             if(idServizio!=null && idServizio.getSoggettoErogatore()!=null) {
  1363.                 existsSoggetto = configurazionePdDReader.existsSoggetto(idServizio.getSoggettoErogatore(), requestInfo);
  1364.             }
  1365.         }catch(Exception e){
  1366.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1367.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1368.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1369.                     "existsSoggetto("+idServizio.getSoggettoErogatore().toString()+")");
  1370.             openspcoopstate.releaseResource();
  1371.             return;
  1372.         }
  1373.         if(existsSoggetto==false){
  1374.             // La PdD non gestisce il soggetto destinatario della busta.
  1375.             // Controllo adesso che sia abilitata la funzione di Router per la PdD, altrimenti nel successivo
  1376.             // modulo verra' generato un errore di soggetto non gestito.
  1377.             msgDiag.mediumDebug("Raccolta identita router...");
  1378.             boolean routerFunctionActive = false;
  1379.             try{
  1380.                 routerFunctionActive = configurazionePdDReader.routerFunctionActive();
  1381.             }catch(Exception e){
  1382.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1383.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1384.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_514_ROUTING_CONFIGURATION_ERROR),e,
  1385.                         "ErroreCheckFunzionalitaRouterAttiva");
  1386.                 openspcoopstate.releaseResource();
  1387.                 return;
  1388.             }      
  1389.             if(routerFunctionActive){
  1390.                 functionAsRouter = true;    
  1391.                 try{
  1392.                     identitaPdD = configurazionePdDReader.getRouterIdentity(protocolFactory, requestInfo);
  1393.                 }catch(Exception e){
  1394.                     setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1395.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1396.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_514_ROUTING_CONFIGURATION_ERROR),e,
  1397.                             "ErroreRiconoscimentoIdentitaRouter");
  1398.                     openspcoopstate.releaseResource();
  1399.                     return;
  1400.                 }
  1401.             }
  1402.             // else: assume identita di default.
  1403.         }else{
  1404.             // identita assume quella dell'erogatore
  1405.             msgDiag.mediumDebug("Raccolta identita porta di dominio...");
  1406.             String dominio = null;
  1407.             try{
  1408.                 dominio = configurazionePdDReader.getIdentificativoPorta(idServizio.getSoggettoErogatore(),protocolFactory, requestInfo);
  1409.                 if(dominio==null){
  1410.                     throw new Exception("Dominio is null");
  1411.                 }
  1412.             }catch(Exception e){
  1413.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1414.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1415.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1416.                         "ErroreRiconoscimentoIdentitaPdD");
  1417.                 openspcoopstate.releaseResource();
  1418.                 return;
  1419.             }
  1420.             identitaPdD = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),
  1421.                     idServizio.getSoggettoErogatore().getNome(),dominio);
  1422.         }
  1423.         if(functionAsRouter){
  1424.             this.msgContext.setTipoPorta(TipoPdD.ROUTER);
  1425.         }
  1426.        
  1427.         // Context
  1428.         this.msgContext.setIdentitaPdD(identitaPdD);
  1429.         // GeneratoreErrore
  1430.         this.generatoreErrore.updateDominio(identitaPdD);
  1431.         // Raccolta dati Busta Ricevuta
  1432.         parametriGenerazioneBustaErrore.setIdentitaPdD(identitaPdD);
  1433.         parametriInvioBustaErrore.setIdentitaPdD(identitaPdD);
  1434.         parametriInvioBustaErrore.setFunctionAsRouter(functionAsRouter);
  1435.         // requestInfo
  1436.         requestInfo.setIdentitaPdD(identitaPdD);
  1437.         // altri
  1438.         msgDiag.setDominio(identitaPdD); // imposto anche il dominio nel msgDiag
  1439.         parametriGenerazioneBustaErrore.setMsgDiag(msgDiag);
  1440.         parametriInvioBustaErrore.setMsgDiag(msgDiag);
  1441.        
  1442.        
  1443.        
  1444.        
  1445.        
  1446.        
  1447.        
  1448.        
  1449.        
  1450.        
  1451.        
  1452.         /* --------------- Header Integrazione (viene letto solo se tracciamento e' abilitato altrimenti significa che il punto di ingresso ha gia gestito la lettura) --------------- */
  1453.         String[] tipiIntegrazionePA = null;
  1454.         msgDiag.mediumDebug("Header integrazione...");
  1455.         if(propertiesReader.processHeaderIntegrazionePARequest(functionAsRouter)){
  1456.             if(functionAsRouter ){
  1457.                 msgDiag.highDebug("Header integrazione (Default gestori integrazione Router)");
  1458.                 if(RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.containsKey(protocolFactory.getProtocol()))
  1459.                     tipiIntegrazionePA = RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.get(protocolFactory.getProtocol());
  1460.                 else
  1461.                     tipiIntegrazionePA = RicezioneBuste.defaultGestoriIntegrazionePA;
  1462.             }else{
  1463.                 msgDiag.highDebug("Header integrazione (Gestori integrazione...)");
  1464.                 if(pa!=null && this.msgContext.isTracciamentoAbilitato()){
  1465.                     msgDiag.mediumDebug("Lettura header di integrazione...");
  1466.                     try {
  1467.                         tipiIntegrazionePA = configurazionePdDReader.getTipiIntegrazione(pa);
  1468.                     } catch (Exception e) {
  1469.                         setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1470.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1471.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1472.                                 "configurazionePdDReader.getTipiIntegrazione(pa)");
  1473.                         openspcoopstate.releaseResource();
  1474.                         return;
  1475.                     }
  1476.                 }
  1477.                 msgDiag.highDebug("Header integrazione (Gestori integrazione terminato)");
  1478.                 if (tipiIntegrazionePA == null){
  1479.                     if(RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.containsKey(protocolFactory.getProtocol()))
  1480.                         tipiIntegrazionePA = RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.get(protocolFactory.getProtocol());
  1481.                     else
  1482.                         tipiIntegrazionePA = RicezioneBuste.defaultGestoriIntegrazionePA;
  1483.                 }
  1484.             }
  1485.         }
  1486.         HeaderIntegrazione headerIntegrazioneRichiesta = new HeaderIntegrazione(idTransazione);
  1487.         InRequestPAMessage inRequestPAMessage = null;
  1488.         if(tipiIntegrazionePA!=null){
  1489.             msgDiag.highDebug("Header integrazione (Impostazione ...)");
  1490.             inRequestPAMessage = new InRequestPAMessage();
  1491.             inRequestPAMessage.setMessage(requestMessage);
  1492.             inRequestPAMessage.setUrlProtocolContext(this.msgContext.getUrlProtocolContext());
  1493.             inRequestPAMessage.setPortaApplicativa(pa);
  1494.             inRequestPAMessage.setServizio(idServizio);
  1495.             for (int i = 0; i < tipiIntegrazionePA.length; i++) {
  1496.                 try {
  1497.                     IGestoreIntegrazionePA gestore = null;
  1498.                     try {
  1499.                         gestore = (IGestoreIntegrazionePA) pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazionePA[i]);
  1500.                     }catch(Exception e){
  1501.                         throw e;
  1502.                     }
  1503.                     if(gestore!=null){
  1504.                         String classType = null;
  1505.                         try {
  1506.                             classType = gestore.getClass().getName();
  1507.                             AbstractCore.init(gestore, pddContext, protocolFactory);
  1508.                         } catch (Exception e) {
  1509.                             throw new Exception(
  1510.                                     "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  1511.                                             + "] da utilizzare per la gestione dell'integrazione delle erogazioni di tipo ["+ tipiIntegrazionePA[i] + "]: " + e.getMessage());
  1512.                         }
  1513.                    
  1514.                         gestore.readInRequestHeader(headerIntegrazioneRichiesta, inRequestPAMessage);
  1515.                     }
  1516.                     else {
  1517.                         msgDiag.logErroreGenerico("Gestore ["
  1518.                                 + tipiIntegrazionePA[i]+ "], per la lettura dell'header di integrazione, non inizializzato",
  1519.                                 "gestoriIntegrazionePASoap.get("+tipiIntegrazionePA[i]+")");
  1520.                     }      
  1521.                 } catch (Exception e) {
  1522.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazionePA[i]);
  1523.                     msgDiag.addKeywordErroreProcessamento(e);
  1524.                     msgDiag.logPersonalizzato("headerIntegrazione.letturaFallita");
  1525.                 }
  1526.             }
  1527.             if(headerIntegrazioneRichiesta!=null){
  1528.                 msgDiag.highDebug("Header integrazione (set context...)");
  1529.                 if(this.msgContext.getIdentitaServizioApplicativoFruitore()!=null)
  1530.                     servizioApplicativoFruitore = this.msgContext.getIdentitaServizioApplicativoFruitore();
  1531.                 else
  1532.                     servizioApplicativoFruitore = headerIntegrazioneRichiesta.getServizioApplicativo();

  1533.                 parametriGenerazioneBustaErrore.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  1534.                 parametriInvioBustaErrore.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  1535.                 this.generatoreErrore.updateInformazioniCooperazione(servizioApplicativoFruitore);
  1536.                
  1537.                 if(this.msgContext.getIdCorrelazioneApplicativa()!=null)
  1538.                     correlazioneApplicativa = this.msgContext.getIdCorrelazioneApplicativa();
  1539.                 else
  1540.                     correlazioneApplicativa = headerIntegrazioneRichiesta.getIdApplicativo();
  1541.                 parametriGenerazioneBustaErrore.setCorrelazioneApplicativa(correlazioneApplicativa);
  1542.                 parametriInvioBustaErrore.setCorrelazioneApplicativa(correlazioneApplicativa);
  1543.                
  1544.                 msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, servizioApplicativoFruitore);
  1545.                 msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, correlazioneApplicativa);
  1546.                
  1547.                 this.msgContext.getIntegrazione().setIdCorrelazioneApplicativa(correlazioneApplicativa);
  1548.                 this.msgContext.getIntegrazione().setServizioApplicativoFruitore(servizioApplicativoFruitore);
  1549.                
  1550.                 msgDiag.highDebug("Header integrazione (set context ok)");
  1551.             }
  1552.         }
  1553.        
  1554.        
  1555.        
  1556.        
  1557.        
  1558.        
  1559.         Utilities.printFreeMemory("RicezioneBuste - Autorizzazione canale ...");
  1560.         ConfigurazioneCanaliNodo configurazioneCanaliNodo = null;
  1561.         try {
  1562.             if(!functionAsRouter) {
  1563.                 configurazioneCanaliNodo = configurazionePdDReader.getConfigurazioneCanaliNodo();
  1564.             }
  1565.         } catch (Exception e) {
  1566.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1567.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1568.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1569.                     "configurazionePdDReader.getConfigurazioneCanaliNodo()");
  1570.             openspcoopstate.releaseResource();
  1571.             return;
  1572.         }
  1573.         boolean canaleNonAutorizzato = false;
  1574.         try {
  1575.             if(configurazioneCanaliNodo!=null && configurazioneCanaliNodo.isEnabled()) {
  1576.            
  1577.                 msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  1578.                 msgDiag.logPersonalizzato("autorizzazioneCanale.inCorso");
  1579.                
  1580.                 String canaleApiInvocata = null;
  1581.                 if(pa!=null) {
  1582.                     String canalePorta = pa.getCanale();
  1583.                     if(canalePorta!=null && !"".equals(canalePorta)) {
  1584.                         canaleApiInvocata = canalePorta;
  1585.                     }
  1586.                     else {
  1587.                         try {
  1588.                             AccordoServizioParteSpecifica asps = registroServiziReader.getAccordoServizioParteSpecifica(idServizio, null, false, requestInfo);
  1589.                             if(asps!=null) {
  1590.                                 AccordoServizioParteComune aspc = registroServiziReader.getAccordoServizioParteComune(IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune()), null, false, false, requestInfo);
  1591.                                 if(aspc!=null) {
  1592.                                     String canaleApi = aspc.getCanale();
  1593.                                     if(canaleApi!=null && !"".equals(canaleApi)) {
  1594.                                         canaleApiInvocata = canaleApi;
  1595.                                     }
  1596.                                 }
  1597.                             }
  1598.                         }catch(DriverRegistroServiziNotFound notFound) {
  1599.                             // saranno segnalati altri errori dovuti al non riconoscimento del servizio
  1600.                         }
  1601.                     }
  1602.                    
  1603.                     if(canaleApiInvocata==null || "".equals(canaleApiInvocata)) {
  1604.                         canaleApiInvocata = configurazioneCanaliNodo.getCanaleDefault();
  1605.                     }
  1606.                    
  1607.                     if(!configurazioneCanaliNodo.getCanaliNodo().contains(canaleApiInvocata)) {
  1608.                         canaleNonAutorizzato = true;
  1609.                         String dettaglio=" (nodo '"+configurazioneCanaliNodo.getIdNodo()+"':"+configurazioneCanaliNodo.getCanaliNodo()+" api-invocata:"+canaleApiInvocata+")";
  1610.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, dettaglio);
  1611.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  1612.                         throw new Exception("L'API invocata richiede un canale differente da quelli associati al nodo; invocazione non autorizzata");
  1613.                     }
  1614.                     else {
  1615.                         msgDiag.logPersonalizzato("autorizzazioneCanale.effettuata");
  1616.                     }
  1617.                    
  1618.                 }
  1619.                 else {
  1620.                     // saranno segnalati altri errori dovuti al non riconoscimento della porta
  1621.                 }
  1622.                
  1623.             }
  1624.         } catch (Exception e) {
  1625.            
  1626.             String msgErrore = e.getMessage();
  1627.            
  1628.             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1629.             msgDiag.logPersonalizzato("autorizzazioneCanale.fallita");
  1630.            
  1631.             if(canaleNonAutorizzato) {
  1632.                 logError(logCore, e.getMessage(),e);
  1633.                 setSOAPFault_intestazione(IntegrationFunctionError.AUTHORIZATION_DENY,
  1634.                         ErroriCooperazione.AUTORIZZAZIONE_FALLITA.getErroreAutorizzazione(msgErrore, CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA));
  1635.             }
  1636.             else {
  1637.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,null,
  1638.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1639.                         "autorizzazioneCanale");
  1640.             }
  1641.             openspcoopstate.releaseResource();
  1642.             return;
  1643.         }
  1644.        
  1645.        
  1646.        
  1647.        
  1648.        
  1649.        
  1650.         Utilities.printFreeMemory("RicezioneBuste - Raccolta dati Gestione CORS ...");
  1651.         // NOTA: i dati CORS sono memorizzati solamente nella porta principale e non in quelle di eventuali azioni delegate.
  1652.         //       deve quindi essere recuperata prima di sostituire la pa con una più specifica
  1653.         CorsConfigurazione cors = null;
  1654.         HttpServletRequest httpServletRequest = null;
  1655.         boolean effettuareGestioneCORS = false;
  1656.         try {
  1657.             if(requestInfo!=null && requestInfo.getProtocolContext()!=null) {
  1658.                 httpServletRequest = requestInfo.getProtocolContext().getHttpServletRequest();  
  1659.             }
  1660.            
  1661.             if(httpServletRequest!=null && HttpRequestMethod.OPTIONS.name().equalsIgnoreCase(httpServletRequest.getMethod())) {
  1662.                
  1663.                 Object nomePortaObject = pddContext.getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  1664.                 String nomePortaS = null;
  1665.                 if(nomePortaObject instanceof String) {
  1666.                     nomePortaS = (String) nomePortaObject;
  1667.                 }
  1668.                 PortaApplicativa paDefault = null;
  1669.                 if(nomePortaS!=null) {
  1670.                     IDPortaApplicativa idPAdefault = new IDPortaApplicativa();
  1671.                     idPAdefault.setNome(nomePortaS);
  1672.                     paDefault = configurazionePdDReader.getPortaApplicativaSafeMethod(idPAdefault, requestInfo);
  1673.                 }
  1674.                 if(paDefault!=null) {
  1675.                     cors = configurazionePdDReader.getConfigurazioneCORS(paDefault);
  1676.                 }
  1677.                 else if(pa!=null) {
  1678.                     cors = configurazionePdDReader.getConfigurazioneCORS(pa);
  1679.                 }
  1680.                 else {
  1681.                     cors = configurazionePdDReader.getConfigurazioneCORS();
  1682.                 }
  1683.             }
  1684.             else {
  1685.                 cors = new CorsConfigurazione();
  1686.                 cors.setStato(StatoFunzionalita.DISABILITATO);
  1687.             }
  1688.         } catch (Exception e) {
  1689.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1690.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1691.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1692.                     "configurazionePdDReader.getConfigurazioneCORS(pa)");
  1693.             openspcoopstate.releaseResource();
  1694.             return;
  1695.         }
  1696.        
  1697.        
  1698.        
  1699.        
  1700.        
  1701.        
  1702.        
  1703.         /* ------------ Identificazione Azione  ------------- */    
  1704.        
  1705.         try{
  1706.             if(pa!=null){
  1707.                 if(requestInfo.getIdServizio()!=null && requestInfo.getIdServizio().getAzione()!=null){
  1708.                     // gia identificata
  1709.                     idServizio.setAzione(requestInfo.getIdServizio().getAzione());
  1710.                 }
  1711.                 else{
  1712.                     idServizio.setAzione(configurazionePdDReader.getAzione(pa, urlProtocolContext, requestInfo, requestMessage, null,
  1713.                             headerIntegrazioneRichiesta, this.msgContext.getIdModulo().endsWith(IntegrationManager.ID_MODULO), protocolFactory));
  1714.                 }
  1715.                 requestInfo.setIdServizio(idServizio);
  1716.             }
  1717.         }catch(Exception e){
  1718.            
  1719.             boolean throwFault = true;
  1720.             if(StatoFunzionalita.ABILITATO.equals(cors.getStato()) && this.msgContext.isGestioneRisposta()) {
  1721.                 throwFault = false;
  1722.             }
  1723.             if(throwFault) {
  1724.            
  1725.                 IntegrationFunctionError integrationFunctinError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1726.                 if(e instanceof IdentificazioneDinamicaException) {
  1727.                    
  1728.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.OPERAZIONE_NON_INDIVIDUATA, "true");
  1729.                                        
  1730.                     integrationFunctinError = IntegrationFunctionError.OPERATION_UNDEFINED;
  1731.                 }
  1732.                
  1733.                 setSOAPFault_processamento(integrationFunctinError,logCore,msgDiag,
  1734.                         ErroriIntegrazione.ERRORE_403_AZIONE_NON_IDENTIFICATA.getErroreIntegrazione(),e,
  1735.                         "identificazioneDinamicaAzionePortaApplicativa");
  1736.                 openspcoopstate.releaseResource();
  1737.                 return;
  1738.                
  1739.             }
  1740.             else {
  1741.                 effettuareGestioneCORS = true;
  1742.             }
  1743.            
  1744.         }
  1745.        
  1746.        
  1747.        
  1748.        
  1749.        

  1750.        
  1751.        
  1752.        
  1753.         Utilities.printFreeMemory("RicezioneBuste - Identificazione PA specifica per azione del servizio ...");
  1754.        
  1755.         msgDiag.mediumDebug("Lettura azione associato alla PA invocata...");
  1756.         if(idServizio!=null && idServizio.getAzione()!=null && pa!=null) {
  1757.             // verifico se esiste una porta applicativa piu' specifica
  1758.             IdentificazionePortaApplicativa identificazione = new IdentificazionePortaApplicativa(logCore, protocolFactory,
  1759.                     registroServiziReader, configurazionePdDReader, requestInfo,
  1760.                     pa);
  1761.             String action = idServizio.getAzione();
  1762.             if(identificazione.find(action)) {
  1763.                 IDPortaApplicativa idPA_action = identificazione.getIDPortaApplicativa(action);
  1764.                 if(idPA_action!=null) {
  1765.                    
  1766.                     requestMessage.addContextProperty(CostantiPdD.NOME_PORTA_INVOCATA, pa.getNome()); // prima di aggiornare la porta applicativa
  1767.                                        
  1768.                     pa = identificazione.getPortaApplicativa(action);
  1769.                     msgDiag.addKeyword(CostantiPdD.KEY_PORTA_APPLICATIVA, pa.getNome());
  1770.                     msgDiag.updatePorta(pa.getNome(), requestInfo);
  1771.                     if(requestMessage.getTransportRequestContext()!=null) {
  1772.                         requestMessage.getTransportRequestContext().setInterfaceName(pa.getNome());
  1773.                     }
  1774.                    
  1775.                     pddContext.removeObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE);
  1776.                     try {
  1777.                         Map<String, String> configProperties = configurazionePdDReader.getProprietaConfigurazione(pa);
  1778.                         if (configProperties != null && !configProperties.isEmpty()) {
  1779.                            pddContext.addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE, configProperties);
  1780.                         }
  1781.                     }catch(Exception e) {
  1782.                         logError(logCore, "Errore durante la lettura delle proprietà di configurazione della porta applicativa [" + pa.getNome() + "]: " + e.getMessage(), e);
  1783.                     }
  1784.                 }
  1785.             }else {
  1786.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.API_NON_INDIVIDUATA, "true");
  1787.                
  1788.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, identificazione.getErroreIntegrazione().getDescrizione(protocolFactory));
  1789.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");    
  1790.                
  1791.                 // passo volutamente null come msgDiag poichè ho generato prima il diagnostico
  1792.                 IntegrationFunctionError integrationFunctionError = null;
  1793.                 if(CodiceErroreIntegrazione.CODICE_401_PORTA_INESISTENTE.equals(identificazione.getErroreIntegrazione().getCodiceErrore())){
  1794.                     integrationFunctionError = IntegrationFunctionError.API_IN_UNKNOWN;
  1795.                 }else{
  1796.                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1797.                 }
  1798.                 setSOAPFault_processamento(integrationFunctionError,logCore,null,
  1799.                         identificazione.getErroreIntegrazione(),null,
  1800.                         "IdentificazionePASpecificaPerAzione");
  1801.                 openspcoopstate.releaseResource();
  1802.                 return;
  1803.             }
  1804.         }
  1805.        
  1806.        
  1807.        

  1808.        
  1809.        
  1810.        
  1811.        
  1812.         // ------------- Informazioni Integrazione -----------------------------
  1813.        
  1814.         msgDiag.mediumDebug("Aggiungo informazioni di integrazione dinamica nel contesto ...");
  1815.                
  1816.         try {
  1817.             if(pa!=null) {
  1818.                 configurazionePdDReader.setInformazioniIntegrazioneDinamiche(logCore, urlProtocolContext, pddContext, pa);
  1819.             }
  1820.         }
  1821.         catch (Exception e) {
  1822.             msgDiag.logErroreGenerico(e, "setInformazioniIntegrazioneDinamiche");
  1823.             setSOAPFault_processamento(IntegrationFunctionError.BAD_REQUEST,logCore,
  1824.                     null, //msgDiag,
  1825.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1826.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1827.                     "setInformazioniIntegrazioneDinamiche");
  1828.             openspcoopstate.releaseResource();
  1829.             return;
  1830.         }
  1831.        
  1832.        
  1833.        
  1834.        
  1835.        
  1836.        
  1837.        
  1838.        
  1839.        
  1840.        
  1841.         // ------------- Dump richiesta-----------------------------
  1842.            
  1843.         msgDiag.mediumDebug("Dump richiesta ...");
  1844.        
  1845.         DumpConfigurazione dumpConfig = null;
  1846.         try {
  1847.             if(pa!=null) {
  1848.                 dumpConfig = configurazionePdDReader.getDumpConfigurazione(pa);
  1849.             }
  1850.             else {
  1851.                 dumpConfig = configurazionePdDReader.getDumpConfigurazionePortaApplicativa();
  1852.             }
  1853.             internalObjects.put(CostantiPdD.DUMP_CONFIG, dumpConfig);
  1854.         }
  1855.         catch (Exception e) {
  1856.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  1857.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1858.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  1859.                     "readDumpConfigurazione");
  1860.             openspcoopstate.releaseResource();
  1861.             return;
  1862.         }
  1863.        
  1864.         Dump dumpApplicativo = new Dump(identitaPdD,
  1865.                 this.msgContext.getIdModulo(),  null,
  1866.                 null, idServizio,
  1867.                 this.msgContext.getTipoPorta(),msgDiag.getPorta(),inRequestContext.getPddContext(),
  1868.                 openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta(),
  1869.                 dumpConfig);
  1870.         dumpApplicativo.dumpRichiestaIngresso(requestMessage,inRequestContext.getConnettore().getUrlProtocolContext());
  1871.         internalObjects.put(CostantiPdD.DUMP_RICHIESTA_EFFETTUATO, true);
  1872.        
  1873.        
  1874.        
  1875.        
  1876.        
  1877.        
  1878.        
  1879.        
  1880.        
  1881.        
  1882.        
  1883.        
  1884.        


  1885.         /* ------------  
  1886.          * URL Mapping
  1887.          * (Identificazione dati sul soggetto fruitore e sulle funzionalità di protocollo ed identificativo di protocollo)
  1888.          * In questo punto l'idServizio contiene tutte le informazioni necessarie per accedere al registro se le funzionalità di protocollo sono statiche
  1889.          * Deve contenere anche l'azione, visto che quest'ultima influenza il profili di collaborazione
  1890.          * ------------- */
  1891.        
  1892.         Servizio infoServizio = null;
  1893.         IDSoggetto soggettoFruitore = null;
  1894.         String id = null;
  1895.         boolean generazioneListaTrasmissioni = false;
  1896.         InformazioniServizioURLMapping is = null;
  1897.         boolean identitaServizioValida = false;
  1898.         String nomeRegistroForSearch = null; // qualsiasi registro
  1899.         try{
  1900.             is = new InformazioniServizioURLMapping(requestMessage,protocolFactory,urlProtocolContext,
  1901.                     logCore, this.msgContext.getIdModuloAsIDService(),
  1902.                     propertiesReader.getCustomContexts());
  1903.             logDebug(logCore, "InformazioniServizioTramiteURLMapping: "+is.toString());    
  1904.            
  1905.        
  1906.             Credential identity = null;
  1907.                        
  1908.             // Read Identity
  1909.             if(is.existsIdentityBasedIdentificationMode()){
  1910.                 if(connectorInMessage!=null)
  1911.                     identity = connectorInMessage.getCredential();
  1912.             }
  1913.            
  1914.             // Refresh dati su mittente
  1915.             soggettoFruitore = new IDSoggetto();
  1916.             IDSoggetto headerIntegrazioneRichiestaSoggettoMittente = null;
  1917.             if(headerIntegrazioneRichiesta!=null && headerIntegrazioneRichiesta.getBusta()!=null){
  1918.                 headerIntegrazioneRichiestaSoggettoMittente = new IDSoggetto(headerIntegrazioneRichiesta.getBusta().getTipoMittente(),
  1919.                         headerIntegrazioneRichiesta.getBusta().getMittente());
  1920.             }
  1921.             is.refreshDati(soggettoFruitore, identity, headerIntegrazioneRichiestaSoggettoMittente);
  1922.            
  1923.             // Reimposto a null se il refresh non ha trovato dati.
  1924.             if(soggettoFruitore.getTipo()==null && soggettoFruitore.getNome()==null){
  1925.                 soggettoFruitore = null;
  1926.             }          
  1927.            
  1928.             // Aggiorno domini dei soggetti se completamente ricostruiti tramite url mapping differente da plugin based
  1929.             if(soggettoFruitore!=null && soggettoFruitore.getTipo()!=null && soggettoFruitore.getNome()!=null){
  1930.                 try {
  1931.                     soggettoFruitore.setCodicePorta(registroServiziReader.getDominio(soggettoFruitore, nomeRegistroForSearch, protocolFactory, requestInfo));
  1932.                 } catch (Exception e) {
  1933.                     //e.printStackTrace();
  1934.                 }
  1935.             }
  1936.             requestInfo.setFruitore(soggettoFruitore);
  1937.            
  1938.             // Check id
  1939.             boolean identitaSoggettoErogatoreValida = idServizio!=null &&
  1940.                     idServizio.getSoggettoErogatore()!=null &&
  1941.                     idServizio.getSoggettoErogatore().getTipo()!=null &&
  1942.                     idServizio.getSoggettoErogatore().getNome()!=null;
  1943.             identitaServizioValida = identitaSoggettoErogatoreValida &&
  1944.                     idServizio!=null && idServizio.getNome()!=null && idServizio.getTipo()!=null && idServizio.getVersione()!=null;
  1945.                        
  1946.             // ID Protocollo
  1947.             id = null;
  1948.             if(is.isStaticBasedIdentificationMode_IdProtocol()){
  1949.                 Imbustamento imbustamento = new Imbustamento(logCore, protocolFactory, openspcoopstate.getStatoRichiesta());
  1950.                 IDSoggetto idSoggetto = null;
  1951.                 if(identitaSoggettoErogatoreValida) {
  1952.                     idSoggetto = idServizio.getSoggettoErogatore();
  1953.                 }
  1954.                 else {
  1955.                     idSoggetto = propertiesReader.getIdentitaPortaDefault(protocolFactory.getProtocol(), requestInfo);
  1956.                 }
  1957.                 id =
  1958.                     imbustamento.buildID(idSoggetto,
  1959.                             (String) this.msgContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE),
  1960.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  1961.                             propertiesReader.getGestioneSerializableDBCheckInterval(),
  1962.                             RuoloMessaggio.RICHIESTA);
  1963.             }
  1964.            
  1965.             // Lista trasmissioni
  1966.             generazioneListaTrasmissioni = is.isGenerateListaTrasmissione();
  1967.            
  1968.             // InfoServizio (NOTA: lasciare per ultimo)
  1969.             if(is.isStaticBasedIdentificationMode_InfoProtocol()){
  1970.                 if(identitaServizioValida) {
  1971.                     infoServizio = registroServiziReader.getInfoServizio(soggettoFruitore, idServizio,nomeRegistroForSearch,true, true, requestInfo);
  1972.                 }
  1973.                 else {
  1974.                     infoServizio = new Servizio(); // se l'id servizio non e' valido poi viene segnalato dal motore della validazione
  1975.                 }
  1976.             }
  1977.             else{
  1978.                 infoServizio = new Servizio();
  1979.             }
  1980.         }
  1981.         catch(DriverRegistroServiziAzioneNotFound e){
  1982.            
  1983.             boolean throwFault = true;
  1984.             if(StatoFunzionalita.ABILITATO.equals(cors.getStato()) && this.msgContext.isGestioneRisposta()) {
  1985.                 throwFault = false;
  1986.                 if(TipoGestioneCORS.TRASPARENTE.equals(cors.getTipo())) {
  1987.                     // per poter continuare l'elaborazione ho bisogno dell'id servizio
  1988.                     try {
  1989.                         if(is.isStaticBasedIdentificationMode_InfoProtocol()){
  1990.                             if(identitaServizioValida) {
  1991.                                 infoServizio = registroServiziReader.getInfoServizio(soggettoFruitore, idServizio,nomeRegistroForSearch,true, false, requestInfo);
  1992.                             }
  1993.                         }
  1994.                     }catch(Exception eGetInfoServizio) {
  1995.                         throwFault = true;
  1996.                     }
  1997.                 }
  1998.             }
  1999.             if(throwFault) {
  2000.            
  2001.                 String azione = "";
  2002.                 if(idServizio.getAzione()!=null) {
  2003.                     azione = "(azione:"+ idServizio.getAzione()+ ") ";
  2004.                 }
  2005.                
  2006.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.OPERAZIONE_NON_INDIVIDUATA, "true");
  2007.                
  2008.                 setSOAPFault_processamento(IntegrationFunctionError.OPERATION_UNDEFINED,logCore,msgDiag,
  2009.                         ErroriIntegrazione.ERRORE_423_SERVIZIO_CON_AZIONE_SCORRETTA.
  2010.                         getErrore423_ServizioConAzioneScorretta(azione+ e.getMessage()),e,
  2011.                         "readProtocolInfo");
  2012.                 openspcoopstate.releaseResource();
  2013.                 return;
  2014.                
  2015.             }
  2016.             else {
  2017.                 effettuareGestioneCORS = true;
  2018.             }
  2019.            
  2020.         }
  2021.         catch(Exception e){
  2022.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  2023.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2024.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  2025.                     "readProtocolInfo");
  2026.             openspcoopstate.releaseResource();
  2027.             return;
  2028.         }
  2029.        
  2030.        
  2031.        
  2032.         // Gestione CORS
  2033.        
  2034.         if(!effettuareGestioneCORS) {
  2035.             if(pddContext.containsKey(CostantiPdD.CORS_PREFLIGHT_REQUEST_SOAP)) {
  2036.                 effettuareGestioneCORS = true;
  2037.             }
  2038.             else {
  2039.                 // devo verificare se si tratta di una azione matched poichè è stato inserito un tipo http method 'qualsiasi'
  2040.                 if(propertiesReader.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneBuste()) {
  2041.                     if(cors!=null &&
  2042.                             StatoFunzionalita.ABILITATO.equals(cors.getStato()) &&
  2043.                             TipoGestioneCORS.GATEWAY.equals(cors.getTipo()) &&
  2044.                             this.msgContext.isGestioneRisposta()) {
  2045.                         if(idServizio!=null && idServizio.getAzione()!=null) {
  2046.                             try {
  2047.                                 RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance();
  2048.                                 AccordoServizioParteSpecifica asps = registroServiziManager.getAccordoServizioParteSpecifica(idServizio, null, false, requestInfo);
  2049.                                 if(asps!=null) {
  2050.                                     AccordoServizioParteComune aspc = registroServiziManager.getAccordoServizioParteComune(IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune()), null, false, false, requestInfo);
  2051.                                     if(aspc!=null && org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(aspc.getServiceBinding())) {
  2052.                                         if(aspc.sizeResourceList()>0) {
  2053.                                             for (Resource resource : aspc.getResourceList()) {
  2054.                                                 if(idServizio.getAzione().equals(resource.getNome())) {
  2055.                                                     if(resource.getMethod()==null){
  2056.                                                         effettuareGestioneCORS = true;
  2057.                                                     }
  2058.                                                     break;
  2059.                                                 }
  2060.                                             }
  2061.                                         }
  2062.                                     }
  2063.                                 }
  2064.                             }catch(Throwable tIgnore) {
  2065.                                 // ignore
  2066.                             }
  2067.                         }
  2068.                     }
  2069.                 }
  2070.             }
  2071.         }
  2072.        
  2073.         if(effettuareGestioneCORS) {
  2074.            
  2075.             if(TipoGestioneCORS.GATEWAY.equals(cors.getTipo())) {
  2076.                
  2077.                 CORSFilter corsFilter = new CORSFilter(logCore, cors);
  2078.                 try {
  2079.                     CORSWrappedHttpServletResponse res = new CORSWrappedHttpServletResponse(true);
  2080.                     corsFilter.doCORS(httpServletRequest, res, CORSRequestType.PRE_FLIGHT, true);
  2081.                     if(this.msgContext.getResponseHeaders()==null) {
  2082.                         this.msgContext.setResponseHeaders(new HashMap<>());
  2083.                     }
  2084.                     this.msgContext.getResponseHeaders().putAll(res.getHeadersValues());
  2085.                     this.msgContext.setMessageResponse(res.buildMessage());
  2086.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY, "true");
  2087.                 }catch(Exception e) {
  2088.                     // un eccezione non dovrebbe succedere
  2089.                     setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  2090.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2091.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  2092.                             "gestioneCORS");
  2093.                     openspcoopstate.releaseResource();
  2094.                     return;
  2095.                 }
  2096.                
  2097.                 openspcoopstate.releaseResource();
  2098.                 return;
  2099.                    
  2100.             }
  2101.             else {
  2102.                
  2103.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_TRASPARENTE, "true");
  2104.                
  2105.             }
  2106.            
  2107.         }
  2108.    

  2109.        
  2110.        
  2111.        
  2112.        

  2113.        
  2114.        
  2115.        
  2116.         /* ------------  Busta con i dati identificati tramite PA e URLMapping ------------- */
  2117.        
  2118.         Busta bustaURLMapping = null;
  2119.         try{
  2120.             // Build Busta
  2121.             bustaURLMapping = new Busta(protocolFactory,infoServizio, soggettoFruitore,
  2122.                     idServizio!=null ? idServizio.getSoggettoErogatore() : null,
  2123.                     id, generazioneListaTrasmissioni);
  2124.             if(infoServizio!=null && infoServizio.getCollaborazione()) {
  2125.                 // in questo punto sar' true solo se infoServizio è stato letto dal registro E siamo in 'isStaticBasedIdentificationMode_InfoProtocol'
  2126.                 if(headerIntegrazioneRichiesta!=null && headerIntegrazioneRichiesta.getBusta()!=null
  2127.                         && headerIntegrazioneRichiesta.getBusta().getIdCollaborazione()!=null) {
  2128.                     bustaURLMapping.setCollaborazione(headerIntegrazioneRichiesta.getBusta().getIdCollaborazione());
  2129.                 }
  2130.             }
  2131.             if(infoServizio!=null && infoServizio.getIdRiferimentoRichiesta()) {
  2132.                 // in questo punto sar' true solo se infoServizio è stato letto dal registro E siamo in 'isStaticBasedIdentificationMode_InfoProtocol'
  2133.                 if(headerIntegrazioneRichiesta!=null && headerIntegrazioneRichiesta.getBusta()!=null
  2134.                         && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio()!=null) {
  2135.                     bustaURLMapping.setRiferimentoMessaggio(headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio());
  2136.                     this.msgContext.getProtocol().setRiferimentoAsincrono(headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio());
  2137.                 }
  2138.             }
  2139.             TipoOraRegistrazione tipoOraRegistrazione = propertiesReader.getTipoTempoBusta(null);
  2140.             bustaURLMapping.setTipoOraRegistrazione(tipoOraRegistrazione, traduttore.toString(tipoOraRegistrazione));
  2141.             if(bustaURLMapping.sizeListaTrasmissioni()>0){
  2142.                 for (Trasmissione trasmissione : bustaURLMapping.getListaTrasmissioni()) {
  2143.                     trasmissione.setTempo(tipoOraRegistrazione, traduttore.toString(tipoOraRegistrazione));
  2144.                 }
  2145.             }
  2146.             bustaURLMapping.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  2147.         }catch(Exception e){
  2148.             setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  2149.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2150.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  2151.                     "bustaURLMapping");
  2152.             openspcoopstate.releaseResource();
  2153.             return;
  2154.         }
  2155.        
  2156.        
  2157.        
  2158.        
  2159.        
  2160.        

  2161.        
  2162.        
  2163.        
  2164.        
  2165.        
  2166.        
  2167.        
  2168.        

  2169.        
  2170.                
  2171.         /* ------------  Processamento Busta Ricevuta ------------- */  
  2172.        
  2173.         RicezioneBusteGeneratoreBustaErrore ricezioneBusteGeneratoreBustaErrore = new RicezioneBusteGeneratoreBustaErrore(this.msgContext, this.generatoreErrore);
  2174.        
  2175.         // ValidazioneSintattica
  2176.         msgDiag.mediumDebug("Validazione busta ricevuta in corso...");
  2177.         ProprietaValidazione properties = new ProprietaValidazione();
  2178.         boolean readQualifiedAttribute = propertiesReader.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  2179.        
  2180.         Validatore validatore = new Validatore(requestMessage,pddContext,properties, openspcoopstate.getStatoRichiesta(),readQualifiedAttribute, protocolFactory);
  2181.        
  2182.        
  2183.         msgDiag.logPersonalizzato("validazioneSintattica");
  2184.         if(validatore.validazioneSintattica(bustaURLMapping, true) == false){

  2185.             // Provo a reperire il dominio se ho l'informazione sul destinatario valida
  2186.             Busta erroreIntestazione = null;
  2187.             boolean setDestinatarioDefault = true;
  2188.             if( validatore.getBustaErroreHeaderIntestazione()!=null){
  2189.                 erroreIntestazione = validatore.getBustaErroreHeaderIntestazione();
  2190.                
  2191.                 // Imposto Identificativo Richiesta
  2192.                 if(erroreIntestazione.getID()!=null){
  2193.                     msgDiag.setIdMessaggioRichiesta(erroreIntestazione.getID());
  2194.                     this.msgContext.getProtocol().setIdRichiesta(erroreIntestazione.getID());
  2195.                 }
  2196.                
  2197.                 IProtocolManager protocolManager = protocolFactory.createProtocolManager();
  2198.                 if( (protocolManager.getKeywordMittenteSconosciuto().equals(erroreIntestazione.getDestinatario())==false) &&
  2199.                         (protocolManager.getKeywordTipoMittenteSconosciuto().equals(erroreIntestazione.getTipoDestinatario())==false)
  2200.                 ){
  2201.                     try{
  2202.                         String dominioTmp = configurazionePdDReader.getIdentificativoPorta(new IDSoggetto(erroreIntestazione.getTipoDestinatario(),
  2203.                                 erroreIntestazione.getDestinatario()),protocolFactory, requestInfo);
  2204.                         if(dominioTmp!=null){
  2205.                             identitaPdD.setCodicePorta(dominioTmp);
  2206.                             identitaPdD.setTipo(erroreIntestazione.getTipoDestinatario());
  2207.                             identitaPdD.setNome(erroreIntestazione.getDestinatario());
  2208.                             setDestinatarioDefault = false;
  2209.                             parametriGenerazioneBustaErrore.setIdentitaPdD(identitaPdD);
  2210.                             parametriInvioBustaErrore.setIdentitaPdD(identitaPdD);
  2211.                         }
  2212.                     }catch(Exception e){
  2213.                         // ignore
  2214.                     }  
  2215.                 }
  2216.                
  2217.                 // Imposto i domini corretti, se sono stati impostati dei mittenti e tipi mittenti esistenti
  2218.                 if(erroreIntestazione.getMittente()!=null && erroreIntestazione.getTipoMittente()!=null){
  2219.                     try{
  2220.                         String dominio = registroServiziReader.getDominio(new IDSoggetto(erroreIntestazione.getTipoMittente(), erroreIntestazione.getMittente()), null, protocolFactory, requestInfo);
  2221.                         if(dominio!=null)
  2222.                             erroreIntestazione.setIdentificativoPortaMittente(dominio);
  2223.                     }catch(Exception e){
  2224.                         // ignore
  2225.                     }
  2226.                 }
  2227.                 if(erroreIntestazione.getDestinatario()!=null && erroreIntestazione.getTipoDestinatario()!=null){
  2228.                     try{
  2229.                         String dominio = registroServiziReader.getDominio(new IDSoggetto(erroreIntestazione.getTipoDestinatario(), erroreIntestazione.getDestinatario()), null, protocolFactory, requestInfo);
  2230.                         if(dominio!=null)
  2231.                             erroreIntestazione.setIdentificativoPortaDestinatario(dominio);
  2232.                     }catch(Exception e){
  2233.                         // ignore
  2234.                     }
  2235.                 }
  2236.             }


  2237.             // Provo a tracciare/dumpare la busta di richiesta arrivata malformata
  2238.             try{
  2239.                 if(erroreIntestazione!=null){
  2240.                     msgDiag.addKeywords(erroreIntestazione,true);
  2241.                     if(erroreIntestazione.getMittente()!=null || erroreIntestazione.getTipoMittente()!=null){
  2242.                         msgDiag.logPersonalizzato("ricezioneMessaggio");
  2243.                     }
  2244.                     else{
  2245.                         msgDiag.logPersonalizzato("ricezioneMessaggio.mittenteAnonimo");
  2246.                     }
  2247.                 }

  2248.                 if(this.msgContext.isTracciamentoAbilitato() && erroreIntestazione!=null){
  2249.                     msgDiag.mediumDebug("Tracciamento busta di richiesta...");

  2250.                     // Tracciamento richiesta
  2251.                     Tracciamento tracciamento = new Tracciamento(identitaPdD,
  2252.                             this.msgContext.getIdModulo(),
  2253.                             inRequestContext.getPddContext(),
  2254.                             this.msgContext.getTipoPorta(),msgDiag.getPorta(),
  2255.                             configurazionePdDReader);
  2256.                    
  2257.                     erroreIntestazione.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  2258.                     String dettaglioErrore = null;
  2259.                     if(erroreIntestazione!=null){
  2260.                         msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, erroreIntestazione.toStringListaEccezioni(protocolFactory));
  2261.                         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_BUSTA, "sintattica");
  2262.                         dettaglioErrore = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneNonRiuscita");
  2263.                     }
  2264.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  2265.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(dettaglioErrore);
  2266.                    
  2267.                     // Prima di tracciare elimino la lista di eccezioni
  2268.                     List<Eccezione> eccezioniRiscontrate = erroreIntestazione.cloneListaEccezioni();
  2269.                     while(erroreIntestazione.sizeListaEccezioni()>0){
  2270.                         erroreIntestazione.removeEccezione(0);
  2271.                     }
  2272.                    
  2273.                     // Tracciamento Busta Ricevuta
  2274.                     tracciamento.registraRichiesta(requestMessage,null,validatore.getHeaderProtocollo_senzaControlli(),erroreIntestazione,esitoTraccia,
  2275.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  2276.                             correlazioneApplicativa);
  2277.                    
  2278.                     // Riaggiungo eccezioni riscontrate per tracciare risposta
  2279.                     while(eccezioniRiscontrate.size()>0){
  2280.                         erroreIntestazione.addEccezione(eccezioniRiscontrate.remove(0));
  2281.                     }
  2282.                 }
  2283.             }catch(Exception e){
  2284.                 msgDiag.logErroreGenerico(e,"TracciamentoBustaMalformata");
  2285.                 logError(logCore, "Riscontrato errore durante il tracciamento della busta malformata ricevuta",e);
  2286.             }

  2287.             if(erroreIntestazione!=null){
  2288.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, erroreIntestazione.toStringListaEccezioni(protocolFactory));
  2289.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_BUSTA, "sintattica");
  2290.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneNonRiuscita");
  2291.                
  2292.                 if(this.msgContext.isGestioneRisposta()){

  2293.                     if(setDestinatarioDefault){
  2294.                         // Non sono riuscito a prendere il dominio del destinatario.
  2295.                         // Usero' come mittente della busta quella della porta di dominio di default
  2296.                         erroreIntestazione.setDestinatario(identitaPdD.getNome());
  2297.                         erroreIntestazione.setTipoDestinatario(identitaPdD.getTipo());
  2298.                         erroreIntestazione.setIdentificativoPortaDestinatario(identitaPdD.getCodicePorta());
  2299.                     }

  2300.                     Tracciamento tracciamento = new Tracciamento(identitaPdD,
  2301.                             this.msgContext.getIdModulo(),
  2302.                             inRequestContext.getPddContext(),
  2303.                             this.msgContext.getTipoPorta(),msgDiag.getPorta(),
  2304.                             configurazionePdDReader);
  2305.                    
  2306.                     parametriGenerazioneBustaErrore.setTracciamento(tracciamento);
  2307.                     parametriGenerazioneBustaErrore.setBusta(erroreIntestazione);
  2308.                     parametriGenerazioneBustaErrore.setError(erroreIntestazione.cloneListaEccezioni());
  2309.                    
  2310.                     IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.BAD_REQUEST;
  2311.                     if(validatore.getErrore_integrationFunctionError()!=null) {
  2312.                         integrationFunctionError = validatore.getErrore_integrationFunctionError();
  2313.                     }
  2314.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  2315.                    
  2316.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  2317.                    
  2318.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreValidazione
  2319.                    
  2320.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  2321.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  2322.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  2323.                 }
  2324.             }else{
  2325.                
  2326.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.BAD_REQUEST;
  2327.                 if(validatore.getErrore_integrationFunctionError()!=null) {
  2328.                     integrationFunctionError = validatore.getErrore_integrationFunctionError();
  2329.                 }
  2330.                 try{
  2331.                     msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, validatore.getErrore().getDescrizione(protocolFactory));
  2332.                 }catch(Exception e){
  2333.                     logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  2334.                 }
  2335.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_BUSTA, "sintattica");
  2336.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneNonRiuscita");
  2337.                 setSOAPFault_intestazione(integrationFunctionError, validatore.getErrore());
  2338.             }
  2339.             openspcoopstate.releaseResource();
  2340.             return;
  2341.         }
  2342.                
  2343.         idServizio = validatore.getIDServizio();
  2344.         Busta bustaRichiesta = validatore.getBusta();
  2345.         BustaRawContent<?> soapHeaderElement = validatore.getHeaderProtocollo();
  2346.        
  2347.         if(bustaRichiesta!=null) {
  2348.             try{
  2349.                 if(infoServizio.getCollaborazione() && bustaRichiesta.getCollaborazione()==null) {
  2350.                     InitialIdConversationType initial = protocolFactory.createProtocolConfiguration().isGenerateInitialIdConversation(TipoPdD.APPLICATIVA, FunzionalitaProtocollo.COLLABORAZIONE);
  2351.                     if(InitialIdConversationType.ID_TRANSAZIONE.equals(initial)) {
  2352.                         bustaRichiesta.setCollaborazione(idTransazione);
  2353.                     }
  2354.                     else if(InitialIdConversationType.ID_MESSAGGIO.equals(initial)) {
  2355.                         bustaRichiesta.setCollaborazione(bustaRichiesta.getID());
  2356.                     }
  2357.                 }
  2358.             }catch(Exception e){
  2359.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,logCore,msgDiag,
  2360.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2361.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  2362.                         "setCollaborazione");
  2363.                 openspcoopstate.releaseResource();
  2364.                 return;
  2365.             }
  2366.         }
  2367.        
  2368.        
  2369.        
  2370.        
  2371.        
  2372.        
  2373.        
  2374.         /* ------------  Controllo che i dati ottenuti dal validatore ed i dati ottenuti dalla RequestInfo coincidano ------------- */  
  2375.        
  2376.        
  2377.         // Controllo che i dati ottenuti dal validatore ed i dati ottenuti dalla RequestInfo coincidano
  2378.         if(requestInfo.getIdServizio()!=null){
  2379.             // Altrimenti i dati l'ho letti dalla busta e coincidono per forza
  2380.             String oggetto = null;
  2381.             String datoBusta = null;
  2382.             String datoPA = null;
  2383.             String locationPA = requestInfo.getProtocolContext().getInterfaceName();
  2384.             if(requestInfo.getIdServizio().getTipo().equals(idServizio.getTipo())==false){
  2385.                 oggetto = "Tipo del servizio";
  2386.                 datoBusta = idServizio.getTipo();
  2387.                 datoPA = requestInfo.getIdServizio().getTipo();
  2388.             }
  2389.             else if(requestInfo.getIdServizio().getNome().equals(idServizio.getNome())==false){
  2390.                 oggetto = "Servizio";
  2391.                 datoBusta = idServizio.getNome();
  2392.                 datoPA = requestInfo.getIdServizio().getNome();
  2393.             }
  2394.             else if(requestInfo.getIdServizio().getVersione().intValue() != idServizio.getVersione().intValue()){
  2395.                 oggetto = "VersioneServizio";
  2396.                 datoBusta = idServizio.getVersione().intValue()+"";
  2397.                 datoPA = requestInfo.getIdServizio().getVersione().intValue()+"";
  2398.             }
  2399.             else if(requestInfo.getIdServizio().getAzione()!=null && requestInfo.getIdServizio().getAzione().equals(idServizio.getAzione())==false){
  2400.                 oggetto = "Azione";
  2401.                 datoBusta = idServizio.getAzione();
  2402.                 datoPA = requestInfo.getIdServizio().getAzione();
  2403.             }
  2404.             else if(requestInfo.getIdServizio().getSoggettoErogatore().getTipo().equals(idServizio.getSoggettoErogatore().getTipo())==false){
  2405.                 oggetto = "Tipo del soggetto erogatore";
  2406.                 datoBusta = idServizio.getSoggettoErogatore().getTipo();
  2407.                 datoPA = requestInfo.getIdServizio().getSoggettoErogatore().getTipo();
  2408.             }
  2409.             else if(requestInfo.getIdServizio().getSoggettoErogatore().getNome().equals(idServizio.getSoggettoErogatore().getNome())==false){
  2410.                 oggetto = "Soggetto erogatore";
  2411.                 datoBusta = idServizio.getSoggettoErogatore().getNome();
  2412.                 datoPA = requestInfo.getIdServizio().getSoggettoErogatore().getNome();
  2413.             }
  2414.             if(oggetto!=null){
  2415.                 setSOAPFault_processamento(IntegrationFunctionError.BAD_REQUEST,logCore,msgDiag,
  2416.                         ErroriIntegrazione.ERRORE_455_DATI_BUSTA_DIFFERENTI_PA_INVOCATA.
  2417.                             getErrore455DatiBustaDifferentiDatiPAInvocata(oggetto, datoBusta, datoPA, locationPA),null,
  2418.                         "ConfrontoDatiBustaConDatiInvocazionePortaApplicativa");
  2419.                 openspcoopstate.releaseResource();
  2420.                 return;
  2421.             }
  2422.         }
  2423.        
  2424.        
  2425.        
  2426.        
  2427.        
  2428.        
  2429.        
  2430.         /* ----------- Ruolo Busta Ricevuta ------------ */
  2431.        
  2432.         RuoloBusta ruoloBustaRicevuta = null;
  2433.         if(!functionAsRouter){
  2434.            
  2435.             if( validatore.getBusta()!=null && (
  2436.                     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(validatore.getBusta().getProfiloDiCollaborazione())) ||
  2437.                     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(validatore.getBusta().getProfiloDiCollaborazione()))
  2438.                     )
  2439.                 ){
  2440.                 if(openspcoopstate.resourceReleased()) {
  2441.                     try{
  2442.                         // inizializzo
  2443.                         openspcoopstate.setUseConnection(true);
  2444.                         openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  2445.                         validatore.updateState(openspcoopstate.getStatoRichiesta());
  2446.                     }catch(Exception e){
  2447.                         msgDiag.logErroreGenerico(e,"validator.getRuoloBustaRicevuta(false) initResources");
  2448.                         setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,logCore,msgDiag,
  2449.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2450.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION),e,
  2451.                                 "initDatabaseResource");
  2452.                         openspcoopstate.releaseResource();
  2453.                         return;
  2454.                     }
  2455.                 }
  2456.             }
  2457.            
  2458.             msgDiag.mediumDebug("Lettura Ruolo Busta...");
  2459.             try{
  2460.                 ruoloBustaRicevuta = validatore.getRuoloBustaRicevuta(requestInfo.getProtocolServiceBinding(),false);
  2461.             }catch(Exception e){
  2462.                 msgDiag.logErroreGenerico(e,"validator.getRuoloBustaRicevuta(false)");
  2463.             }
  2464.            
  2465.             boolean checkConnection=false;
  2466.             if( validatore.getBusta()!=null) {
  2467.                 if(!org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(validatore.getBusta().getProfiloDiCollaborazione())){
  2468.                     if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta) == false){
  2469.                         checkConnection=true;
  2470.                     }
  2471.                 }
  2472.                 else {
  2473.                     if(validatore.getBusta().getSequenza()!=-1 && validatore.getBusta().getCollaborazione()!=null) {
  2474.                         checkConnection=true;
  2475.                     }
  2476.                 }
  2477.             }
  2478.             if(checkConnection && openspcoopstate.resourceReleased()) {
  2479.                 try{
  2480.                     // inizializzo
  2481.                     openspcoopstate.setUseConnection(true);
  2482.                     openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  2483.                     validatore.updateState(openspcoopstate.getStatoRichiesta());
  2484.                 }catch(Exception e){
  2485.                     msgDiag.logErroreGenerico(e,"validator.getRuoloBustaRicevuta(false) initResources after read role");
  2486.                     setSOAPFault_processamento(IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE,logCore,msgDiag,
  2487.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2488.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION),e,
  2489.                             "initDatabaseResource");
  2490.                     openspcoopstate.releaseResource();
  2491.                     return;
  2492.                 }  
  2493.             }
  2494.         }
  2495.        
  2496.        
  2497.        
  2498.        
  2499.        
  2500.        
  2501.        
  2502.        
  2503.         /* -------- Lettura Porta Applicativa
  2504.          * (Il vero controllo sull'esistenza della Porta Applicativa viene effettuato in Sbustamento, poiche' dipende dal profilo) ------------- */
  2505.         // per profili asincroni
  2506.         PortaDelegata pd = null;
  2507.         IDPortaDelegata idPD = null;
  2508.         IDPortaApplicativa idPA = null;
  2509.         String servizioApplicativoErogatoreAsincronoSimmetricoRisposta = null;
  2510.         boolean asincronoSimmetricoRisposta = false;
  2511.         if(!functionAsRouter && idServizio!=null){
  2512.             msgDiag.mediumDebug("Lettura porta applicativa/delegata...");
  2513.             try{

  2514.                 /* ----------- Identificazione profilo -------------- */
  2515.                 if(     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  2516.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) &&
  2517.                         !(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString())) )
  2518.                 {
  2519.                     msgDiag.highDebug("Lettura porta applicativa/delegata (Asincrono)...");
  2520.                     // La validazione non deve essere effettuata se abbiamo una ricevuta asincrona, 'modalita' asincrona'
  2521.                     ProfiloDiCollaborazione profiloCollaborazione = new ProfiloDiCollaborazione(openspcoopstate.getStatoRichiesta(),protocolFactory);

  2522.                     if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  

  2523.                         asincronoSimmetricoRisposta = true;
  2524.                        
  2525.                         //  Risposta Asincrona
  2526.                         RepositoryBuste repository = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true, protocolFactory);
  2527.                         Integrazione integrazione = null;
  2528.                         if(bustaRichiesta.getRiferimentoMessaggio()!=null){
  2529.                             integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  2530.                         }else{
  2531.                             // LineeGuida (Collaborazione)
  2532.                             integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getCollaborazione());
  2533.                         }
  2534.                         servizioApplicativoErogatoreAsincronoSimmetricoRisposta = integrazione.getServizioApplicativo();
  2535.                         idPD = new IDPortaDelegata();
  2536.                         idPD.setNome(integrazione.getNomePorta());
  2537.                         pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  2538.                         idPD = configurazionePdDReader.convertToIDPortaDelegata(pd); // per aggiungere informazioni sugli identificativi
  2539.                        
  2540.                     }
  2541.                     // Profilo Asincrono Asimmetrico
  2542.                     else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {

  2543.                         /// Risposta Asincrona
  2544.                         if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  2545.                             // ConversioneServizio.
  2546.                             IDServizio idServizioOriginale = null;
  2547.                             if(bustaRichiesta.getRiferimentoMessaggio()!=null){
  2548.                                 idServizioOriginale = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta(bustaRichiesta.getRiferimentoMessaggio());
  2549.                             }else{
  2550.                                 // LineeGuida (Collaborazione)
  2551.                                 idServizioOriginale = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta(bustaRichiesta.getCollaborazione());
  2552.                             }
  2553.                             this.overwriteIdSoggetto(idServizioOriginale, idServizio.getSoggettoErogatore());
  2554.                                
  2555.                             if(pa==null){
  2556.                                 pa = ricezioneBusteUtils.getPortaApplicativa(configurazionePdDReader, idServizioOriginale);
  2557.                             }
  2558.                            
  2559.                         }
  2560.                         // Ricevuta alla richiesta/risposta.
  2561.                         else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString()) ||
  2562.                                 RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){  
  2563.                             RepositoryBuste repository = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true, protocolFactory);
  2564.                             Integrazione integrazione = null;
  2565.                             if(bustaRichiesta.getRiferimentoMessaggio()!=null){
  2566.                                 integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  2567.                             }else{
  2568.                                 // LineeGuida (Collaborazione)
  2569.                                 integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getCollaborazione());
  2570.                             }
  2571.                             idPD = new IDPortaDelegata();
  2572.                             idPD.setNome(integrazione.getNomePorta());
  2573.                             pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  2574.                             idPD = configurazionePdDReader.convertToIDPortaDelegata(pd); // per aggiungere informazioni sugli identificativi
  2575.                         }
  2576.                        
  2577.                     }
  2578.                     // Chiudo eventuali prepared statement, che non voglio eseguire.
  2579.                     ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  2580.                 }else{
  2581.                     msgDiag.highDebug("Lettura porta applicativa/delegata (Normale)...");
  2582.                     if(pa==null){
  2583.                         pa = ricezioneBusteUtils.getPortaApplicativa(configurazionePdDReader, idServizio);
  2584.                     }
  2585.                 }
  2586.                
  2587.                 // Aggiungo identita servizio applicativi
  2588.                 if(pa!=null){
  2589.                     idPA = configurazionePdDReader.convertToIDPortaApplicativa(pa);
  2590.                     msgDiag.updatePorta(pa.getNome(), requestInfo);
  2591.                     for(int i=0; i<pa.sizeServizioApplicativoList();i++){
  2592.                         this.msgContext.getIntegrazione().addServizioApplicativoErogatore(pa.getServizioApplicativo(i).getNome());
  2593.                     }
  2594.                 }
  2595.                 else if(servizioApplicativoErogatoreAsincronoSimmetricoRisposta!=null){
  2596.                     // E' l'erogatore della risposta asincrona!
  2597.                     this.msgContext.getIntegrazione().addServizioApplicativoErogatore(servizioApplicativoErogatoreAsincronoSimmetricoRisposta);
  2598.                 }
  2599.                
  2600.                 // Aggiungo identificativo porta applicativa/delegata
  2601.                 if(idPA!=null){
  2602.                     this.msgContext.getIntegrazione().setIdPA(idPA);
  2603.                 }
  2604.                 else if(idPD!=null){
  2605.                     this.msgContext.getIntegrazione().setIdPD(idPD);
  2606.                 }
  2607.                
  2608.                 msgDiag.highDebug("Lettura porta applicativa/delegata terminato");
  2609.                
  2610.             }catch(Exception e){
  2611.                 if(  !(e instanceof DriverConfigurazioneNotFound) ) {
  2612.                     msgDiag.logErroreGenerico(e,"letturaPorta");
  2613.                    
  2614.                     setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  2615.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2616.                             get5XX_ErroreProcessamento("LetturaPorta",CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e);
  2617.                     return;

  2618.                 }
  2619.             }
  2620.         }

  2621.         msgDiag.highDebug("Lettura porta applicativa/delegata terminato impostazione context");

  2622.        
  2623.        
  2624.        
  2625.        
  2626.        
  2627.        
  2628.        
  2629.        
  2630.        
  2631.         /*
  2632.          * ---------------- Aggiornamento dati raccolti (PreAutenticazione) ---------------------
  2633.          */
  2634.        
  2635.         //       Aggiornamento Informazioni protocollo
  2636.         msgDiag.setIdMessaggioRichiesta(validatore.getBusta().getID());
  2637.         this.msgContext.setIdMessage(validatore.getBusta().getID());
  2638.         msgDiag.setServizio(idServizio);
  2639.         msgDiag.addKeywords(validatore.getBusta(), true);
  2640.         parametriGenerazioneBustaErrore.setMsgDiag(msgDiag);
  2641.         parametriInvioBustaErrore.setMsgDiag(msgDiag);

  2642.        
  2643.         Tracciamento tracciamento = new Tracciamento(identitaPdD,
  2644.                 this.msgContext.getIdModulo(),
  2645.                 inRequestContext.getPddContext(),
  2646.                 this.msgContext.getTipoPorta(),msgDiag.getPorta(),
  2647.                 configurazionePdDReader);
  2648.         parametriGenerazioneBustaErrore.setTracciamento(tracciamento);
  2649.        
  2650.        
  2651.        
  2652.        
  2653.        
  2654.        
  2655.        
  2656.         /* --------------- Gestione credenziali --------------- */
  2657.         if(RicezioneBuste.tipiGestoriCredenziali!=null){
  2658.             msgDiag.mediumDebug("Gestione personalizzata delle credenziali...");
  2659.            
  2660.             for (int i = 0; i < RicezioneBuste.tipiGestoriCredenziali.length; i++) {
  2661.                 try {
  2662.                    
  2663.                     IGestoreCredenziali gestore = null;
  2664.                     String classType = null;
  2665.                     try {
  2666.                         classType = className.getGestoreCredenziali(RicezioneBuste.tipiGestoriCredenziali[i]);
  2667.                         gestore = (IGestoreCredenziali)loader.newInstance(classType);
  2668.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  2669.                     } catch (Exception e) {
  2670.                         throw new Exception(
  2671.                                 "Riscontrato errore durante il caricamento della classe ["+ classType
  2672.                                 + "] da utilizzare per la gestione delle credenziali di tipo ["
  2673.                                 + RicezioneBuste.tipiGestoriCredenziali[i]+ "]: " + e.getMessage());
  2674.                     }
  2675.                    
  2676.                     if (gestore != null) {
  2677.                         Credenziali credenzialiRitornate = gestore.elaborazioneCredenziali(identitaPdD, inRequestContext.getConnettore(), requestMessage);
  2678.                         if(credenzialiRitornate==null){
  2679.                             throw new Exception("Credenziali non ritornate");
  2680.                         }
  2681.                         if(!inRequestContext.getConnettore().getCredenziali().equals(credenzialiRitornate)){
  2682.                             String nuoveCredenziali = credenzialiRitornate.toString();
  2683.                             if(nuoveCredenziali.length()>0) {
  2684.                                 nuoveCredenziali = nuoveCredenziali.substring(0,(nuoveCredenziali.length()-1));
  2685.                             }
  2686.                             msgDiag.addKeyword(CostantiPdD.KEY_NUOVE_CREDENZIALI,nuoveCredenziali);
  2687.                             String identita = gestore.getIdentitaGestoreCredenziali();
  2688.                             if(identita==null){
  2689.                                 identita = "Gestore delle credenziali di tipo "+RicezioneBuste.tipiGestoriCredenziali[i];
  2690.                             }
  2691.                             msgDiag.addKeyword(CostantiPdD.KEY_IDENTITA_GESTORE_CREDENZIALI, identita);
  2692.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.IDENTITA_GESTORE_CREDENZIALI, identita);
  2693.                             msgDiag.logPersonalizzato("gestoreCredenziali.nuoveCredenziali");
  2694.                             // update credenziali
  2695.                             inRequestContext.getConnettore().setCredenziali(credenzialiRitornate);
  2696.                             credenziali = credenzialiRitornate;
  2697.                             setCredenziali(credenziali, msgDiag);  
  2698.                         }
  2699.                     } else {
  2700.                         throw new Exception("non inizializzato");
  2701.                     }
  2702.                 }
  2703.                 catch (Exception e) {
  2704.                     logError(logCore, "Errore durante l'identificazione delle credenziali ["+ RicezioneBuste.tipiGestoriCredenziali[i]
  2705.                              + "]: "+ e.getMessage(),e);
  2706.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_GESTORE_CREDENZIALI,RicezioneBuste.tipiGestoriCredenziali[i]);
  2707.                     msgDiag.addKeywordErroreProcessamento(e);
  2708.                     msgDiag.logPersonalizzato("gestoreCredenziali.errore");
  2709.                     ErroreIntegrazione msgErroreIntegrazione = null;
  2710.                     String wwwAuthenticateErrorHeader = null;
  2711.                     if(e instanceof GestoreCredenzialiConfigurationException){
  2712.                         GestoreCredenzialiConfigurationException ge = (GestoreCredenzialiConfigurationException) e;
  2713.                         parametriGenerazioneBustaErrore.setIntegrationFunctionError(ge.getIntegrationFunctionError());
  2714.                         msgErroreIntegrazione =
  2715.                                 ErroriIntegrazione.ERRORE_431_GESTORE_CREDENZIALI_ERROR.
  2716.                                     getErrore431_ErroreGestoreCredenziali(RicezioneBuste.tipiGestoriCredenziali[i],e);
  2717.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTENTICAZIONE, "true");
  2718.                         wwwAuthenticateErrorHeader = ge.getWwwAuthenticateErrorHeader();
  2719.                     }else{
  2720.                         msgErroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2721.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_548_GESTORE_CREDENZIALI_NON_FUNZIONANTE);
  2722.                     }
  2723.                    
  2724.                     // Tracciamento richiesta: non ancora registrata
  2725.                     if(this.msgContext.isTracciamentoAbilitato()){
  2726.                         EsitoElaborazioneMessaggioTracciato esitoTraccia =
  2727.                                 EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(msgDiag.getMessaggio_replaceKeywords("gestoreCredenziali.errore"));
  2728.                         tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  2729.                                 Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  2730.                                 correlazioneApplicativa);
  2731.                     }
  2732.                     if(this.msgContext.isGestioneRisposta()){
  2733.                        
  2734.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  2735.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(msgErroreIntegrazione);
  2736.                         OpenSPCoop2Message errorMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  2737.                         if(wwwAuthenticateErrorHeader!=null) {
  2738.                             errorMsg.forceTransportHeader(HttpConstants.AUTHORIZATION_RESPONSE_WWW_AUTHENTICATE, wwwAuthenticateErrorHeader);
  2739.                         }
  2740.                        
  2741.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  2742.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorMsg);
  2743.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  2744.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  2745.                     }
  2746.                     openspcoopstate.releaseResource();
  2747.                     return;
  2748.                    
  2749.                 }
  2750.             }
  2751.         }
  2752.        
  2753.        
  2754.        
  2755.        
  2756.        
  2757.        
  2758.        
  2759.        
  2760.        
  2761.        
  2762.         /* ------------ GestioneToken ------------- */
  2763.        
  2764.         RicezioneBusteGestioneToken gestioneToken = new RicezioneBusteGestioneToken(msgDiag, logCore,
  2765.                 tracciamento, correlazioneApplicativa, soapHeaderElement, bustaRichiesta,
  2766.                 pa, idPA, pd, idPD,
  2767.                 requestMessage,
  2768.                 asincronoSimmetricoRisposta,
  2769.                 this.msgContext, this.generatoreErrore, inRequestContext,
  2770.                 configurazionePdDReader,
  2771.                 pddContext, idTransazione,
  2772.                 openspcoopstate, transaction, requestInfo,
  2773.                 protocolFactory,
  2774.                 identitaPdD,
  2775.                 parametriGenerazioneBustaErrore, parametriInvioBustaErrore);
  2776.        
  2777.         GestioneTokenAutenticazione gestioneTokenAutenticazione = null;
  2778.         String token = null;
  2779.        
  2780.         if(!gestioneToken.process()) {
  2781.             return;
  2782.         }
  2783.        
  2784.         gestioneTokenAutenticazione = gestioneToken.getGestioneTokenAutenticazione();
  2785.         token = gestioneToken.getToken();
  2786.        
  2787.        
  2788.        
  2789.        
  2790.        
  2791.        
  2792.        
  2793.        
  2794.        
  2795.        
  2796.         /* ------------ Riconciliazione ID Messaggio con quello ricevuto nel token oAuth ------------- */
  2797.        
  2798.         if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol())) {
  2799.             ModIValidazioneSemanticaProfiloSicurezza modIValidazioneSemanticaProfiloSicurezza = new ModIValidazioneSemanticaProfiloSicurezza(bustaRichiesta, true);
  2800.             if(modIValidazioneSemanticaProfiloSicurezza.isSicurezzaTokenOauth()) {
  2801.                 boolean useJtiAuthorization = ModIUtils.useJtiAuthorizationObject(requestMessage);
  2802.                 if(useJtiAuthorization) {
  2803.                     String jti = TokenUtilities.readJtiFromInformazioniToken(pddContext);
  2804.                     if(jti!=null && StringUtils.isNotEmpty(jti)) {
  2805.                         ModIUtils.replaceBustaIdWithJtiTokenId(modIValidazioneSemanticaProfiloSicurezza, jti);
  2806.                         msgDiag.updateKeywordIdMessaggioRichiesta(bustaRichiesta.getID());
  2807.                     }
  2808.                 }
  2809.             }
  2810.         }
  2811.        
  2812.        
  2813.        
  2814.        
  2815.        
  2816.        
  2817.        
  2818.         /*
  2819.          * ---------------- Mittente / Autenticazione ---------------------
  2820.          */
  2821.        
  2822.         RicezioneBusteGestioneAutenticazione gestioneAutenticazione = new RicezioneBusteGestioneAutenticazione(msgDiag, logCore,
  2823.                 tracciamento, correlazioneApplicativa, soapHeaderElement, bustaRichiesta,
  2824.                 pa, idPA, pd, idPD,
  2825.                 soggettoFruitore, credenziali, servizioApplicativoFruitore, gestioneTokenAutenticazione,
  2826.                 requestMessage,
  2827.                 asincronoSimmetricoRisposta, functionAsRouter,
  2828.                 this.msgContext, this.generatoreErrore, inRequestContext,
  2829.                 configurazionePdDReader, registroServiziReader,
  2830.                 pddContext, idTransazione, identitaPdD,
  2831.                 openspcoopstate, transaction, requestInfo,
  2832.                 protocolFactory, validatore,
  2833.                 parametriGenerazioneBustaErrore, parametriInvioBustaErrore);
  2834.        
  2835.         boolean soggettoFruitoreIdentificatoTramiteProtocollo = false;
  2836.         boolean soggettoAutenticato = false;
  2837.         boolean supportatoAutenticazioneSoggetti = false;
  2838.         IDServizioApplicativo idApplicativoToken = null;
  2839.        
  2840.         if(!gestioneAutenticazione.process()) {
  2841.             return;
  2842.         }
  2843.        
  2844.         soggettoFruitoreIdentificatoTramiteProtocollo = gestioneAutenticazione.isSoggettoFruitoreIdentificatoTramiteProtocollo();
  2845.         soggettoAutenticato = gestioneAutenticazione.isSoggettoAutenticato();
  2846.         supportatoAutenticazioneSoggetti = gestioneAutenticazione.isSupportatoAutenticazioneSoggetti();
  2847.         idApplicativoToken = gestioneAutenticazione.getIdApplicativoToken();
  2848.         soggettoFruitore = gestioneAutenticazione.getSoggettoFruitore();
  2849.         boolean autenticazioneOpzionale = gestioneAutenticazione.isAutenticazioneOpzionale();
  2850.         servizioApplicativoFruitore = gestioneAutenticazione.getServizioApplicativoFruitore();
  2851.        
  2852.        
  2853.        
  2854.        
  2855.        
  2856.        
  2857.    
  2858.        
  2859.        
  2860.         /*
  2861.          * ---------------- Aggiornamento dati raccolti (PostAutenticazione) ---------------------
  2862.          */
  2863.            
  2864.         Trasmissione trasmissioneSoggettoAutenticato = null;
  2865.         if(soggettoAutenticato || soggettoFruitoreIdentificatoTramiteProtocollo){
  2866.             validatore.getBusta().setTipoMittente(soggettoFruitore.getTipo());
  2867.             validatore.getBusta().setMittente(soggettoFruitore.getNome());
  2868.             if(validatore.getBusta().sizeListaTrasmissioni()>0){
  2869.                 for (int i = 0; i < validatore.getBusta().sizeListaTrasmissioni(); i++) {
  2870.                     Trasmissione trasmissione = validatore.getBusta().getTrasmissione(i);
  2871.                     if(trasmissione.getOrigine()==null && trasmissione.getTipoOrigine()==null && trasmissione.getIdentificativoPortaOrigine()==null){
  2872.                         trasmissioneSoggettoAutenticato = trasmissione;
  2873.                         trasmissione.setTipoOrigine(soggettoFruitore.getTipo());
  2874.                         trasmissione.setOrigine(soggettoFruitore.getNome());
  2875.                     }
  2876.                 }
  2877.             }
  2878.             validatore.setMittente(soggettoFruitore);
  2879.             bustaRichiesta = validatore.getBusta();
  2880.             msgDiag.addKeywords(validatore.getBusta(), true);
  2881.         }
  2882.                
  2883.         // VM ProtocolInfo (se siamo arrivati da un canale VM)
  2884.         if(pddContext!=null && bustaRichiesta!=null)
  2885.             DirectVMProtocolInfo.setInfoFromContext(pddContext, bustaRichiesta);
  2886.            
  2887.         // Se non impostati, imposto i domini
  2888.         org.openspcoop2.pdd.core.Utilities.refreshIdentificativiPorta(bustaRichiesta, requestInfo.getIdentitaPdD(), registroServiziReader, protocolFactory, requestInfo);
  2889.         if(soggettoFruitore != null){
  2890.             if(soggettoFruitore.getCodicePorta()==null){
  2891.                 soggettoFruitore.setCodicePorta(bustaRichiesta.getIdentificativoPortaMittente());
  2892.             }
  2893.             if(trasmissioneSoggettoAutenticato!=null && trasmissioneSoggettoAutenticato.getIdentificativoPortaOrigine()==null){
  2894.                 trasmissioneSoggettoAutenticato.setIdentificativoPortaOrigine(bustaRichiesta.getIdentificativoPortaMittente());
  2895.             }
  2896.             msgDiag.setFruitore(soggettoFruitore);
  2897.         }
  2898.         if(idServizio!=null && idServizio.getSoggettoErogatore()!=null){
  2899.             if(idServizio.getSoggettoErogatore().getCodicePorta()==null){
  2900.                 idServizio.getSoggettoErogatore().setCodicePorta(bustaRichiesta.getIdentificativoPortaDestinatario());
  2901.             }
  2902.         }
  2903.        
  2904.         if(servizioApplicativoFruitore!=null){
  2905.             // overriding busta
  2906.             if(bustaRichiesta!=null) {
  2907.                 bustaRichiesta.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  2908.             }
  2909.         }
  2910.         else{
  2911.             // altrimenti se è valorizzato internamente alla busta (poichè previsto dal protocollo (es. pdc)) e non capito tramite informazioni di integrazione uso quello
  2912.             if(bustaRichiesta!=null && bustaRichiesta.getServizioApplicativoFruitore()!=null){
  2913.                 servizioApplicativoFruitore = bustaRichiesta.getServizioApplicativoFruitore();
  2914.             }
  2915.         }
  2916.         String idMessageRequest = bustaRichiesta!=null ? bustaRichiesta.getID() : null;

  2917.         TipoPdD tipoPorta = TipoPdD.APPLICATIVA;
  2918.         if(functionAsRouter)
  2919.             tipoPorta = TipoPdD.ROUTER;
  2920.         this.msgContext.getProtocol().setDominio(identitaPdD);
  2921.         this.msgContext.setIdentitaPdD(identitaPdD);
  2922.         this.msgContext.setTipoPorta(tipoPorta);
  2923.         this.msgContext.getProtocol().setFruitore(soggettoFruitore);
  2924.         if(bustaRichiesta!=null){
  2925.             this.msgContext.getProtocol().setIndirizzoFruitore(bustaRichiesta.getIndirizzoMittente());
  2926.         }
  2927.         if(idServizio!=null && idServizio.getSoggettoErogatore()!=null){
  2928.             this.msgContext.getProtocol().setErogatore(idServizio.getSoggettoErogatore());
  2929.         }
  2930.         if(bustaRichiesta!=null){
  2931.             this.msgContext.getProtocol().setIndirizzoErogatore(bustaRichiesta.getIndirizzoDestinatario());
  2932.         }
  2933.         if(idServizio!=null) {
  2934.             this.msgContext.getProtocol().setTipoServizio(idServizio.getTipo());
  2935.             this.msgContext.getProtocol().setServizio(idServizio.getNome());
  2936.             this.msgContext.getProtocol().setVersioneServizio(idServizio.getVersione());
  2937.             this.msgContext.getProtocol().setAzione(idServizio.getAzione());
  2938.         }
  2939.         this.msgContext.getProtocol().setIdRichiesta(idMessageRequest);
  2940.         if(bustaRichiesta!=null) {
  2941.             this.msgContext.getProtocol().setProfiloCollaborazione(bustaRichiesta.getProfiloDiCollaborazione(),bustaRichiesta.getProfiloDiCollaborazioneValue());
  2942.             this.msgContext.getProtocol().setCollaborazione(bustaRichiesta.getCollaborazione());
  2943.         }




  2944.        
  2945.        
  2946.        
  2947.        
  2948.        
  2949.        

  2950.        
  2951.         /*
  2952.          * ---------------- Verifico che il servizio di RicezioneBuste sia abilitato ---------------------
  2953.          */
  2954.         boolean serviceIsEnabled = false;
  2955.         boolean portaEnabled = false;
  2956.         Exception serviceIsEnabledExceptionProcessamento = null;
  2957.         try{
  2958.             serviceIsEnabled = StatoServiziPdD.isEnabledPortaApplicativa(soggettoFruitore, idServizio);
  2959.             if(serviceIsEnabled){
  2960.                 // verifico la singola porta
  2961.                 if(pa!=null){
  2962.                     portaEnabled = configurazionePdDReader.isPortaAbilitata(pa);
  2963.                 }
  2964.                 else{
  2965.                     portaEnabled = configurazionePdDReader.isPortaAbilitata(pd);
  2966.                 }
  2967.             }
  2968.         }catch(Exception e){
  2969.             serviceIsEnabledExceptionProcessamento = e;
  2970.         }
  2971.         if (!serviceIsEnabled || !portaEnabled || serviceIsEnabledExceptionProcessamento!=null) {
  2972.             ErroreIntegrazione errore = null;
  2973.             String esito = null;
  2974.             IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.API_SUSPEND;
  2975.             if(serviceIsEnabledExceptionProcessamento!=null){
  2976.                 logError(logCore, "["+ RicezioneBuste.ID_MODULO+ "] Identificazione stato servizio di ricezione buste non riuscita: "+serviceIsEnabledExceptionProcessamento.getMessage(),serviceIsEnabledExceptionProcessamento);
  2977.                 msgDiag.logErroreGenerico("Identificazione stato servizio di ricezione buste non riuscita", "PA");
  2978.                 esito = "["+ RicezioneBuste.ID_MODULO+ "] Identificazione stato servizio di ricezione buste non riuscita";
  2979.                 errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  2980.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2981.             }else{
  2982.                
  2983.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_SOSPENSIONE, "true");
  2984.                
  2985.                 String msg = "Servizio di ricezione buste disabilitato";
  2986.                 if(serviceIsEnabled){
  2987.                     if(pa!=null){
  2988.                         msg = "Porta Applicativa ["+pa.getNome()+"] disabilitata";
  2989.                     }
  2990.                     else{
  2991.                         msg = "Porta Delegata ["+pd.getNome()+"] disabilitata";
  2992.                     }
  2993.                     errore = ErroriIntegrazione.ERRORE_446_PORTA_SOSPESA.getErroreIntegrazione();
  2994.                 }
  2995.                 else {
  2996.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2997.                             get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_551_PA_SERVICE_NOT_ACTIVE);
  2998.                 }
  2999.                 logError(logCore, "["+ RicezioneBuste.ID_MODULO+ "] "+msg);
  3000.                 msgDiag.logErroreGenerico(msg, "PA");
  3001.                 esito = "["+ RicezioneBuste.ID_MODULO+ "] "+msg;
  3002.             }
  3003.             // Tracciamento richiesta: non ancora registrata
  3004.             if(this.msgContext.isTracciamentoAbilitato()){
  3005.                 EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3006.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(esito);
  3007.                 tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3008.                         Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3009.                         correlazioneApplicativa);
  3010.             }
  3011.             if(this.msgContext.isGestioneRisposta()){

  3012.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);                          
  3013.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(errore);
  3014.                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);

  3015.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,serviceIsEnabledExceptionProcessamento);
  3016.                
  3017.                 if(IntegrationFunctionError.API_SUSPEND.equals(integrationFunctionError) &&
  3018.                         propertiesReader.isEnabledServiceUnavailableRetryAfterPASuspend() &&
  3019.                         propertiesReader.getServiceUnavailableRetryAfterSecondsPASuspend()!=null &&
  3020.                         propertiesReader.getServiceUnavailableRetryAfterSecondsPASuspend()>0) {
  3021.                     int seconds = propertiesReader.getServiceUnavailableRetryAfterSecondsPASuspend();
  3022.                     if(propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend()!=null &&
  3023.                             propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend()>0) {
  3024.                         seconds = seconds + ServicesUtils.getRandom().nextInt(propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPASuspend());
  3025.                     }
  3026.                     errorOpenSPCoopMsg.forceTransportHeader(HttpConstants.RETRY_AFTER, seconds+"");
  3027.                 }
  3028.                
  3029.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  3030.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3031.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3032.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3033.             }
  3034.             openspcoopstate.releaseResource();
  3035.             return;
  3036.         }
  3037.        
  3038.        
  3039.        
  3040.        
  3041.        
  3042.        
  3043.        
  3044.        
  3045.        
  3046.        
  3047.         /* ------------ Gestione Attribute Authority ------------- */
  3048.        
  3049.         msgDiag.mediumDebug("Gestione Attribute Authority...");
  3050.         List<AttributeAuthority> attributeAuthorities = null;
  3051.         if(pa!=null) {
  3052.             attributeAuthorities = pa.getAttributeAuthorityList();
  3053.         }
  3054.         else if(pd!=null) {
  3055.             attributeAuthorities = pd.getAttributeAuthorityList();
  3056.         }
  3057.         this.msgContext.getIntegrazione().setAttributeAuthoritiesFromObjectList(attributeAuthorities);
  3058.        
  3059.         if (attributeAuthorities == null || attributeAuthorities.isEmpty()) {

  3060.             if(!asincronoSimmetricoRisposta) {
  3061.                 msgDiag.logPersonalizzato("gestioneAADisabilitata");
  3062.             }
  3063.            
  3064.         } else {

  3065.             transaction.getTempiElaborazione().startAttributeAuthority();
  3066.            
  3067.             try {
  3068.                 msgDiag.logPersonalizzato("gestioneAAInCorso");
  3069.                
  3070.                 org.openspcoop2.pdd.core.token.attribute_authority.pa.DatiInvocazionePortaApplicativa datiInvocazione = new org.openspcoop2.pdd.core.token.attribute_authority.pa.DatiInvocazionePortaApplicativa();
  3071.                 datiInvocazione.setInfoConnettoreIngresso(inRequestContext.getConnettore());
  3072.                 datiInvocazione.setState(openspcoopstate.getStatoRichiesta());
  3073.                 datiInvocazione.setIdModulo(inRequestContext.getIdModulo());
  3074.                 datiInvocazione.setMessage(requestMessage);
  3075.                 datiInvocazione.setBusta(bustaRichiesta);
  3076.                 datiInvocazione.setRequestInfo(requestInfo);
  3077.                 datiInvocazione.setIdPA(idPA);
  3078.                 datiInvocazione.setPa(pa);  
  3079.                 datiInvocazione.setIdPD(idPD);
  3080.                 datiInvocazione.setPd(pd);      
  3081.                
  3082.                 GestioneAttributeAuthority gestioneAAEngine = new GestioneAttributeAuthority(logCore, idTransazione, pddContext, protocolFactory);
  3083.                 List<InformazioniAttributi> esitiValidiRecuperoAttributi = new ArrayList<InformazioniAttributi>();
  3084.                
  3085.                 for (AttributeAuthority aa : attributeAuthorities) {
  3086.                    
  3087.                     try {
  3088.                         msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTE_AUTHORITY_NAME, aa.getNome());
  3089.                         msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTE_AUTHORITY_ENDPOINT, "-");
  3090.                        
  3091.                         PolicyAttributeAuthority policyAttributeAuthority = configurazionePdDReader.getPolicyAttributeAuthority(false, aa.getNome(), requestInfo);
  3092.                         datiInvocazione.setPolicyAttributeAuthority(policyAttributeAuthority);
  3093.                
  3094.                         GestoreToken.validazioneConfigurazione(policyAttributeAuthority); // assicura che la configurazione sia corretta
  3095.                        
  3096.                         msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTE_AUTHORITY_ENDPOINT, policyAttributeAuthority.getEndpoint());
  3097.                        
  3098.                         msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve");
  3099.                        
  3100.                         EsitoRecuperoAttributi esitoRecuperoAttributi = gestioneAAEngine.readAttributes(datiInvocazione);
  3101.                         if(esitoRecuperoAttributi.isValido()) {
  3102.                            
  3103.                             StringBuilder attributiRecuperati = new StringBuilder();
  3104.                             if(esitoRecuperoAttributi.getInformazioniAttributi()!=null &&
  3105.                                     esitoRecuperoAttributi.getInformazioniAttributi().getAttributes()!=null &&
  3106.                                     !esitoRecuperoAttributi.getInformazioniAttributi().getAttributes().isEmpty()) {
  3107.                                 for (String attrName : esitoRecuperoAttributi.getInformazioniAttributi().getAttributesNames()) {
  3108.                                     if(attributiRecuperati.length()>0) {
  3109.                                         attributiRecuperati.append(",");
  3110.                                     }
  3111.                                     attributiRecuperati.append(attrName);
  3112.                                 }
  3113.                             }
  3114.                             msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTES, attributiRecuperati.toString());
  3115.                            
  3116.                             if(esitoRecuperoAttributi.isInCache()) {
  3117.                                 msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.completataSuccesso.inCache");
  3118.                             }
  3119.                             else {
  3120.                                 msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.completataSuccesso");
  3121.                             }
  3122.                            
  3123.                             esitiValidiRecuperoAttributi.add(esitoRecuperoAttributi.getInformazioniAttributi());
  3124.                         }
  3125.                         else {
  3126.                            
  3127.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, esitoRecuperoAttributi.getDetails());
  3128.                             msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.fallita");
  3129.        
  3130.                             String msgErrore = "processo di gestione dell'attribute authority ["+ aa.getNome() + "] fallito: " + esitoRecuperoAttributi.getDetails();
  3131.                             if(esitoRecuperoAttributi.getEccezioneProcessamento()!=null) {
  3132.                                 logError(logCore, msgErrore,esitoRecuperoAttributi.getEccezioneProcessamento());
  3133.                             }
  3134.                             else {
  3135.                                 logError(logCore, msgErrore);
  3136.                             }                          
  3137.                         }
  3138.                        
  3139.                     } catch (Throwable e) {
  3140.                        
  3141.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  3142.                         msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.fallita");
  3143.                         String msgErrore = "processo di gestione dell'attribute authority ["+ aa.getNome() + "] fallito: " + e.getMessage();
  3144.                         logError(logCore, msgErrore,e);
  3145.                        
  3146.                     }
  3147.                    
  3148.                 }
  3149.                
  3150.                 InformazioniAttributi informazioniAttributiNormalizzati = null;
  3151.                 if(esitiValidiRecuperoAttributi!=null && esitiValidiRecuperoAttributi.size()>0) {
  3152.                     informazioniAttributiNormalizzati = GestoreToken.normalizeInformazioniAttributi(esitiValidiRecuperoAttributi, attributeAuthorities);
  3153.                     informazioniAttributiNormalizzati.setValid(true);
  3154.                 }
  3155.                 if(informazioniAttributiNormalizzati!=null) {
  3156.                     pddContext.addObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_ATTRIBUTI_INFORMAZIONI_NORMALIZZATE, informazioniAttributiNormalizzati);
  3157.                    
  3158.                     InformazioniToken informazioniTokenNormalizzate = null;
  3159.                     if(pddContext.containsKey(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE)) {
  3160.                         informazioniTokenNormalizzate = (InformazioniToken) pddContext.getObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_TOKEN_INFORMAZIONI_NORMALIZZATE);
  3161.                     }
  3162.                    
  3163.                     if(informazioniTokenNormalizzate!=null) {
  3164.                         informazioniTokenNormalizzate.setAa(informazioniAttributiNormalizzati);
  3165.                     }
  3166.                     else {
  3167.                         transaction.setInformazioniAttributi(informazioniAttributiNormalizzati);
  3168.                     }
  3169.                 }
  3170.                
  3171.                 msgDiag.logPersonalizzato("gestioneAACompletata");

  3172.             } catch (Throwable e) {
  3173.                
  3174.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  3175.                 msgDiag.logPersonalizzato("gestioneAAFallita");
  3176.                 logError(logCore, "processo di gestione delle attribute authorities fallito: " + e.getMessage(),e);
  3177.                
  3178.             }
  3179.             finally {
  3180.                 transaction.getTempiElaborazione().endAttributeAuthority();
  3181.             }
  3182.            
  3183.         }
  3184.        
  3185.        
  3186.        
  3187.        
  3188.        
  3189.        
  3190.        
  3191.        
  3192.        
  3193.        
  3194.         /* -------- OpenSPCoop2Message Update ------------- */
  3195.         try {
  3196.             msgDiag.mediumDebug("Aggiornamento del messaggio");
  3197.             requestMessage = protocolFactory.createProtocolManager().updateOpenSPCoop2MessageRequest(requestMessage, bustaRichiesta,
  3198.                     protocolFactory.getCachedRegistryReader(registroServiziReader, requestInfo));
  3199.         } catch (Exception e) {
  3200.             // Emetto log, non ancora emesso
  3201.             boolean mittenteEsistente = validatore.getBusta()!=null &&
  3202.                     (validatore.getBusta().getMittente()!=null || validatore.getBusta().getTipoMittente()!=null);
  3203.             msgDiag.emitRicezioneMessaggioModuloBuste(msgDiag, pddContext, !mittenteEsistente);
  3204.            
  3205.             msgDiag.addKeywordErroreProcessamento(e,"Aggiornamento messaggio fallito");
  3206.             msgDiag.logErroreGenerico(e,"ProtocolManager.updateOpenSPCoop2Message");
  3207.             logError(logCore, "ProtocolManager.updateOpenSPCoop2Message error: "+e.getMessage(),e);
  3208.            
  3209.             // Tracciamento richiesta: non ancora registrata
  3210.             if(this.msgContext.isTracciamentoAbilitato()){
  3211.                 EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3212.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("ProtocolManager.updateOpenSPCoop2Message, non riuscito: "+e.getMessage());
  3213.                 tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3214.                         Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3215.                         correlazioneApplicativa);
  3216.             }
  3217.             if(this.msgContext.isGestioneRisposta()){

  3218.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3219.                 parametriGenerazioneBustaErrore.
  3220.                     setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3221.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO));
  3222.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3223.                
  3224.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3225.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3226.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3227.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3228.             }
  3229.             openspcoopstate.releaseResource();
  3230.             return;
  3231.         }
  3232.        
  3233.        
  3234.        
  3235.        
  3236.        
  3237.        
  3238.        

  3239.        
  3240.         // Imposto un context di Base (utilizzato anche  per la successiva spedizione della risposta)
  3241.         MessageSecurityContext messageSecurityContext = null;
  3242.         // Proprieta' FlowParameter MTOM / Security relative alla ricezione della busta
  3243.         FlowProperties flowPropertiesRequest = null;
  3244.         // Proprieta' FlowParameter MTOM / Security relative alla spedizione della risposta
  3245.         FlowProperties flowPropertiesResponse = null;

  3246.        
  3247.         // Modalita' gestione risposta (Sincrona/Fault/Ricevute...)
  3248.         // Per i profili diversi dal sincrono e' possibile impostare dove far ritornare l'errore
  3249.         boolean newConnectionForResponse = false;
  3250.         boolean utilizzoIndirizzoTelematico = false;        
  3251.         if(!functionAsRouter){

  3252.             // Calcolo newConnectionForResponse in caso di asincroni
  3253.             if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  3254.                     org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  3255.                 newConnectionForResponse = configurazionePdDReader.newConnectionForResponse();
  3256.                 utilizzoIndirizzoTelematico = configurazionePdDReader.isUtilizzoIndirizzoTelematico();
  3257.                 parametriInvioBustaErrore.setNewConnectionForResponse(newConnectionForResponse);
  3258.                 parametriInvioBustaErrore.setUtilizzoIndirizzoTelematico(utilizzoIndirizzoTelematico);
  3259.             }


  3260.             /* ------------
  3261.                Controllo effettuato in caso di ricezione di una risposta Asincrona Simmetrica, o richiesta-stato Asincrona Asimmetrica
  3262.                In questo caso, se e' ancora in corso la gestione della richiesta o della ricevuta alla richiesta,
  3263.                prima di procedere con la gestione della risposta/richiesta-stato, devono termiare le precedenti richieste/ricevute.
  3264.                ------------
  3265.              */
  3266.             if(validatore.isErroreProtocollo()==false && validatore.isBustaDiServizio()==false){
  3267.                 try{
  3268.                     long scadenzaControllo = DateManager.getTimeMillis() + propertiesReader.getTimeoutBustaRispostaAsincrona();
  3269.                     int checkIntervalControllo = propertiesReader.getCheckIntervalBustaRispostaAsincrona();
  3270.                     boolean attendiTerminazioneRichiesta =
  3271.                         this.gestioneRispostaAsincrona_checkPresenzaRichiesta(scadenzaControllo,checkIntervalControllo, bustaRichiesta,
  3272.                                 openspcoopstate, msgDiag, newConnectionForResponse, inRequestContext.getPddContext());
  3273.                     boolean attendiTerminazioneRicevutaRichiesta =
  3274.                         this.gestioneRispostaAsincrona_checkPresenzaRicevutaRichiesta(scadenzaControllo,checkIntervalControllo, bustaRichiesta,
  3275.                                 openspcoopstate, msgDiag, newConnectionForResponse, inRequestContext.getPddContext());

  3276.                     ErroreIntegrazione msgErroreIntegrazione = null;
  3277.                     String motivoErrore = null;
  3278.                     if(attendiTerminazioneRichiesta){
  3279.                         msgDiag.logPersonalizzato("attesaFineProcessamento.richiestaAsincrona.timeoutScaduto");
  3280.                         msgErroreIntegrazione = ErroriIntegrazione.ERRORE_538_RICHIESTA_ASINCRONA_ANCORA_IN_PROCESSAMENTO.getErroreIntegrazione();
  3281.                     }else if(attendiTerminazioneRicevutaRichiesta){
  3282.                         msgDiag.logPersonalizzato("attesaFineProcessamento.ricevutaRichiestaAsincrona.timeoutScaduto");
  3283.                         msgErroreIntegrazione = ErroriIntegrazione.ERRORE_539_RICEVUTA_RICHIESTA_ASINCRONA_ANCORA_IN_PROCESSAMENTO.getErroreIntegrazione();
  3284.                     }
  3285.                     if(attendiTerminazioneRichiesta || attendiTerminazioneRicevutaRichiesta){
  3286.                         // Tracciamento richiesta: non ancora registrata
  3287.                         if(this.msgContext.isTracciamentoAbilitato()){
  3288.                             EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3289.                                     EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(motivoErrore);
  3290.                             tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3291.                                     Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3292.                                     correlazioneApplicativa);
  3293.                         }
  3294.                         if(this.msgContext.isGestioneRisposta()){

  3295.                             parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3296.                             parametriGenerazioneBustaErrore.setErroreIntegrazione(msgErroreIntegrazione);

  3297.                             OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,null);
  3298.                            
  3299.                             // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  3300.                             parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3301.                             parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3302.                             ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3303.                         }
  3304.                         openspcoopstate.releaseResource();
  3305.                         return;
  3306.                     }

  3307.                 }catch(Exception e){

  3308.                     // Emetto log, non ancora emesso
  3309.                     boolean mittenteEsistente = validatore.getBusta()!=null &&
  3310.                             (validatore.getBusta().getMittente()!=null || validatore.getBusta().getTipoMittente()!=null);
  3311.                     msgDiag.emitRicezioneMessaggioModuloBuste(msgDiag, pddContext, !mittenteEsistente);
  3312.                    
  3313.                     msgDiag.logErroreGenerico(e,"checkPresenzaRichiestaRicevutaAsincronaAncoraInGestione");
  3314.                     logError(logCore, "Controllo presenza richieste/ricevuteRichieste ancora in gestione " +
  3315.                             "correlate alla risposta/richiesta-stato asincrona simmetrica/asimmetrica arrivata, non riuscito",e);
  3316.                     // Tracciamento richiesta: non ancora registrata
  3317.                     if(this.msgContext.isTracciamentoAbilitato()){
  3318.                         EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3319.                                 EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Controllo presenza richieste/ricevuteRichieste ancora in gestione " +
  3320.                                         "correlate alla risposta/richiesta-stato asincrona simmetrica/asimmetrica arrivata, non riuscito: "+e.getMessage());
  3321.                         tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3322.                                 Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3323.                                 correlazioneApplicativa);
  3324.                     }
  3325.                     if(this.msgContext.isGestioneRisposta()){

  3326.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3327.                         parametriGenerazioneBustaErrore.
  3328.                             setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3329.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  3330.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3331.                        
  3332.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3333.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3334.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3335.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3336.                     }
  3337.                     openspcoopstate.releaseResource();
  3338.                     return;
  3339.                 }
  3340.             }
  3341.            
  3342.             /* ----------- Scenario Cooperazione ------------ */
  3343.             if(ruoloBustaRicevuta!=null){
  3344.                 try{
  3345.                     String scenarioCooperazione = null;
  3346.                     if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione())) {
  3347.                         scenarioCooperazione = Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO;
  3348.                     }
  3349.                     else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  
  3350.                         scenarioCooperazione = Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO;
  3351.                     }
  3352.                     else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  
  3353.                         if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString())){
  3354.                             scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO;
  3355.                         }
  3356.                         else if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  3357.                             scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA;
  3358.                         }
  3359.                         else{
  3360.                             // sono ricevute asincrone
  3361.                         }
  3362.                     }
  3363.                     else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {
  3364.                         if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString())){
  3365.                             scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO;
  3366.                         }
  3367.                         else if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  3368.                             scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING;
  3369.                         }
  3370.                         else{
  3371.                             // sono ricevute asincrone
  3372.                         }
  3373.                     }
  3374.                     this.msgContext.getProtocol().setScenarioCooperazione(scenarioCooperazione);
  3375.                 }catch(Exception e){
  3376.                     msgDiag.logErroreGenerico(e,"setScenarioCooperazione");
  3377.                 }
  3378.             }

  3379.         }



  3380.        
  3381.        
  3382.        
  3383.        
  3384.        
  3385.        
  3386.        
  3387.        
  3388.         /* -------------------------- Implementazione PdD Soggetti busta -------------------------------*/
  3389.         String implementazionePdDMittente = null;
  3390.         String implementazionePdDDestinatario = null;
  3391.         String idPdDMittente = null;
  3392.         String idPdDDestinatario = null;
  3393.         msgDiag.mediumDebug("Ricerca implementazione della porta di dominio dei soggetti...");
  3394.         ProprietaManifestAttachments proprietaManifestAttachments = null;
  3395.         boolean validazioneIDBustaCompleta = true;
  3396.         try{
  3397.             if(soggettoFruitore!=null){
  3398.                 implementazionePdDMittente = registroServiziReader.getImplementazionePdD(soggettoFruitore, null, requestInfo);
  3399.             }
  3400.             if(idServizio!=null && idServizio.getSoggettoErogatore()!=null){
  3401.                 implementazionePdDDestinatario = registroServiziReader.getImplementazionePdD(idServizio.getSoggettoErogatore(), null, requestInfo);
  3402.             }
  3403.             if(soggettoFruitore!=null){
  3404.                 idPdDMittente = registroServiziReader.getIdPortaDominio(soggettoFruitore, null, requestInfo);
  3405.             }
  3406.             if(idServizio!=null && idServizio.getSoggettoErogatore()!=null){
  3407.                 idPdDDestinatario = registroServiziReader.getIdPortaDominio(idServizio.getSoggettoErogatore(), null, requestInfo);
  3408.             }
  3409.             parametriGenerazioneBustaErrore.setImplementazionePdDMittente(implementazionePdDMittente);
  3410.             parametriGenerazioneBustaErrore.setImplementazionePdDDestinatario(implementazionePdDDestinatario);
  3411.             parametriInvioBustaErrore.setImplementazionePdDMittente(implementazionePdDMittente);
  3412.             parametriInvioBustaErrore.setImplementazionePdDDestinatario(implementazionePdDDestinatario);
  3413.            
  3414.             properties.setValidazioneConSchema(configurazionePdDReader.isLivelloValidazioneRigido(implementazionePdDMittente));
  3415.             properties.setValidazioneProfiloCollaborazione(configurazionePdDReader.isValidazioneProfiloCollaborazione(implementazionePdDMittente));
  3416.             if(openspcoopstate!=null) {
  3417.                 properties.setRuntimeState(openspcoopstate.getStatoRichiesta());
  3418.                 if(propertiesReader.isTransazioniUsePddRuntimeDatasource()) {
  3419.                     properties.setTracceState(openspcoopstate.getStatoRichiesta());
  3420.                 }
  3421.             }
  3422.             validatore.setProprietaValidazione(properties); // update
  3423.            
  3424.             MessageSecurityContextParameters contextParameters = new MessageSecurityContextParameters();
  3425.             contextParameters.setUseActorDefaultIfNotDefined(propertiesReader.isGenerazioneActorDefault(implementazionePdDMittente));
  3426.             contextParameters.setActorDefault(propertiesReader.getActorDefault(implementazionePdDMittente));
  3427.             contextParameters.setLog(logCore);
  3428.             contextParameters.setFunctionAsClient(SecurityConstants.SECURITY_SERVER);
  3429.             contextParameters.setPrefixWsuId(propertiesReader.getPrefixWsuId());
  3430.             contextParameters.setRemoveAllWsuIdRef(propertiesReader.isRemoveAllWsuIdRef());
  3431.             contextParameters.setIdFruitore(soggettoFruitore);
  3432.             contextParameters.setPddFruitore(idPdDMittente);
  3433.             contextParameters.setIdServizio(idServizio);
  3434.             contextParameters.setPddErogatore(idPdDDestinatario);
  3435.             messageSecurityContext = new MessageSecurityFactory().getMessageSecurityContext(contextParameters);
  3436.             parametriGenerazioneBustaErrore.setMessageSecurityContext(messageSecurityContext);
  3437.            
  3438.             proprietaManifestAttachments = propertiesReader.getProprietaManifestAttachments(implementazionePdDMittente);
  3439.             readQualifiedAttribute = propertiesReader.isReadQualifiedAttribute(implementazionePdDMittente);
  3440.             validazioneIDBustaCompleta = propertiesReader.isValidazioneIDBustaCompleta(implementazionePdDMittente);
  3441.            
  3442.         }catch(Exception e){
  3443.             msgDiag.logErroreGenerico(e,"ricercaImplementazionePdDSoggettiBusta");
  3444.             // Tracciamento richiesta: non ancora registrata
  3445.             if(this.msgContext.isTracciamentoAbilitato()){
  3446.                 EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3447.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Errore durante la ricerca dell'implementazione della porta di dominio dei soggetti: "+e.getMessage());
  3448.                 tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3449.                         Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3450.                         correlazioneApplicativa);
  3451.             }
  3452.             if(this.msgContext.isGestioneRisposta()){
  3453.                
  3454.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3455.                 parametriGenerazioneBustaErrore.
  3456.                 setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3457.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  3458.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3459.                
  3460.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  3461.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3462.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3463.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  3464.             }
  3465.             openspcoopstate.releaseResource();
  3466.             return;
  3467.         }
  3468.         if(soggettoFruitore!=null){
  3469.             msgDiag.mediumDebug("ImplementazionePdD soggetto fruitore ("+soggettoFruitore.toString()+"): ["+implementazionePdDMittente+"]");
  3470.         }
  3471.         if(idServizio!=null && idServizio.getSoggettoErogatore()!=null){
  3472.             msgDiag.mediumDebug("ImplementazionePdD soggetto erogatore ("+idServizio.getSoggettoErogatore().toString()+"): ["+implementazionePdDDestinatario+"]");
  3473.         }
  3474.        
  3475.        
  3476.        
  3477.        
  3478.        
  3479.        
  3480.        




  3481.        
  3482.         /* -------- Manifest attachments ------------- */
  3483.         // per profili asincroni
  3484.         if(!functionAsRouter){
  3485.             msgDiag.mediumDebug("Lettura manifest attachments impostato in porta applicativa/delegata...");
  3486.             try{

  3487.                 // Validazione manifest attachments
  3488.                 msgDiag.highDebug("Lettura porta applicativa/delegata (Set)...");
  3489.                 if(pa!=null){
  3490.                     properties.setValidazioneManifestAttachments(
  3491.                             configurazionePdDReader.isValidazioneManifestAttachments(implementazionePdDMittente) &&
  3492.                             configurazionePdDReader.isGestioneManifestAttachments(pa,protocolFactory));
  3493.                 }
  3494.                 else if(pd!=null){
  3495.                     properties.setValidazioneManifestAttachments(
  3496.                             configurazionePdDReader.isValidazioneManifestAttachments(implementazionePdDDestinatario) &&
  3497.                             configurazionePdDReader.isGestioneManifestAttachments(pd,protocolFactory));
  3498.                 }
  3499.                 else{
  3500.                     properties.setValidazioneManifestAttachments(
  3501.                             configurazionePdDReader.isValidazioneManifestAttachments(implementazionePdDMittente));
  3502.                 }
  3503.                
  3504.                 msgDiag.highDebug("Lettura porta applicativa/delegata terminato");
  3505.                
  3506.             }catch(Exception e){
  3507.                 if(  !(e instanceof DriverConfigurazioneNotFound) ) {
  3508.                     msgDiag.logErroreGenerico(e,"letturaPortaManifestAttachments");
  3509.                    
  3510.                     // Tracciamento richiesta: non ancora registrata
  3511.                     if(this.msgContext.isTracciamentoAbilitato()){
  3512.                         EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3513.                                 EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Errore durante la lettura della porta applicativa/delegata per la gestione ManifestAttachments: "+e.getMessage());
  3514.                         tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3515.                                 Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3516.                                 correlazioneApplicativa);
  3517.                     }
  3518.                     if(this.msgContext.isGestioneRisposta()){
  3519.                        
  3520.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3521.                         parametriGenerazioneBustaErrore.
  3522.                         setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3523.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  3524.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3525.                        
  3526.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3527.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3528.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3529.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3530.                     }
  3531.                     openspcoopstate.releaseResource();
  3532.                     return;
  3533.                 }
  3534.             }
  3535.             msgDiag.highDebug("Lettura manifest attachments impostato in porta applicativa/delegata terminato");
  3536.         }

  3537.        






  3538.        
  3539.        
  3540.        
  3541.         // Configurazione Richiesta Applicativa
  3542.         String idModuloInAttesa = null;
  3543.         if(this.msgContext.isGestioneRisposta())
  3544.             idModuloInAttesa = this.msgContext.getIdModulo();
  3545.         RichiestaApplicativa richiestaApplicativa = null;
  3546.         if(idPA!=null) {
  3547.             richiestaApplicativa = new RichiestaApplicativa(soggettoFruitore,
  3548.                     idModuloInAttesa,identitaPdD,idPA);
  3549.             if(idServizio!=null && idServizio.getAzione()!=null &&
  3550.                     idPA!=null && idPA.getIdentificativiErogazione()!=null && idPA.getIdentificativiErogazione().getIdServizio()!=null &&
  3551.                     idPA.getIdentificativiErogazione().getIdServizio().getAzione()==null) {
  3552.                 idPA.getIdentificativiErogazione().getIdServizio().setAzione(idServizio.getAzione());
  3553.             }
  3554.         }
  3555.         else {
  3556.             // Scenario Asincrono Simmetrico - Risposta
  3557.             richiestaApplicativa = new RichiestaApplicativa(soggettoFruitore,
  3558.                     idModuloInAttesa,identitaPdD,idServizio);
  3559.         }
  3560.         richiestaApplicativa.setFiltroProprietaPorteApplicative(this.msgContext.getProprietaFiltroPortaApplicativa());
  3561.         richiestaApplicativa.setIntegrazione(this.msgContext.getIntegrazione());
  3562.         richiestaApplicativa.setProtocol(this.msgContext.getProtocol());
  3563.        
  3564.        
  3565.        


  3566.        
  3567.        
  3568.        
  3569.        
  3570.        
  3571.         // ------------- Controllo funzionalita di protocollo richieste siano compatibili con il protocollo -----------------------------
  3572.         try{
  3573.             // NOTA: Usare getIntegrationServiceBinding poichè le funzionalità si riferiscono al tipo di integrazione scelta
  3574.            
  3575.             IProtocolConfiguration protocolConfiguration = protocolFactory.createProtocolConfiguration();
  3576.             if(bustaRichiesta!=null && bustaRichiesta.getProfiloDiCollaborazione()!=null &&
  3577.                     !org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.UNKNOWN.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  3578.                 if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),bustaRichiesta.getProfiloDiCollaborazione())==false){
  3579.                     throw new Exception("Profilo di Collaborazione ["+bustaRichiesta.getProfiloDiCollaborazione().getEngineValue()+"]");
  3580.                 }
  3581.             }
  3582.             // NOTA:  FiltroDuplicati, consegnaAffidabile, idCollaborazione, consegnaInOrdine verificato in sbustamento.
  3583.             if(bustaRichiesta!=null && bustaRichiesta.getScadenza()!=null){
  3584.                 if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.SCADENZA)==false){
  3585.                     throw new Exception(FunzionalitaProtocollo.SCADENZA.getEngineValue());
  3586.                 }
  3587.             }
  3588.            
  3589.             if(configurazionePdDReader.isGestioneManifestAttachments(pa,protocolFactory)){
  3590.                 if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.MANIFEST_ATTACHMENTS)==false){
  3591.                     throw new Exception(FunzionalitaProtocollo.MANIFEST_ATTACHMENTS.getEngineValue());
  3592.                 }
  3593.             }          
  3594.         }catch(Exception e){    
  3595.             msgDiag.addKeywordErroreProcessamento(e);
  3596.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"protocolli.funzionalita.unsupported");
  3597.             // Tracciamento richiesta: non ancora registrata
  3598.             if(this.msgContext.isTracciamentoAbilitato()){
  3599.                 EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3600.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(msgDiag.getMessaggio_replaceKeywords("protocolli.funzionalita.unsupported"));
  3601.                 tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3602.                         Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3603.                         correlazioneApplicativa);
  3604.             }
  3605.             if(this.msgContext.isGestioneRisposta()){
  3606.                
  3607.                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL);
  3608.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3609.                 parametriGenerazioneBustaErrore.
  3610.                 setErroreIntegrazione(ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.
  3611.                         getErrore439_FunzionalitaNotSupportedByProtocol(e.getMessage(), protocolFactory));
  3612.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3613.                
  3614.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3615.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3616.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3617.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3618.             }
  3619.             openspcoopstate.releaseResource();
  3620.             return;
  3621.         }
  3622.        
  3623.        


  3624.    
  3625.        




  3626.         /* ------------- Modalita' di gestione ---------------------------- */
  3627.         //Versione OneWay
  3628.         boolean oneWayStateless = false;
  3629.         boolean oneWayVersione11 = false;
  3630.         // Versione Sincrono
  3631.         boolean sincronoStateless = false;
  3632.         // Asincrono stateless
  3633.         boolean asincronoStateless = false;

  3634.         // Gestione stateless
  3635.         boolean portaStateless = false; // vero se almeno uno dei 3 precedenti e' vero

  3636.         // Routing stateless
  3637.         boolean routingStateless = false;

  3638.         try {
  3639.            
  3640.             if(functionAsRouter == false){
  3641.                
  3642.                 if(propertiesReader.isServerJ2EE()==false){
  3643.                     // Stateless obbligatorio in server di tipo web (non j2ee)
  3644.                     oneWayStateless = true;
  3645.                     sincronoStateless = true;
  3646.                     asincronoStateless = true;
  3647.                 }
  3648.                 else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  3649.                     if(soggettoVirtuale==false) {
  3650.                         oneWayStateless = configurazionePdDReader.isModalitaStateless(pa,bustaRichiesta.getProfiloDiCollaborazione());
  3651.                     }
  3652.                 }
  3653.                 else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())){  
  3654.                     sincronoStateless = configurazionePdDReader.isModalitaStateless(pa,bustaRichiesta.getProfiloDiCollaborazione());
  3655.                 }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  3656.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  3657.                     // Le ricevute arrivano solo con connection-new (possibile solo con stateful)
  3658.                     if( (RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())==false) &&
  3659.                             (RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())==false)){
  3660.                         if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  3661.                                 pd!=null){
  3662.                             // Risposta
  3663.                             asincronoStateless = configurazionePdDReader.isModalitaStateless(pd, bustaRichiesta.getProfiloDiCollaborazione());
  3664.                         }else{
  3665.                             asincronoStateless = configurazionePdDReader.isModalitaStateless(pa, bustaRichiesta.getProfiloDiCollaborazione());
  3666.                         }
  3667.                     }
  3668.                 }

  3669.                 oneWayVersione11 = propertiesReader.isGestioneOnewayStateful_1_1() &&  
  3670.                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione())&& !oneWayStateless ;

  3671.                 if ( oneWayStateless || sincronoStateless || asincronoStateless || oneWayVersione11 ) {
  3672.                     portaStateless = true;      
  3673.                     if(oneWayVersione11==false){
  3674.                         this.msgContext.getIntegrazione().setGestioneStateless(true);
  3675.                     }else{
  3676.                         this.msgContext.getIntegrazione().setGestioneStateless(false);
  3677.                     }
  3678.                 }else{
  3679.                     this.msgContext.getIntegrazione().setGestioneStateless(false);
  3680.                 }
  3681.                
  3682.                 if(!portaStateless || oneWayVersione11) {
  3683.                     if(!openspcoopstate.isUseConnection() &&
  3684.                             (openspcoopstate instanceof OpenSPCoopStateful || oneWayVersione11)) {
  3685.                         if(openspcoopstate.resourceReleased()) {
  3686.                             // inizializzo
  3687.                             openspcoopstate.setUseConnection(true);
  3688.                             openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  3689.                         }
  3690.                     }
  3691.                 }
  3692.                
  3693.             }else{
  3694.                 routingStateless = CostantiConfigurazione.ABILITATO.equals(propertiesReader.getStatelessRouting());
  3695.                 this.msgContext.getIntegrazione().setGestioneStateless(routingStateless);
  3696.                
  3697.                 if(!routingStateless) {
  3698.                     if(!openspcoopstate.isUseConnection() &&
  3699.                             (openspcoopstate instanceof OpenSPCoopStateful)) {
  3700.                         if(openspcoopstate.resourceReleased()) {
  3701.                             // inizializzo
  3702.                             openspcoopstate.setUseConnection(true);
  3703.                             openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  3704.                         }
  3705.                     }
  3706.                 }
  3707.             }
  3708.            
  3709.             parametriInvioBustaErrore.setOnewayVersione11(oneWayVersione11);
  3710.            
  3711.         } catch (Exception e) {
  3712.             msgDiag.logErroreGenerico(e,"AnalisiModalitaGestioneStatefulStateless");
  3713.             logError(logCore, "Analisi modalita di gestione STATEFUL/STATELESS non riuscita: "  + e);
  3714.             if (this.msgContext.isGestioneRisposta()) {
  3715.                
  3716.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3717.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3718.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  3719.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3720.                
  3721.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3722.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3723.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3724.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3725.             }
  3726.             openspcoopstate.releaseResource();
  3727.             return;
  3728.         }


  3729.         // UPDATE: Modalita' gestione risposta (Sincrona/Fault/Ricevute...)
  3730.         // Per i profili diversi dal sincrono e' possibile impostare dove far ritornare l'errore
  3731.         if(
  3732.                 (bustaRichiesta!=null) &&
  3733.                 (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())==false) &&
  3734.                 (oneWayStateless==false) &&
  3735.                 (sincronoStateless==false) &&
  3736.                 (asincronoStateless==false) &&
  3737.                 (routingStateless==false)
  3738.             ){
  3739.             // New connection puo' essere usata solo se non siamo in modalita stateless
  3740.             newConnectionForResponse = configurazionePdDReader.newConnectionForResponse();
  3741.         }
  3742.         parametriInvioBustaErrore.setNewConnectionForResponse(newConnectionForResponse);
  3743.         if( (oneWayStateless==false) && (sincronoStateless==false) && (asincronoStateless==false) && (routingStateless==false)){
  3744.             // New connection puo' essere usata solo se non siamo in modalita stateless
  3745.             utilizzoIndirizzoTelematico = configurazionePdDReader.isUtilizzoIndirizzoTelematico();
  3746.         }
  3747.         parametriInvioBustaErrore.setUtilizzoIndirizzoTelematico(utilizzoIndirizzoTelematico);

  3748.         /* --------- Rilascio connessione se agisco come router stateless --------------- */
  3749.         if(routingStateless){
  3750.             openspcoopstate.releaseResource();
  3751.         }

  3752.         Integrazione infoIntegrazione = new Integrazione();
  3753.         infoIntegrazione.setIdModuloInAttesa(this.msgContext.getIdModulo());
  3754.         infoIntegrazione.setStateless(portaStateless);
  3755.         parametriGenerazioneBustaErrore.setIntegrazione(infoIntegrazione);




  3756.        


  3757.        

  3758.        
  3759.        
  3760.        
  3761.        
  3762.        
  3763.         // ------------- in-protocol-handler -----------------------------
  3764.         try{
  3765.             InRequestProtocolContext inRequestProtocolContext = new InRequestProtocolContext(inRequestContext);
  3766.             if(inRequestProtocolContext.getStato()==null) {
  3767.                 inRequestProtocolContext.setStato(openspcoopstate.getStatoRichiesta());
  3768.             }
  3769.             if(inRequestProtocolContext.getConnettore()!=null){
  3770.                 inRequestProtocolContext.getConnettore().setCredenziali(credenziali);
  3771.             }
  3772.             inRequestProtocolContext.setProtocollo(this.msgContext.getProtocol());
  3773.             inRequestProtocolContext.setIntegrazione(this.msgContext.getIntegrazione());
  3774.             GestoreHandlers.inRequestProtocol(inRequestProtocolContext, msgDiag, logCore);
  3775.         }catch(Exception e){        
  3776.             ErroreIntegrazione erroreIntegrazione = null;
  3777.             IntegrationFunctionError integrationFunctionError = null;
  3778.             if(e instanceof HandlerException){
  3779.                 HandlerException he = (HandlerException) e;
  3780.                 if(he.isEmettiDiagnostico()){
  3781.                     msgDiag.logErroreGenerico(e,he.getIdentitaHandler());
  3782.                 }
  3783.                 logError(logCore, "Gestione InRequestProtocolHandler non riuscita ("+he.getIdentitaHandler()+"): "  + he);
  3784.                 if(this.msgContext.isGestioneRisposta()){
  3785.                     erroreIntegrazione = he.convertToErroreIntegrazione();
  3786.                     integrationFunctionError = he.getIntegrationFunctionError();
  3787.                 }
  3788.             }else{
  3789.                 msgDiag.logErroreGenerico(e,"InvocazioneInRequestHandler");
  3790.                 logError(logCore, "Gestione InRequestProtocolHandler non riuscita: "    + e);
  3791.             }
  3792.             if (this.msgContext.isGestioneRisposta()) {
  3793.                
  3794.                 if(erroreIntegrazione==null){
  3795.                     erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3796.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_558_HANDLER_IN_PROTOCOL_REQUEST);
  3797.                 }
  3798.                 if(integrationFunctionError==null) {
  3799.                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  3800.                 }
  3801.                
  3802.                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  3803.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3804.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(erroreIntegrazione);
  3805.                 OpenSPCoop2Message errorMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3806.                 if(e instanceof HandlerException){
  3807.                     HandlerException he = (HandlerException) e;
  3808.                     he.customized(errorMsg);
  3809.                 }
  3810.                
  3811.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  3812.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorMsg);
  3813.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3814.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  3815.             }
  3816.             openspcoopstate.releaseResource();
  3817.             return;
  3818.         }
  3819.        
  3820.        
  3821.        
  3822.        
  3823.        
  3824.        
  3825.        
  3826.        
  3827.        

  3828.         // Validazione Semantica (se modalita router non attiva)
  3829.         if(!functionAsRouter){


  3830.             /* ----------- Raccolta FlowParameter MTOM / Security ------------ */
  3831.             msgDiag.mediumDebug("Raccolta FlowParameter MTOM / Security proprieta...");
  3832.             MTOMProcessor mtomProcessor = null;
  3833.             try{
  3834.                
  3835.                 // read flow Properties
  3836.                 flowPropertiesRequest = ricezioneBusteUtils.getFlowPropertiesRequest(requestMessage, bustaRichiesta, configurazionePdDReader,
  3837.                         ((StateMessage)openspcoopstate.getStatoRichiesta()), msgDiag,logCore,propertiesReader,
  3838.                         ruoloBustaRicevuta,implementazionePdDMittente,requestInfo, inRequestContext.getPddContext(),pa);                
  3839.                 flowPropertiesResponse = ricezioneBusteUtils.getFlowPropertiesResponse(requestMessage, bustaRichiesta, configurazionePdDReader,
  3840.                         ((StateMessage)openspcoopstate.getStatoRichiesta()), msgDiag,logCore,propertiesReader,
  3841.                         ruoloBustaRicevuta,implementazionePdDMittente,requestInfo, inRequestContext.getPddContext(),pa,
  3842.                         flowPropertiesRequest);
  3843.                 parametriGenerazioneBustaErrore.setFlowPropertiesResponse(flowPropertiesResponse);
  3844.                
  3845.                 // init message security context
  3846.                 if(flowPropertiesRequest!=null && flowPropertiesRequest.messageSecurity!=null &&
  3847.                         flowPropertiesRequest.messageSecurity.getFlowParameters()!=null){
  3848.                     if(flowPropertiesRequest.messageSecurity.getFlowParameters().size() > 0){
  3849.                         messageSecurityContext.setIncomingProperties(flowPropertiesRequest.messageSecurity.getFlowParameters());
  3850.                     }
  3851.                 }
  3852.                
  3853.                 // init mtom processor
  3854.                 mtomProcessor = new MTOMProcessor(flowPropertiesRequest.mtom, flowPropertiesRequest.messageSecurity,
  3855.                         tipoPorta, msgDiag, logCore, pddContext);
  3856.                
  3857.                 msgDiag.mediumDebug("Raccolta FlowParameter MTOM / Security completata con successo");
  3858.                
  3859.             }catch(Exception e){

  3860.                 // Emetto log, non ancora emesso
  3861.                 boolean mittenteEsistente = validatore.getBusta()!=null &&
  3862.                         (validatore.getBusta().getMittente()!=null || validatore.getBusta().getTipoMittente()!=null);
  3863.                 msgDiag.emitRicezioneMessaggioModuloBuste(msgDiag, pddContext, !mittenteEsistente);
  3864.            
  3865.                 msgDiag.logErroreGenerico(e,"RaccoltaFlowParameter_MTOM_Security");
  3866.                
  3867.                 // Tracciamento richiesta: non ancora registrata
  3868.                 if(this.msgContext.isTracciamentoAbilitato()){
  3869.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3870.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Riscontrato errore durante la lettura delle proprieta' di MTOM / SecurityMessage: "+e.getMessage());
  3871.                     tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3872.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3873.                             correlazioneApplicativa);
  3874.                 }
  3875.                 if(this.msgContext.isGestioneRisposta()){
  3876.                    
  3877.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3878.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3879.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  3880.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3881.                    
  3882.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3883.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3884.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3885.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3886.                 }
  3887.                 openspcoopstate.releaseResource();
  3888.                 return;
  3889.             }

  3890.            
  3891.            
  3892.            
  3893.             /* ----------- MTOM Processor BeforeSecurity ------------ */
  3894.             msgDiag.mediumDebug("MTOM Processor [BeforeSecurity]...");
  3895.             try{
  3896.                 mtomProcessor.mtomBeforeSecurity(requestMessage, flowPropertiesRequest.tipoMessaggio);
  3897.             }catch(Exception e){
  3898.                 // L'errore viene registrato dentro il metodo mtomProcessor.mtomBeforeSecurity
  3899.                 //msgDiag.logErroreGenerico(e,"MTOMProcessor(BeforeSec-"+mtomProcessor.getMTOMProcessorType()+")");
  3900.                
  3901.                 // Tracciamento richiesta: non ancora registrata
  3902.                 if(this.msgContext.isTracciamentoAbilitato()){
  3903.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3904.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Riscontrato errore durante la gestione MTOM(BeforeSec-"+mtomProcessor.getMTOMProcessorType()+"): "+e.getMessage());
  3905.                     tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3906.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3907.                             correlazioneApplicativa);
  3908.                 }
  3909.                 if(this.msgContext.isGestioneRisposta()){
  3910.                    
  3911.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3912.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3913.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_557_MTOM_PROCESSOR_ERROR));
  3914.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.ATTACHMENTS_PROCESSING_REQUEST_FAILED);
  3915.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3916.                    
  3917.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3918.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3919.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3920.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3921.                 }
  3922.                 openspcoopstate.releaseResource();
  3923.                 return;
  3924.             }
  3925.            

  3926.             /* ----------- Validazione Semantica (viene anche applicata la sicurezza) ------------ */
  3927.            
  3928.             msgDiag.logPersonalizzato("validazioneSemantica.beforeSecurity");
  3929.             boolean presenzaRichiestaProtocollo = validatore.validazioneSemantica_beforeMessageSecurity(requestInfo.getProtocolServiceBinding(),false, null, requestInfo);
  3930.            
  3931.             if(validatore.isRilevatiErroriDuranteValidazioneSemantica()==false){
  3932.                
  3933.                 try{
  3934.                     if(org.openspcoop2.security.message.engine.WSSUtilities.isNormalizeToSaajImpl(messageSecurityContext)){
  3935.                         msgDiag.mediumDebug("Normalize to saajImpl");
  3936.                         //System.out.println("RicezioneBuste.request.normalize");
  3937.                         requestMessage = requestMessage.normalizeToSaajImpl();
  3938.                        
  3939.                         validatore.updateMsg(requestMessage);
  3940.                     }
  3941.                 }catch(Exception e){
  3942.                     msgDiag.logErroreGenerico(e,"NormalizeRequestToSaajImpl");
  3943.                    
  3944.                     // Tracciamento richiesta: non ancora registrata
  3945.                     if(this.msgContext.isTracciamentoAbilitato()){
  3946.                         EsitoElaborazioneMessaggioTracciato esitoTraccia =
  3947.                                 EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Riscontrato errore durante la gestione NormalizeRequestToSaajImpl: "+e.getMessage());
  3948.                         tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  3949.                                 Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  3950.                                 correlazioneApplicativa);
  3951.                     }
  3952.                     if(this.msgContext.isGestioneRisposta()){
  3953.                        
  3954.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  3955.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3956.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  3957.                         if(validatore.getErrore_integrationFunctionError()!=null) {
  3958.                             parametriGenerazioneBustaErrore.setIntegrationFunctionError(validatore.getErrore_integrationFunctionError());
  3959.                         }
  3960.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  3961.                        
  3962.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  3963.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  3964.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  3965.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  3966.                     }
  3967.                     openspcoopstate.releaseResource();
  3968.                     return;
  3969.                 }
  3970.                
  3971.                 msgDiag.mediumDebug("Lettura informazioni sulla Sicurezza dal Messaggio di richiesta ...");
  3972.                 presenzaRichiestaProtocollo = validatore.validazioneSemantica_messageSecurity_readSecurityInfo(messageSecurityContext);
  3973.                 msgDiag.mediumDebug("Lettura informazioni sulla Sicurezza dal Messaggio di richiesta completata con successo");
  3974.            
  3975.                 if(validatore.isRilevatiErroriDuranteValidazioneSemantica()==false){                
  3976.                     if(messageSecurityContext!= null && messageSecurityContext.getIncomingProperties() != null && messageSecurityContext.getIncomingProperties().size() > 0){
  3977.                    
  3978.                         String tipoSicurezza = SecurityConstants.convertActionToString(messageSecurityContext.getIncomingProperties());
  3979.                         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_SICUREZZA_MESSAGGIO_RICHIESTA, tipoSicurezza);
  3980.                         pddContext.addObject(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RICHIESTA, tipoSicurezza);
  3981.                        
  3982.                         msgDiag.logPersonalizzato("messageSecurity.processamentoRichiestaInCorso");
  3983.                        
  3984.                         StringBuilder bfErroreSecurity = new StringBuilder();
  3985.                         DynamicMapBuilderUtils.injectDynamicMap(bustaRichiesta, requestInfo, pddContext, logCore);
  3986.                         presenzaRichiestaProtocollo = validatore.validazioneSemantica_messageSecurity_process(messageSecurityContext, bfErroreSecurity,
  3987.                                 transaction!=null ? transaction.getTempiElaborazione() : null,
  3988.                                         true);
  3989.                        
  3990.                         if(bfErroreSecurity.length()>0){
  3991.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO , bfErroreSecurity.toString() );
  3992.                             msgDiag.logPersonalizzato("messageSecurity.processamentoRichiestaInErrore");
  3993.                         }
  3994.                         else{
  3995.                             msgDiag.logPersonalizzato("messageSecurity.processamentoRichiestaEffettuato");
  3996.                         }
  3997.                     }  
  3998.                     else{
  3999.                         msgDiag.logPersonalizzato("messageSecurity.processamentoRichiestaDisabilitato");
  4000.                     }
  4001.                 }
  4002.            
  4003.                 if(validatore.isRilevatiErroriDuranteValidazioneSemantica()==false){
  4004.                    
  4005.                     msgDiag.logPersonalizzato("validazioneSemantica.afterSecurity");
  4006.                     presenzaRichiestaProtocollo = validatore.validazioneSemantica_afterMessageSecurity(proprietaManifestAttachments, validazioneIDBustaCompleta, requestInfo);
  4007.            
  4008.                 }
  4009.             }

  4010.             if(presenzaRichiestaProtocollo == false){

  4011.                 // Emetto log, non ancora emesso
  4012.                 boolean mittenteEsistente = validatore.getBusta()!=null &&
  4013.                         (validatore.getBusta().getMittente()!=null || validatore.getBusta().getTipoMittente()!=null);
  4014.                 msgDiag.emitRicezioneMessaggioModuloBuste(msgDiag, pddContext, !mittenteEsistente);
  4015.                
  4016.                 try{
  4017.                     msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, validatore.getErrore().getDescrizione(protocolFactory));
  4018.                 }catch(Exception e){
  4019.                     logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  4020.                 }
  4021.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_BUSTA, "semantica");
  4022.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneNonRiuscita");
  4023.                
  4024.                 // Tracciamento richiesta: non ancora registrata
  4025.                 if(this.msgContext.isTracciamentoAbilitato()){
  4026.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  4027.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneNonRiuscita"));
  4028.                     tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  4029.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4030.                             correlazioneApplicativa);
  4031.                 }
  4032.                 if(this.msgContext.isGestioneRisposta()){
  4033.                    
  4034.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4035.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4036.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO));
  4037.                     if(validatore.getErrore_integrationFunctionError()!=null) {
  4038.                         parametriGenerazioneBustaErrore.setIntegrationFunctionError(validatore.getErrore_integrationFunctionError());
  4039.                     }
  4040.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,validatore.getEccezioneProcessamentoValidazioneSemantica());
  4041.                    
  4042.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  4043.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4044.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4045.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  4046.                 }
  4047.                 openspcoopstate.releaseResource();
  4048.                 return;
  4049.             }
  4050.            
  4051.            
  4052.             /* ----------- MTOM Processor AfterSecurity ------------ */
  4053.             msgDiag.mediumDebug("MTOM Processor [AfterSecurity]...");
  4054.             try{
  4055.                 mtomProcessor.mtomAfterSecurity(requestMessage, flowPropertiesRequest.tipoMessaggio);
  4056.             }catch(Exception e){
  4057.                 // L'errore viene registrato dentro il metodo mtomProcessor.mtomAfterSecurity
  4058.                 //msgDiag.logErroreGenerico(e,"MTOMProcessor(AfterSec-"+mtomProcessor.getMTOMProcessorType()+")");
  4059.                
  4060.                 // Tracciamento richiesta: non ancora registrata
  4061.                 if(this.msgContext.isTracciamentoAbilitato()){
  4062.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  4063.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Riscontrato errore durante la gestione MTOM(AfterSec-"+mtomProcessor.getMTOMProcessorType()+"): "+e.getMessage());
  4064.                     tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  4065.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4066.                             correlazioneApplicativa);
  4067.                 }
  4068.                 if(this.msgContext.isGestioneRisposta()){
  4069.                    
  4070.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4071.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4072.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_557_MTOM_PROCESSOR_ERROR));
  4073.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.ATTACHMENTS_PROCESSING_REQUEST_FAILED);
  4074.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  4075.                    
  4076.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  4077.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4078.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4079.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  4080.                 }
  4081.                 openspcoopstate.releaseResource();
  4082.                 return;
  4083.             }
  4084.            
  4085.         }
  4086.         java.util.List<Eccezione> erroriValidazione = validatore.getEccezioniValidazione();
  4087.         java.util.List<Eccezione> erroriProcessamento =validatore.getEccezioniProcessamento();
  4088.         IntegrationFunctionError integrationFunctionErrorValidazione = validatore.getErrore_integrationFunctionError();
  4089.         SecurityInfo securityInfoRequest = validatore.getSecurityInfo();
  4090.        
  4091.         boolean isMessaggioErroreProtocollo = validatore.isErroreProtocollo();
  4092.         // Se ho un msg Errore e' interessante solo utilizzare mittente/destinatario poiche' il servizio non esistera'
  4093.         // La busta e' stata invertita tra mittente e destinatario
  4094.         if(isMessaggioErroreProtocollo && idServizio!=null){
  4095.             this.cleanDatiServizio(idServizio);
  4096.             idServizio.setAzione(null);
  4097.         }
  4098.         boolean bustaDiServizio = validatore.isBustaDiServizio();
  4099.         if(validatore.getInfoServizio()!=null && validatore.getInfoServizio().getIdAccordo()!=null){
  4100.             this.msgContext.getProtocol().setIdAccordo(validatore.getInfoServizio().getIdAccordo());
  4101.             richiestaApplicativa.setIdAccordo(validatore.getInfoServizio().getIdAccordo());
  4102.         }
  4103.         else if(infoServizio!=null && infoServizio.getIdAccordo()!=null){
  4104.             this.msgContext.getProtocol().setIdAccordo(infoServizio.getIdAccordo());
  4105.             richiestaApplicativa.setIdAccordo(infoServizio.getIdAccordo());
  4106.         }
  4107.        
  4108.         // Aggiorno eventuale valore ProfiloCollaborazione dipendete dal profilo (PDC)
  4109.         if(bustaRichiesta!=null && this.msgContext.getProtocol()!=null) {
  4110.             this.msgContext.getProtocol().setProfiloCollaborazione(bustaRichiesta.getProfiloDiCollaborazione(),bustaRichiesta.getProfiloDiCollaborazioneValue());
  4111.             if(
  4112.                     (bustaRichiesta!=null) &&
  4113.                     (bustaRichiesta.getVersioneServizio()!=null) &&
  4114.                     (bustaRichiesta.getVersioneServizio().intValue()>0) &&
  4115.                     (this.msgContext.getProtocol().getVersioneServizio()!=null) &&
  4116.                     (bustaRichiesta.getVersioneServizio().intValue()!=this.msgContext.getProtocol().getVersioneServizio().intValue())
  4117.                 ) {
  4118.                 this.msgContext.getProtocol().setVersioneServizio(bustaRichiesta.getVersioneServizio());
  4119.             }
  4120.         }

  4121.        
  4122.        
  4123.        
  4124.        
  4125.        
  4126.         /* ------------ Riconciliazione Mittente per caso intermediario ------------- */
  4127.         if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol()) &&
  4128.                 pddContext.containsKey(CostantiPdD.INTERMEDIARIO)) {
  4129.                 Object o = pddContext.get(CostantiPdD.INTERMEDIARIO);
  4130.                 if(o instanceof IDSoggetto) {
  4131.                     IDSoggetto intermediario = (IDSoggetto) o;
  4132.                     if(soggettoFruitore!=null && soggettoFruitore.equals(intermediario) && bustaRichiesta!=null &&
  4133.                             bustaRichiesta.getMittente()!=null && !bustaRichiesta.getMittente().equals(intermediario.getNome())) {
  4134.                         soggettoFruitore.setNome(bustaRichiesta.getMittente());
  4135.                         soggettoFruitore.setCodicePorta(bustaRichiesta.getIdentificativoPortaMittente());
  4136.                         if(msgDiag!=null) {
  4137.                             msgDiag.setFruitore(soggettoFruitore);
  4138.                         }
  4139.                         if(this.msgContext.getProtocol()!=null) {
  4140.                             this.msgContext.getProtocol().setFruitore(soggettoFruitore);
  4141.                         }
  4142.                     }
  4143.                 }
  4144.         }
  4145.        
  4146.        
  4147.        
  4148.        
  4149.        
  4150.         /* ------------ Riconciliazione ID Messaggio con quello ricevuto nel token oAuth ------------- */
  4151.        
  4152.         if(Costanti.MODIPA_PROTOCOL_NAME.equals(protocolFactory.getProtocol()) &&
  4153.             pddContext.containsKey(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID_UPDATE_DIAGNOSTIC)) {
  4154.             Object o = pddContext.get(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID_UPDATE_DIAGNOSTIC);
  4155.             if(o instanceof String) {
  4156.                 msgDiag.updateKeywordIdMessaggioRichiesta((String)o);
  4157.                 idMessageRequest = (String)o;
  4158.                 this.msgContext.getProtocol().setIdRichiesta(idMessageRequest);
  4159.             }
  4160.         }
  4161.        
  4162.        
  4163.        
  4164.        
  4165.        
  4166.        
  4167.        
  4168.        
  4169.         /* -------- Controlli Header di Integrazione ------------- */
  4170.        
  4171.         IProtocolConfiguration protocolConfig = protocolFactory.createProtocolConfiguration();
  4172.         if(
  4173.                 (infoServizio!=null) &&
  4174.                 (infoServizio.getIdRiferimentoRichiesta()) &&
  4175.                 (protocolConfig.isIntegrationInfoRequired(TipoPdD.APPLICATIVA, requestInfo.getProtocolServiceBinding(),FunzionalitaProtocollo.RIFERIMENTO_ID_RICHIESTA))
  4176.             ) {
  4177.             String riferimentoRichiesta = null;
  4178.             if (headerIntegrazioneRichiesta!=null &&
  4179.                     headerIntegrazioneRichiesta.getBusta() != null && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null) {
  4180.                 riferimentoRichiesta = headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio();
  4181.             }
  4182.             if(riferimentoRichiesta==null) {
  4183.                 StringBuilder bf = new StringBuilder();
  4184.                 for (int i = 0; i < tipiIntegrazionePA.length; i++) {
  4185.                     if(i>0) {
  4186.                         bf.append(",");
  4187.                     }
  4188.                     bf.append(tipiIntegrazionePA[i]);
  4189.                 }
  4190.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPI_INTEGRAZIONE ,bf.toString() );
  4191.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE,"riferimentoIdRichiesta.nonFornito");
  4192.                
  4193.                 // Tracciamento richiesta: non ancora registrata
  4194.                 if(this.msgContext.isTracciamentoAbilitato()){
  4195.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  4196.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(msgDiag.getMessaggio(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE,"riferimentoIdRichiesta.nonFornito"));
  4197.                     tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  4198.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4199.                             correlazioneApplicativa);
  4200.                 }
  4201.                
  4202.                 if(this.msgContext.isGestioneRisposta()){
  4203.                    
  4204.                     ErroreIntegrazione erroreIntegrazione = ErroriIntegrazione.ERRORE_442_RIFERIMENTO_ID_MESSAGGIO.getErroreIntegrazione();
  4205.                     IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND;
  4206.                    
  4207.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4208.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(erroreIntegrazione);
  4209.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  4210.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore, null);

  4211.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4212.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4213.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4214.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  4215.                 }
  4216.                 openspcoopstate.releaseResource();
  4217.                 return;

  4218.                
  4219.             }
  4220.         }
  4221.        
  4222.        
  4223.        
  4224.        
  4225.        
  4226.        
  4227.         /* ----------- Sbustamento ------------ */
  4228.         BustaRawContent<?> headerProtocolloRichiesta = null;
  4229.         if(functionAsRouter == false &&
  4230.                 isMessaggioErroreProtocollo==false &&
  4231.                 erroriProcessamento.size()==0 && erroriValidazione.size()==0 &&
  4232.                 bustaDiServizio==false){
  4233.             msgDiag.highDebug("Tipo Messaggio Richiesta prima dello sbustamento ["+FaseSbustamento.POST_VALIDAZIONE_SEMANTICA_RISPOSTA
  4234.                     +"] ["+requestMessage.getClass().getName()+"]");
  4235.             org.openspcoop2.protocol.engine.builder.Sbustamento sbustatore = new org.openspcoop2.protocol.engine.builder.Sbustamento(protocolFactory,openspcoopstate.getStatoRichiesta());
  4236.             ProtocolMessage protocolMessage = sbustatore.sbustamento(requestMessage,pddContext,
  4237.                     bustaRichiesta,
  4238.                     RuoloMessaggio.RICHIESTA,properties.isValidazioneManifestAttachments(),proprietaManifestAttachments,
  4239.                     FaseSbustamento.POST_VALIDAZIONE_SEMANTICA_RICHIESTA, requestInfo);
  4240.             if(protocolMessage!=null) {
  4241.                 if(protocolMessage.isUseBustaRawContentReadByValidation()) {
  4242.                     headerProtocolloRichiesta = soapHeaderElement;
  4243.                 }
  4244.                 else {
  4245.                     headerProtocolloRichiesta = protocolMessage.getBustaRawContent();
  4246.                 }
  4247.                 requestMessage = protocolMessage.getMessage(); // updated
  4248.             }
  4249.             msgDiag.highDebug("Tipo Messaggio Richiesta dopo lo sbustamento ["+FaseSbustamento.POST_VALIDAZIONE_SEMANTICA_RISPOSTA
  4250.                     +"] ["+requestMessage.getClass().getName()+"]");
  4251.         }
  4252.         else{
  4253.             headerProtocolloRichiesta = soapHeaderElement;
  4254.         }
  4255.        
  4256.        
  4257.        
  4258.        
  4259.        
  4260.         /* --------------- CorrelazioneApplicativa (Lato PA se definita) -------------------
  4261.          * NOTA: Vi e' l'overwrite dell'informazione sulla correlazione applicativa eventualmente letta prima dall'header di trasporto
  4262.          *        opzione comunuque per default disabitata.
  4263.          * --------------- */
  4264.         if(functionAsRouter == false &&
  4265.                 isMessaggioErroreProtocollo==false &&
  4266.                 erroriProcessamento.size()==0 && erroriValidazione.size()==0 &&
  4267.                 bustaDiServizio==false &&
  4268.                 pa!=null && pa.getCorrelazioneApplicativa()!=null){
  4269.        
  4270.             GestoreCorrelazioneApplicativa gestoreCorrelazioneApplicativa = null;
  4271.             try {
  4272.                 GestoreCorrelazioneApplicativaConfig caConfig = new GestoreCorrelazioneApplicativaConfig();
  4273.                 caConfig.setState(openspcoopstate.getStatoRichiesta());
  4274.                 caConfig.setAlog(logCore);
  4275.                 caConfig.setSoggettoFruitore(soggettoFruitore);
  4276.                 caConfig.setIdServizio(idServizio);
  4277.                 caConfig.setBusta(bustaRichiesta);
  4278.                 caConfig.setServizioApplicativo(servizioApplicativoFruitore);
  4279.                 caConfig.setProtocolFactory(protocolFactory);
  4280.                 caConfig.setTransaction(transaction);
  4281.                 caConfig.setPddContext(pddContext);
  4282.                 caConfig.setPa(pa);
  4283.                 gestoreCorrelazioneApplicativa = new GestoreCorrelazioneApplicativa(caConfig);
  4284.                
  4285.                 gestoreCorrelazioneApplicativa.verificaCorrelazione(pa.getCorrelazioneApplicativa(), urlProtocolContext, requestMessage,
  4286.                         headerIntegrazioneRichiesta, false);
  4287.                
  4288.                 if(gestoreCorrelazioneApplicativa.getIdCorrelazione()!=null)
  4289.                     correlazioneApplicativa = gestoreCorrelazioneApplicativa.getIdCorrelazione();
  4290.                
  4291.             }catch(Exception e){
  4292.                
  4293.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_CORRELAZIONE_APPLICATIVA_RICHIESTA, "true");
  4294.                
  4295.                 msgDiag.logErroreGenerico(e,"CorrelazioneApplicativa("+bustaRichiesta.getID()+")");
  4296.                 logError(logCore, "Riscontrato errore durante la correlazione applicativa ["+bustaRichiesta.getID()+"]",e);
  4297.                
  4298.                 // Tracciamento richiesta: non ancora registrata
  4299.                 if(this.msgContext.isTracciamentoAbilitato()){
  4300.                     EsitoElaborazioneMessaggioTracciato esitoTraccia =
  4301.                             EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Riscontrato errore durante la correlazione applicativa ["+bustaRichiesta.getID()+"]: "+e.getMessage());
  4302.                     tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  4303.                             Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4304.                             correlazioneApplicativa);
  4305.                 }
  4306.                
  4307.                 if(this.msgContext.isGestioneRisposta()){
  4308.                    
  4309.                     ErroreIntegrazione errore = null;
  4310.                     if(gestoreCorrelazioneApplicativa!=null){
  4311.                         errore = gestoreCorrelazioneApplicativa.getErrore();
  4312.                     }
  4313.                     if(errore==null){
  4314.                         errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4315.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_529_CORRELAZIONE_APPLICATIVA_RICHIESTA_NON_RIUSCITA);
  4316.                     }
  4317.                    
  4318.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4319.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(errore);
  4320.                     IntegrationFunctionError integrationFunctionError = null;
  4321.                     if(CodiceErroreIntegrazione.CODICE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.equals(errore.getCodiceErrore())){
  4322.                         integrationFunctionError = IntegrationFunctionError.APPLICATION_CORRELATION_IDENTIFICATION_REQUEST_FAILED;
  4323.                     }
  4324.                     else{
  4325.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  4326.                     }
  4327.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  4328.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);

  4329.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4330.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4331.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4332.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  4333.                 }
  4334.                 openspcoopstate.releaseResource();
  4335.                 return;
  4336.             }
  4337.         }
  4338.         else{
  4339.             // L'informazione nel caso di functionAsRouter o isMessaggioErrore o erroriProcessamento.size()>0 o erroriValidazione.size()>0 o bustaDiServizio non e' significativa
  4340.             // Invece nel caso di pa==null o di pa.getCorrelazioneApplicativa==null l'informazione eventualmente cmq letta prima non deve essere usata:
  4341.             correlazioneApplicativa = null;
  4342.         }
  4343.        
  4344.        
  4345.        
  4346.        
  4347.        
  4348.        
  4349.        
  4350.        
  4351.        
  4352.        
  4353.        
  4354.         /* --------------- Header Integrazione SOAP (aggiornamento/eliminazione) -------------------  */
  4355.         if(tipiIntegrazionePA!=null){
  4356.            
  4357.             if(inRequestPAMessage!=null){
  4358.                 inRequestPAMessage.setBustaRichiesta(bustaRichiesta);
  4359.                 inRequestPAMessage.setSoggettoMittente(soggettoFruitore);
  4360.             }
  4361.            
  4362.             for (int i = 0; i < tipiIntegrazionePA.length; i++) {
  4363.                 try {
  4364.                     IGestoreIntegrazionePA gestore = null;
  4365.                     try {
  4366.                         gestore = (IGestoreIntegrazionePA) pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazionePA[i]);
  4367.                     }catch(Exception e){
  4368.                         throw e;
  4369.                     }
  4370.                     if(gestore!=null){
  4371.                         String classType = null;
  4372.                         try {
  4373.                             classType = gestore.getClass().getName();
  4374.                             AbstractCore.init(gestore, pddContext, protocolFactory);
  4375.                         } catch (Exception e) {
  4376.                             throw new Exception(
  4377.                                     "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  4378.                                             + "] da utilizzare per la gestione dell'integrazione delle erogazioni (aggiornamento/eliminazione) di tipo ["+ tipiIntegrazionePA[i] + "]: " + e.getMessage());
  4379.                         }
  4380.                         if (gestore instanceof IGestoreIntegrazionePASoap) {
  4381.                             if(propertiesReader.deleteHeaderIntegrazioneRequestPA()){
  4382.                                 ((IGestoreIntegrazionePASoap)gestore).deleteInRequestHeader(inRequestPAMessage);
  4383.                             }
  4384.                             else{
  4385.                                 ((IGestoreIntegrazionePASoap)gestore).updateInRequestHeader(inRequestPAMessage, idMessageRequest, servizioApplicativoFruitore, correlazioneApplicativa);
  4386.                             }
  4387.                         }  
  4388.                     }
  4389.                 } catch (Exception e) {
  4390.                     msgDiag.logErroreGenerico(e,"HeaderIntegrazione("+tipiIntegrazionePA[i]+")");
  4391.                    
  4392.                     // Tracciamento richiesta: non ancora registrata
  4393.                     if(this.msgContext.isTracciamentoAbilitato()){
  4394.                         EsitoElaborazioneMessaggioTracciato esitoTraccia =
  4395.                                 EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Riscontrato errore durante la gestione dell'Header di Integrazione("+tipiIntegrazionePA[i]+"): "+e.getMessage());
  4396.                         tracciamento.registraRichiesta(requestMessage,null,soapHeaderElement,bustaRichiesta,esitoTraccia,
  4397.                                 Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4398.                                 correlazioneApplicativa);
  4399.                     }
  4400.                    
  4401.                     if(this.msgContext.isGestioneRisposta()){
  4402.                        
  4403.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4404.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4405.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_541_GESTIONE_HEADER_INTEGRAZIONE));
  4406.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);

  4407.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4408.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4409.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4410.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  4411.                     }
  4412.                     openspcoopstate.releaseResource();
  4413.                     return;
  4414.                 }
  4415.             }
  4416.         }
  4417.        
  4418.        
  4419.        
  4420.        
  4421.        
  4422.        
  4423.        
  4424.        
  4425.        

  4426.        

  4427.         /* ----------- Correlazione nei messaggi diagnostici ---------------*/
  4428.         msgDiag.setIdCorrelazioneApplicativa(correlazioneApplicativa);
  4429.         if(this.msgContext.getIntegrazione()!=null)
  4430.             this.msgContext.getIntegrazione().setIdCorrelazioneApplicativa(correlazioneApplicativa);
  4431.         parametriGenerazioneBustaErrore.setMsgDiag(msgDiag);
  4432.         parametriInvioBustaErrore.setMsgDiag(msgDiag);
  4433.        
  4434.        
  4435.        
  4436.        
  4437.        
  4438.        
  4439.        
  4440.        
  4441.        
  4442.        
  4443.        
  4444.         /* ----------- Emetto msg diagnostico di ricezione Busta ----------------------*/
  4445.         DettaglioEccezione dettaglioEccezione = null;
  4446.         boolean mittenteAnonimo = false;
  4447.         if(validatore.getBusta()!=null &&
  4448.                 (validatore.getBusta().getMittente()!=null || validatore.getBusta().getTipoMittente()!=null)){
  4449.             mittenteAnonimo = false;
  4450.         }
  4451.         else{
  4452.             mittenteAnonimo = true;
  4453.         }
  4454.         if(isMessaggioErroreProtocollo){
  4455.             if(validatore.isMessaggioErroreIntestazione()){
  4456.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO_BUSTA_ERRORE, CostantiPdD.TIPO_MESSAGGIO_BUSTA_ERRORE_INTESTAZIONE);
  4457.             }else{
  4458.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO_BUSTA_ERRORE, CostantiPdD.TIPO_MESSAGGIO_BUSTA_ERRORE_PROCESSAMENTO);
  4459.             }
  4460.             msgDiag.logPersonalizzato("ricezioneMessaggioErrore");
  4461.            
  4462.             // Esamino se e' presente un elemento DettaglioEccezione
  4463.             try{
  4464.                 dettaglioEccezione = XMLUtils.getDettaglioEccezione(logCore,requestMessage);
  4465.             }catch(Exception e){
  4466.                 logError(logCore, "Errore durante l'analisi del dettaglio dell'eccezione",e);
  4467.             }
  4468.            
  4469.         }else{
  4470.             msgDiag.emitRicezioneMessaggioModuloBuste(msgDiag, pddContext, mittenteAnonimo);
  4471.         }












  4472.         /* -------- Profilo di Gestione ------------- */
  4473.         String versioneProtocollo = validatore.getProfiloGestione();
  4474.         msgDiag.mediumDebug("Profilo di gestione ["+RicezioneBuste.ID_MODULO+"] della busta: "+versioneProtocollo);
  4475.         richiestaApplicativa.setProfiloGestione(versioneProtocollo);
  4476.         parametriGenerazioneBustaErrore.setProfiloGestione(versioneProtocollo);
  4477.         IProtocolVersionManager moduleManager = protocolFactory.createProtocolVersionManager(versioneProtocollo);
  4478.         if( !functionAsRouter ){

  4479.             // Riferimento messaggio con un profilo sincrono non può essere ricevuto in questo contesto.
  4480.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  4481.                     bustaRichiesta.getRiferimentoMessaggio()!=null &&
  4482.                     !isMessaggioErroreProtocollo &&// aggiunto !isMessaggioErrore poiche' una busta di eccezione puo' contenenere in effetti il rifMsg
  4483.                     (ruoloBustaRicevuta==null || !ruoloBustaRicevuta.equals(RuoloBusta.RICHIESTA)) // aggiunto questo controllo perchè i protocolli con id riferimento richiesta hanno il rif messaggio, ma il ruolo rimane RICHIESTA
  4484.                     ){
  4485.                 Eccezione ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(), protocolFactory);
  4486.                 erroriValidazione.add(ecc);
  4487.             }
  4488.         }

















  4489.         /* -------- Gestione errori ------------- */
  4490.         // Se sono in modalita router: se vi sono errori di processamento/validazione, ritorno subito l'errore.
  4491.         // altrimenti: se sono presenti errore di processamento, ritorno subito l'errore.
  4492.         msgDiag.mediumDebug("Gestione errori...");
  4493.         if( (erroriProcessamento.size()>0) || (functionAsRouter && (erroriValidazione.size()>0)) ){
  4494.             StringBuilder errore = new StringBuilder();
  4495.             for(int k=0; k<erroriProcessamento.size();k++){
  4496.                 Eccezione erroreProcessamento = erroriProcessamento.get(k);
  4497.                 try{
  4498.                     errore.append("Processamento["+traduttore.toString(erroreProcessamento.getCodiceEccezione(),erroreProcessamento.getSubCodiceEccezione())+"] "+erroriProcessamento.get(k).getDescrizione(protocolFactory)+"\n");
  4499.                 }catch(Exception e){
  4500.                     logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  4501.                 }
  4502.             }
  4503.             for(int k=0; k<erroriValidazione.size();k++){
  4504.                 Eccezione erroreValidazione = erroriValidazione.get(k);
  4505.                 try{
  4506.                     errore.append("Validazione["+traduttore.toString(erroreValidazione.getCodiceEccezione(),erroreValidazione.getSubCodiceEccezione())+"] "+erroriValidazione.get(k).getDescrizione(protocolFactory)+"\n");
  4507.                 }catch(Exception e){
  4508.                     logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  4509.                 }
  4510.             }
  4511.             msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, errore.toString());
  4512.             msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, (erroriProcessamento.size()+erroriValidazione.size())+"" );
  4513.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneBusta.bustaNonCorretta");
  4514.             // Tracciamento richiesta: non ancora registrata
  4515.             if(this.msgContext.isTracciamentoAbilitato()){
  4516.                 EsitoElaborazioneMessaggioTracciato esitoTraccia =
  4517.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneBusta.bustaNonCorretta"));
  4518.                 tracciamento.registraRichiesta(requestMessage,securityInfoRequest,soapHeaderElement,bustaRichiesta,esitoTraccia,
  4519.                         Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4520.                         correlazioneApplicativa);
  4521.             }
  4522.             if(this.msgContext.isGestioneRisposta()){
  4523.                 OpenSPCoop2Message errorOpenSPCoopMsg = null;
  4524.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4525.                 if(erroriProcessamento.size()>0){
  4526.                     // inserisco in erroriProcessamento anche erroriValidazione
  4527.                     for(int j=0; j<erroriValidazione.size(); j++){
  4528.                         erroriProcessamento.add(erroriValidazione.get(j));
  4529.                     }

  4530.                     parametriGenerazioneBustaErrore.setError(erroriProcessamento);
  4531.                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,null);

  4532.                 }else{

  4533.                     parametriGenerazioneBustaErrore.setError(erroriValidazione);
  4534.                     if(integrationFunctionErrorValidazione!=null) {
  4535.                         parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionErrorValidazione);
  4536.                     }
  4537.                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);

  4538.                 }
  4539.                
  4540.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento

  4541.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4542.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4543.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  4544.             }
  4545.             openspcoopstate.releaseResource();
  4546.             return;
  4547.         }











  4548.        
  4549.        
  4550.        
  4551.         /* -------- Tracciamento ------------- */
  4552.         if(this.msgContext.isTracciamentoAbilitato()){
  4553.             msgDiag.mediumDebug("Tracciamento busta di richiesta...");
  4554.            
  4555.             EsitoElaborazioneMessaggioTracciato esitoTraccia = null;
  4556.             if( (erroriProcessamento.size()>0) || (erroriValidazione.size()>0) ){
  4557.                
  4558.                 boolean foundErroriGravi = false;
  4559.                
  4560.                 String dettaglioErrore = null;
  4561.                 StringBuilder eccBuffer = new StringBuilder();
  4562.                 for(int k = 0; k < erroriProcessamento.size() ; k++){
  4563.                     Eccezione er = erroriProcessamento.get(k);
  4564.                     if(k>0)
  4565.                         eccBuffer.append(" ");
  4566.                     eccBuffer.append(er.toString(protocolFactory));
  4567.                     eccBuffer.append(";");
  4568.                    
  4569.                     if(moduleManager.isIgnoraEccezioniLivelloNonGrave()){
  4570.                         if(er.getRilevanza()!=null){
  4571.                             if(LivelloRilevanza.isEccezioneLivelloGrave(er.getRilevanza())){
  4572.                                 foundErroriGravi = true;
  4573.                             }
  4574.                         }else{
  4575.                             foundErroriGravi = true;
  4576.                         }
  4577.                     }else{
  4578.                         foundErroriGravi = true;
  4579.                     }
  4580.                 }
  4581.                 for(int k = 0; k < erroriValidazione.size() ; k++){
  4582.                     Eccezione er = erroriValidazione.get(k);
  4583.                     if(eccBuffer.length()>0)
  4584.                         eccBuffer.append(" ");
  4585.                     eccBuffer.append(er.toString(protocolFactory));
  4586.                     eccBuffer.append(";");
  4587.                    
  4588.                     if(moduleManager.isIgnoraEccezioniLivelloNonGrave()){
  4589.                         if(er.getRilevanza()!=null){
  4590.                             if(LivelloRilevanza.isEccezioneLivelloGrave(er.getRilevanza())){
  4591.                                 foundErroriGravi = true;
  4592.                             }
  4593.                         }else{
  4594.                             foundErroriGravi = true;
  4595.                         }
  4596.                     }else{
  4597.                         foundErroriGravi = true;
  4598.                     }
  4599.                 }
  4600.                 msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, erroriProcessamento.size()+erroriValidazione.size()+"");
  4601.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, eccBuffer.toString());
  4602.                 if(isMessaggioErroreProtocollo){
  4603.                     dettaglioErrore = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneBustaErrore.listaEccezioniMalformata");
  4604.                 }else{
  4605.                     dettaglioErrore = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneBusta.bustaNonCorretta");
  4606.                 }
  4607.                 if(foundErroriGravi){
  4608.                     esitoTraccia =
  4609.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore(dettaglioErrore);
  4610.                 }
  4611.                 else{
  4612.                     esitoTraccia =
  4613.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioRicevuto(dettaglioErrore);
  4614.                 }
  4615.             }
  4616.             else{
  4617.                 esitoTraccia =
  4618.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioRicevuto();
  4619.             }
  4620.            
  4621.             // Tracciamento Busta Ricevuta
  4622.             tracciamento.registraRichiesta(requestMessage,securityInfoRequest,headerProtocolloRichiesta,bustaRichiesta,esitoTraccia,
  4623.                     Tracciamento.createLocationString(true,this.msgContext.getSourceLocation()),
  4624.                     correlazioneApplicativa);
  4625.         }













  4626.         /* -------- Check Mittente o Destinatario o Servizio conosciuto o identificativo errato ---------------- */
  4627.         msgDiag.mediumDebug("Controllo mittente/destinatario/servizio (se sconosciuto, risposta immediata sulla connessione)...");
  4628.         for(int k = 0; k < erroriValidazione.size() ; k++){
  4629.             Eccezione er = erroriValidazione.get(k);
  4630.             if( CodiceErroreCooperazione.isEccezioneMittente(er.getCodiceEccezione()) ||            
  4631.                 CodiceErroreCooperazione.isEccezioneDestinatario(er.getCodiceEccezione()) ||    
  4632.                 CodiceErroreCooperazione.isEccezioneServizio(er.getCodiceEccezione()) ||    
  4633.                 CodiceErroreCooperazione.isEccezioneIdentificativoMessaggio(er.getCodiceEccezione()) ||
  4634.                 CodiceErroreCooperazione.isEccezioneSicurezzaAutorizzazione(er.getCodiceEccezione()) ){

  4635.                 if(!functionAsRouter){
  4636.                     // Può esistere un errore mittente, che non è altro che una segnalazione sull'indirizzo telematico
  4637.                     if(moduleManager.isEccezioniLivelloInfoAbilitato()){
  4638.                         if(LivelloRilevanza.INFO.equals(er.getRilevanza()))
  4639.                             continue;
  4640.                     }
  4641.                 }

  4642.                 StringBuilder eccBuffer = new StringBuilder();
  4643.                 for(int j = 0; j < erroriValidazione.size() ; j++){
  4644.                     if(j>0)
  4645.                         eccBuffer.append("\n");
  4646.                     eccBuffer.append(erroriValidazione.get(j).toString(protocolFactory));
  4647.                 }
  4648.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, eccBuffer.toString());
  4649.                 msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, erroriValidazione.size()+"" );
  4650.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"validazioneBusta.bustaNonCorretta");
  4651.                 if(this.msgContext.isGestioneRisposta()){
  4652.                    
  4653.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4654.                     List<Eccezione> errs = new ArrayList<>();
  4655.                     for(int add = 0; add < erroriValidazione.size() ; add++){
  4656.                         errs.add(erroriValidazione.get(add));
  4657.                     }
  4658.                     parametriGenerazioneBustaErrore.setError(errs);
  4659.                    
  4660.                     if(integrationFunctionErrorValidazione!=null) {
  4661.                         parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionErrorValidazione);
  4662.                     }
  4663.                     else if(CodiceErroreCooperazione.isEccezioneSicurezzaAutorizzazione(er.getCodiceEccezione())) {
  4664.                         parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.AUTHORIZATION);
  4665.                     }
  4666.                     else {
  4667.                         parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_REQUEST);
  4668.                     }
  4669.                    
  4670.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  4671.                    
  4672.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4673.                     // se il mittente e' sconosciuto non e' possibile utilizzare l'invio su di una nuova connessione,
  4674.                     // a meno della presenza dell'indirizzo telematico, poiche' non esistera un connettore su cui spedire

  4675.                     parametriInvioBustaErrore.setUtilizzoIndirizzoTelematico(false);
  4676.                     parametriInvioBustaErrore.setNewConnectionForResponse(false);
  4677.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4678.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4679.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  4680.                 }
  4681.                 openspcoopstate.releaseResource();
  4682.                 return;
  4683.             }
  4684.         }





  4685.        
  4686.        







  4687.         /* -------- Check Autorizzazione (Se non ho ricevuto un msg Errore Protocollo)---------------- */
  4688.        
  4689.         // Guardo se vi sono eccezioni di validazione
  4690.         // Se ci sono eccezioni di processamento vengono ritornate prima
  4691.         boolean eccezioniValidazioni = false;
  4692.         for(int k = 0; k < erroriValidazione.size() ; k++){
  4693.             Eccezione er = erroriValidazione.get(k);
  4694.             if(!functionAsRouter){
  4695.                 // Check profilo linee guida 1.0
  4696.                 // Può esistere un errore, che non è altro che una segnalazione sull'indirizzo telematico
  4697.                 if(moduleManager.isEccezioniLivelloInfoAbilitato()){
  4698.                     if(LivelloRilevanza.INFO.equals(er.getRilevanza()))
  4699.                         continue;
  4700.                 }
  4701.             }
  4702.             eccezioniValidazioni = true;
  4703.             break;
  4704.         }
  4705.        
  4706.         msgDiag.mediumDebug("Autorizzazione ...");
  4707.         String tipoAutorizzazione = null;
  4708.         try{
  4709.             if(functionAsRouter){
  4710.                 tipoAutorizzazione = propertiesReader.getTipoAutorizzazioneBuste();
  4711.             }
  4712.             else{
  4713.                 if(pa!=null){
  4714.                     tipoAutorizzazione = configurazionePdDReader.getAutorizzazione(pa);
  4715.                 }
  4716.                 // Non ha senso effettuare l'autorizzazione basato sulla PD
  4717. //              else{
  4718. //                  tipoAutorizzazione = configurazionePdDReader.getAutorizzazione(pd);
  4719. //              }
  4720.             }
  4721.         }catch(Exception notFound){
  4722.             // ignore
  4723.         }
  4724.         boolean isAttivoAutorizzazioneBuste = tipoAutorizzazione!=null && !CostantiConfigurazione.AUTORIZZAZIONE_NONE.equalsIgnoreCase(tipoAutorizzazione);
  4725.         this.msgContext.getIntegrazione().setTipoAutorizzazione(tipoAutorizzazione);
  4726.         if(tipoAutorizzazione!=null){
  4727.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_AUTORIZZAZIONE, tipoAutorizzazione);
  4728.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_AUTORIZZAZIONE_BUSTE, tipoAutorizzazione);
  4729.         }
  4730.         if(!isAttivoAutorizzazioneBuste){
  4731.             msgDiag.logPersonalizzato("autorizzazioneBusteDisabilitata");
  4732.         }

  4733.         DatiInvocazionePortaApplicativa datiInvocazione = null;
  4734.        
  4735.         if(isAttivoAutorizzazioneBuste &&
  4736.                 isMessaggioErroreProtocollo==false &&
  4737.                 bustaDiServizio==false &&
  4738.                 eccezioniValidazioni==false){  
  4739.            
  4740.             transaction.getTempiElaborazione().startAutorizzazione();
  4741.             try{

  4742.                 msgDiag.mediumDebug("Autorizzazione di tipo ["+tipoAutorizzazione+"]...");

  4743.                 //  Controllo Autorizzazione
  4744.                 String identitaMittente = null;
  4745.                 if(credenziali!=null && !soggettoAutenticato){
  4746.                     if(!"".equals(credenziali.toString())){
  4747.                         identitaMittente = credenziali.toString();
  4748.                         if(identitaMittente.endsWith(" ")){
  4749.                             identitaMittente = identitaMittente.substring(0, identitaMittente.length()-1);  
  4750.                         }
  4751.                     }
  4752.                 }
  4753.                 String subjectMessageSecurity = null;
  4754.                 if(messageSecurityContext!=null){
  4755.                     subjectMessageSecurity = messageSecurityContext.getSubject();
  4756.                 }



  4757.                 /* --- Calcolo idServizio e fruitore ---- */

  4758.                 IDServizio idServizioPerAutorizzazione = getIdServizioPerAutorizzazione(idServizio, soggettoFruitore, functionAsRouter, bustaRichiesta, ruoloBustaRicevuta);
  4759.                 IDSoggetto idSoggettoMittentePerAutorizzazione = getIDSoggettoMittentePerAutorizzazione(idServizio, soggettoFruitore, functionAsRouter, bustaRichiesta, ruoloBustaRicevuta, supportatoAutenticazioneSoggetti);
  4760.                 Soggetto soggettoMittentePerAutorizzazione = null;
  4761.                 if(idSoggettoMittentePerAutorizzazione!=null){
  4762.                     soggettoMittentePerAutorizzazione = registroServiziReader.getSoggetto(idSoggettoMittentePerAutorizzazione, null, requestInfo);
  4763.                 }

  4764.                 String tipoMessaggio = "messaggio";
  4765.                 if(ruoloBustaRicevuta!=null){
  4766.                     if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString()) || RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  4767.                         tipoMessaggio = "ricevuta asincrona";
  4768.                     }
  4769.                 }
  4770.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO_BUSTA, tipoMessaggio);
  4771.                 if(idSoggettoMittentePerAutorizzazione!=null){
  4772.                     msgDiag.addKeyword(CostantiPdD.KEY_MITTENTE_E_SERVIZIO_DA_AUTORIZZARE, "fruitore ["+idSoggettoMittentePerAutorizzazione.toString()+"] -> servizio ["+idServizioPerAutorizzazione.toString()+"]");
  4773.                 }
  4774.                 else{
  4775.                     msgDiag.addKeyword(CostantiPdD.KEY_MITTENTE_E_SERVIZIO_DA_AUTORIZZARE, "servizio ["+idServizioPerAutorizzazione.toString()+"]");
  4776.                 }
  4777.                 if(identitaMittente!=null)
  4778.                     msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_MITTENTE_MSG, " credenzialiMittente "+identitaMittente);
  4779.                 else
  4780.                     msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_MITTENTE_MSG, "");
  4781.                 if(servizioApplicativoFruitore!=null)
  4782.                     msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE_MSG, " identitaServizioApplicativoFruitore ["+servizioApplicativoFruitore+"]");
  4783.                 else
  4784.                     msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE_MSG, "");
  4785.                 if(subjectMessageSecurity!=null)
  4786.                     msgDiag.addKeyword(CostantiPdD.KEY_SUBJECT_MESSAGE_SECURITY_MSG, " subjectMessageSecurity ["+subjectMessageSecurity+"]");
  4787.                 else
  4788.                     msgDiag.addKeyword(CostantiPdD.KEY_SUBJECT_MESSAGE_SECURITY_MSG, "");
  4789.                 msgDiag.logPersonalizzato("autorizzazioneBusteInCorso");
  4790.                
  4791.                 IDServizioApplicativo identitaServizioApplicativoFruitore = new IDServizioApplicativo();
  4792.                 identitaServizioApplicativoFruitore.setNome(servizioApplicativoFruitore);
  4793.                 identitaServizioApplicativoFruitore.setIdSoggettoProprietario(idSoggettoMittentePerAutorizzazione);
  4794.                
  4795.                 datiInvocazione = new DatiInvocazionePortaApplicativa();
  4796.                 datiInvocazione.setBusta(bustaRichiesta);
  4797.                 datiInvocazione.setToken(token);
  4798.                 datiInvocazione.setPddContext(pddContext);
  4799.                 datiInvocazione.setInfoConnettoreIngresso(inRequestContext.getConnettore());
  4800.                 datiInvocazione.setIdServizio(idServizioPerAutorizzazione);
  4801.                 datiInvocazione.setState(openspcoopstate.getStatoRichiesta());
  4802.                 datiInvocazione.setCredenzialiPdDMittente(credenziali);
  4803.                 datiInvocazione.setIdentitaServizioApplicativoFruitore(identitaServizioApplicativoFruitore);
  4804.                 datiInvocazione.setSubjectServizioApplicativoFruitoreFromMessageSecurityHeader(subjectMessageSecurity);
  4805.                 datiInvocazione.setIdPA(idPA);
  4806.                 datiInvocazione.setPa(pa);
  4807.                 datiInvocazione.setIdPD(idPD);
  4808.                 datiInvocazione.setPd(pd);
  4809.                 datiInvocazione.setIdSoggettoFruitore(idSoggettoMittentePerAutorizzazione);
  4810.                 datiInvocazione.setSoggettoFruitore(soggettoMittentePerAutorizzazione);
  4811.                 datiInvocazione.setRuoloBusta(ruoloBustaRicevuta);
  4812.                
  4813.                 EsitoAutorizzazionePortaApplicativa esito =
  4814.                         GestoreAutorizzazione.verificaAutorizzazionePortaApplicativa(tipoAutorizzazione,
  4815.                                 datiInvocazione, pddContext, protocolFactory, requestMessage, logCore);
  4816.                 CostantiPdD.addKeywordInCache(msgDiag, esito.isEsitoPresenteInCache(),
  4817.                         pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE);
  4818.                 if(esito.getDetails()==null){
  4819.                     msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  4820.                 }else{
  4821.                     msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, " ("+esito.getDetails()+")");
  4822.                 }
  4823.                 if(esito.isAutorizzato()==false){
  4824.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  4825.                     String descrizioneErrore = null;
  4826.                     try{
  4827.                         if(esito.getErroreCooperazione()!=null){
  4828.                             descrizioneErrore = esito.getErroreCooperazione().getDescrizione(protocolFactory);
  4829.                         }
  4830.                         else{
  4831.                             descrizioneErrore = esito.getErroreIntegrazione().getDescrizione(protocolFactory);
  4832.                         }
  4833.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, descrizioneErrore);
  4834.                     }catch(Exception e){
  4835.                         logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  4836.                     }
  4837.                     msgDiag.addKeyword(CostantiPdD.KEY_POSIZIONE_ERRORE, traduttore.toString(esito.getErroreCooperazione().getCodiceErrore()));
  4838.                     msgDiag.logPersonalizzato("autorizzazioneBusteFallita");
  4839.                     String errorMsg =  "Riscontrato errore durante il processo di Autorizzazione per il messaggio con identificativo ["+bustaRichiesta.getID()+"]: "+descrizioneErrore;
  4840.                     if(esito.getEccezioneProcessamento()!=null){
  4841.                         logError(logCore, errorMsg,esito.getEccezioneProcessamento());
  4842.                     }
  4843.                     else{
  4844.                         logError(logCore, errorMsg);
  4845.                     }
  4846.                     if(this.msgContext.isGestioneRisposta()){
  4847.                        
  4848.                         if(esito.getErrorMessage()!=null) {
  4849.                             this.msgContext.setMessageResponse(esito.getErrorMessage());
  4850.                         }
  4851.                         else {
  4852.                        
  4853.                             OpenSPCoop2Message errorOpenSPCoopMsg = null;
  4854.                             parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4855.                             IntegrationFunctionError integrationFunctionError = esito.getIntegrationFunctionError();
  4856.                             if(esito.getErroreCooperazione()!=null){
  4857.                                 parametriGenerazioneBustaErrore.setErroreCooperazione(esito.getErroreCooperazione());
  4858.                                 if(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA.equals(esito.getErroreCooperazione().getCodiceErrore()) ||
  4859.                                         CodiceErroreCooperazione.SICUREZZA_FALSIFICAZIONE_MITTENTE.equals(esito.getErroreCooperazione().getCodiceErrore()) ||
  4860.                                         CodiceErroreCooperazione.SICUREZZA_TOKEN_AUTORIZZAZIONE_FALLITA.equals(esito.getErroreCooperazione().getCodiceErrore())){
  4861.                                     if(integrationFunctionError==null) {
  4862.                                         integrationFunctionError = IntegrationFunctionError.AUTHORIZATION;
  4863.                                     }
  4864.                                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  4865.                                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  4866.                                 }
  4867.                                 // Else necessario per Certificazione DigitPA tramite Router
  4868.                                 else if(CodiceErroreCooperazione.SERVIZIO_SCONOSCIUTO.equals(esito.getErroreCooperazione().getCodiceErrore())){
  4869.                                     parametriGenerazioneBustaErrore.setErroreCooperazione(
  4870.                                             ErroriCooperazione.SERVIZIO_SCONOSCIUTO.getErroreCooperazione()); // in modo da utilizzare la posizione standard.
  4871.                                     if(integrationFunctionError==null) {
  4872.                                         integrationFunctionError = IntegrationFunctionError.NOT_FOUND;
  4873.                                     }
  4874.                                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  4875.                                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  4876.                                 }
  4877.                                 else{
  4878.                                     if(integrationFunctionError==null) {
  4879.                                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  4880.                                     }
  4881.                                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  4882.                                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore, esito.getEccezioneProcessamento());
  4883.                                 }
  4884.                             }
  4885.                             else{
  4886.                                 parametriGenerazioneBustaErrore.setErroreIntegrazione(esito.getErroreIntegrazione());
  4887.                                 if(integrationFunctionError==null) {
  4888.                                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  4889.                                 }
  4890.                                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  4891.                                 errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore, esito.getEccezioneProcessamento());
  4892.                             }
  4893.                            
  4894.                             if(esito.getWwwAuthenticateErrorHeader()!=null) {
  4895.                                 errorOpenSPCoopMsg.forceTransportHeader(HttpConstants.AUTHORIZATION_RESPONSE_WWW_AUTHENTICATE, esito.getWwwAuthenticateErrorHeader());
  4896.                             }
  4897.    
  4898.                             // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4899.                             parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4900.                             parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4901.                             ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  4902.                            
  4903.                         }
  4904.                     }
  4905.                     openspcoopstate.releaseResource();
  4906.                     return;
  4907.                 }else{
  4908.                     msgDiag.logPersonalizzato("autorizzazioneBusteEffettuata");
  4909.                 }
  4910.             }catch(Exception e){
  4911.                 CostantiPdD.addKeywordInCache(msgDiag, false,
  4912.                         pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE);
  4913.                 msgDiag.logErroreGenerico(e,"AutorizzazioneMessaggio("+bustaRichiesta.getID()+")");
  4914.                 logError(logCore, "Riscontrato errore durante il processo di Autorizzazione per il messaggio con identificativo ["+bustaRichiesta.getID()+"]",e);
  4915.                 if(this.msgContext.isGestioneRisposta()){
  4916.                    
  4917.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  4918.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4919.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_504_AUTORIZZAZIONE));
  4920.                    
  4921.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);

  4922.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4923.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4924.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4925.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  4926.                 }
  4927.                 openspcoopstate.releaseResource();
  4928.                 return;
  4929.             }
  4930.             finally {
  4931.                 transaction.getTempiElaborazione().endAutorizzazione();
  4932.             }
  4933.         }







  4934.        
  4935.        
  4936.        
  4937.        
  4938.        
  4939.        
  4940.        
  4941.        
  4942.         /* --------------- Verifica tipo soggetto fruitore e tipo servizio rispetto al canale utilizzato
  4943.          * (NOTA!: non sportarlo prima senno non si supera eventuali certificazioni) --------------- */
  4944.         msgDiag.mediumDebug("Verifica canale utilizzato...");
  4945.         List<String> tipiSoggettiSupportatiCanale = protocolFactory.createProtocolConfiguration().getTipiSoggetti();
  4946.         List<String> tipiServiziSupportatiCanale = protocolFactory.createProtocolConfiguration().getTipiServizi(requestMessage.getServiceBinding());
  4947.         ErroreCooperazione erroreVerificaTipoByProtocol = null;
  4948.         // Nota: se qualche informazione e' null verranno segnalati altri errori
  4949.         if(soggettoFruitore!=null && soggettoFruitore.getTipo()!=null &&
  4950.                 !tipiSoggettiSupportatiCanale.contains(soggettoFruitore.getTipo())){
  4951.             if(autenticazioneOpzionale && !propertiesReader.isAutorizzazioneBustaAutenticazioneOpzionaleSoggettoFruitoreProfiloInteroperabilitaDifferenteServizioBloccaRichiesta()) {
  4952.                 msgDiag.logPersonalizzato("protocolli.tipoSoggetto.fruitore.unsupported.warning");
  4953.             }
  4954.             else {
  4955.                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL);
  4956.                 msgDiag.logPersonalizzato("protocolli.tipoSoggetto.fruitore.unsupported");
  4957.                 erroreVerificaTipoByProtocol = ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.getErroreCooperazione();
  4958.             }
  4959.         }
  4960.         else if(idServizio!=null && idServizio.getSoggettoErogatore()!=null && idServizio.getSoggettoErogatore().getTipo()!=null &&
  4961.                 !tipiSoggettiSupportatiCanale.contains(idServizio.getSoggettoErogatore().getTipo())){
  4962.             parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL);
  4963.             msgDiag.logPersonalizzato("protocolli.tipoSoggetto.erogatore.unsupported");
  4964.             erroreVerificaTipoByProtocol = ErroriCooperazione.TIPO_DESTINATARIO_NON_VALIDO.getErroreCooperazione();
  4965.         }
  4966.         else if(idServizio!=null && idServizio.getTipo()!=null &&
  4967.                 !tipiServiziSupportatiCanale.contains(idServizio.getTipo())){
  4968.             parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL);
  4969.             msgDiag.logPersonalizzato("protocolli.tipoServizio.unsupported");
  4970.             erroreVerificaTipoByProtocol = ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.getErroreCooperazione();
  4971.         }
  4972.         else if(idApplicativoToken!=null && idApplicativoToken.getIdSoggettoProprietario()!=null &&
  4973.                 idApplicativoToken.getIdSoggettoProprietario().getTipo()!=null &&
  4974.                 !tipiSoggettiSupportatiCanale.contains(idApplicativoToken.getIdSoggettoProprietario().getTipo())){
  4975.             parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL);
  4976.             msgDiag.logPersonalizzato("protocolli.tipoSoggetto.applicativoToken.unsupported");
  4977.             erroreVerificaTipoByProtocol = ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.getErroreCooperazione();
  4978.         }
  4979.            
  4980.         if(erroreVerificaTipoByProtocol!=null){
  4981.             if(this.msgContext.isGestioneRisposta()){

  4982.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);                          
  4983.                 parametriGenerazioneBustaErrore.setErroreCooperazione(erroreVerificaTipoByProtocol);

  4984.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  4985.                
  4986.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  4987.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  4988.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  4989.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  4990.             }
  4991.             openspcoopstate.releaseResource();
  4992.             return;
  4993.         }
  4994.        
  4995.        
  4996.        
  4997.        
  4998.        
  4999.        
  5000.        
  5001.        
  5002.        
  5003.        




  5004.         /* ------------ Validazione Contenuti Applicativi e Autorizzazione per Contenuto  ------------- */
  5005.         ValidazioneContenutiApplicativi validazioneContenutoApplicativoApplicativo = null;
  5006.         List<Proprieta> proprietaPorta = null;
  5007.         String tipoAutorizzazionePerContenuto = null;
  5008.         if(functionAsRouter == false &&
  5009.                 isMessaggioErroreProtocollo==false &&
  5010.                 erroriProcessamento.size()==0 && erroriValidazione.size()==0 &&
  5011.                 bustaDiServizio==false &&
  5012.                 pa!=null){
  5013.             msgDiag.mediumDebug("Controllo abilitazione validazione XSD della richiesta...");
  5014.             boolean isRicevutaAsincrona_modalitaAsincrona = false;
  5015.             try{


  5016.                 /* ----------- Identificazione profilo -------------- */
  5017.                 if(     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  5018.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) &&
  5019.                         (bustaRichiesta.getRiferimentoMessaggio()!=null) )
  5020.                 {
  5021.                     msgDiag.mediumDebug("Controllo abilitazione validazione XSD della richiesta (check asincrono)...");
  5022.                     // La validazione non deve essere effettuata se abbiamo una ricevuta asincrona, 'modalita' asincrona'

  5023.                     if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  

  5024.                         //  Richiesta Asincrona
  5025.                         if(bustaRichiesta.getRiferimentoMessaggio()==null){
  5026.                             validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pa,implementazionePdDMittente, true);
  5027.                             proprietaPorta = pa.getProprietaList();
  5028.                             tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pa);
  5029.                         }else{
  5030.                             //  Risposta Asincrona
  5031.                             if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  5032.                                 validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pd,implementazionePdDMittente, true);
  5033.                                 proprietaPorta = pd.getProprietaList();
  5034.                                 // NOTA: deve essere registrato un tipo di autorizzazione per contenuto busta uguale al tipo di autorizzazione utilizzato lato servizi applicativi.
  5035.                                 tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pd);
  5036.                             }
  5037.                             //  Ricevuta alla richiesta/risposta.
  5038.                             else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString()) ||
  5039.                                     RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){  
  5040.                                 if( configurazionePdDReader.ricevutaAsincronaSimmetricaAbilitata(pd))   {
  5041.                                     isRicevutaAsincrona_modalitaAsincrona = true;  
  5042.                                 }else{
  5043.                                     validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pd,implementazionePdDMittente, true);
  5044.                                     proprietaPorta = pd.getProprietaList();
  5045.                                     // NOTA: deve essere registrato un tipo di autorizzazione per contenuto busta uguale al tipo di autorizzazione utilizzato lato servizi applicativi.
  5046.                                     tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pd);
  5047.                                 }
  5048.                             }
  5049.                         }
  5050.                     }
  5051.                     // Profilo Asincrono Asimmetrico
  5052.                     else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {

  5053.                         //  Richiesta Asincrona
  5054.                         if(bustaRichiesta.getRiferimentoMessaggio()==null){
  5055.                             validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pa,implementazionePdDMittente, true);
  5056.                             proprietaPorta = pa.getProprietaList();
  5057.                             tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pa);
  5058.                         }else{
  5059.                             //  Risposta Asincrona
  5060.                             if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  5061.                                 validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pa,implementazionePdDMittente, true);
  5062.                                 proprietaPorta = pa.getProprietaList();
  5063.                                 tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pa);
  5064.                             }
  5065.                             // Ricevuta alla richiesta/risposta.
  5066.                             else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString()) ||
  5067.                                     RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){  
  5068.                                 if( configurazionePdDReader.ricevutaAsincronaAsimmetricaAbilitata(pd))  {
  5069.                                     isRicevutaAsincrona_modalitaAsincrona = true;  
  5070.                                 }else{
  5071.                                     validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pd,implementazionePdDMittente, true);
  5072.                                     proprietaPorta = pd.getProprietaList();
  5073.                                     // NOTA: deve essere registrato un tipo di autorizzazione per contenuto busta uguale al tipo di autorizzazione utilizzato lato servizi applicativi.
  5074.                                     tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pd);
  5075.                                 }
  5076.                             }
  5077.                         }
  5078.                     }
  5079.                     // Chiudo eventuali prepared statement, che non voglio eseguire.
  5080.                     ((StateMessage)openspcoopstate.getStatoRichiesta()).closePreparedStatement();
  5081.                 }else{
  5082.                     msgDiag.mediumDebug("Controllo abilitazione validazione dei contenuti applicativi della richiesta...");
  5083.                     validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(pa,implementazionePdDMittente, true);
  5084.                     proprietaPorta = pa.getProprietaList();
  5085.                     tipoAutorizzazionePerContenuto = configurazionePdDReader.getAutorizzazioneContenuto(pa);
  5086.                 }
  5087.             }catch(Exception e){
  5088.                 msgDiag.logErroreGenerico(e,"getTipoValidazione/Autorizzazione ContenutoApplicativo");
  5089.                 if(this.msgContext.isGestioneRisposta()){
  5090.                    
  5091.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5092.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5093.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));
  5094.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5095.                    
  5096.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5097.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5098.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5099.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5100.                 }
  5101.                 openspcoopstate.releaseResource();
  5102.                 return;
  5103.             }
  5104.             if(isRicevutaAsincrona_modalitaAsincrona==false){

  5105.                 if(validazioneContenutoApplicativoApplicativo!=null && validazioneContenutoApplicativoApplicativo.getTipo()!=null){
  5106.                     String tipo = ValidatoreMessaggiApplicativi.getTipo(validazioneContenutoApplicativoApplicativo);
  5107.                     this.msgContext.getIntegrazione().setTipoValidazioneContenuti(tipo);
  5108.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_CONTENUTI, tipo);
  5109.                     msgDiag.addKeyword(CostantiPdD.KEY_DETAILS_VALIDAZIONE_CONTENUTI,"");
  5110.                 }
  5111.                
  5112.                 // VALIDAZIONE CONTENUTI APPLICATIVI
  5113.                
  5114.                 if(
  5115.                         (validazioneContenutoApplicativoApplicativo!=null)
  5116.                         &&
  5117.                         (
  5118.                                 CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(validazioneContenutoApplicativoApplicativo.getStato())
  5119.                                 ||
  5120.                                 CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())
  5121.                         )
  5122.                     ){
  5123.                
  5124.                     transaction.getTempiElaborazione().startValidazioneRichiesta();
  5125.                     ByteArrayInputStream binXSD = null;
  5126.                     try{
  5127.                                                
  5128.                         msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaInCorso");
  5129.                        
  5130.                         boolean readInterface = CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo());
  5131.                                
  5132.                         if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())){
  5133.                        
  5134.                             // Accept mtom message
  5135.                             List<MtomXomReference> xomReferences = null;
  5136.                             if(StatoFunzionalita.ABILITATO.equals(validazioneContenutoApplicativoApplicativo.getAcceptMtomMessage())){
  5137.                                 msgDiag.mediumDebug("Validazione xsd della richiesta (mtomFastUnpackagingForXSDConformance)...");
  5138.                                 if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())==false){
  5139.                                     throw new Exception("Funzionalita 'AcceptMtomMessage' valida solamente per Service Binding SOAP");
  5140.                                 }
  5141.                                 xomReferences = requestMessage.castAsSoap().mtomFastUnpackagingForXSDConformance();
  5142.                             }
  5143.                            
  5144.                             // Init Validatore
  5145.                             msgDiag.mediumDebug("Validazione della richiesta (initValidator)...");
  5146.                             ValidatoreMessaggiApplicativi validatoreMessaggiApplicativi =
  5147.                                 new ValidatoreMessaggiApplicativi(registroServiziReader,idServizio,requestMessage,readInterface,
  5148.                                         propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione(),
  5149.                                         proprietaPorta,
  5150.                                         pddContext);
  5151.    
  5152.                             // Validazione WSDL
  5153.                             if( CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  5154.                                     ||
  5155.                                     CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  5156.                             ){
  5157.                                 msgDiag.mediumDebug("Validazione wsdl della richiesta ...");
  5158.                                 validatoreMessaggiApplicativi.validateWithWsdlLogicoImplementativo(true);
  5159.                             }
  5160.                            
  5161.                             // Validazione XSD
  5162.                             msgDiag.mediumDebug("Validazione xsd della richiesta (validazione)...");
  5163.                             validatoreMessaggiApplicativi.validateWithWsdlDefinitorio(true);
  5164.                                                    
  5165.                             // Validazione WSDL (Restore Original Document)
  5166.                             if (CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  5167.                                 || CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutoApplicativoApplicativo.getTipo())) {
  5168.                                 if(propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione() &&
  5169.                                         propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione()){
  5170.                                     msgDiag.mediumDebug("Ripristino elementi modificati per supportare validazione wsdl della richiesta ...");
  5171.                                     validatoreMessaggiApplicativi.restoreOriginalDocument(true);
  5172.                                 }
  5173.                             }
  5174.                            
  5175.                             // Ripristino struttura messaggio con xom
  5176.                             if(xomReferences!=null && xomReferences.size()>0){
  5177.                                 msgDiag.mediumDebug("Validazione xsd della richiesta (mtomRestoreAfterXSDConformance)...");
  5178.                                 if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())==false){
  5179.                                     throw new Exception("Funzionalita 'AcceptMtomMessage' valida solamente per Service Binding SOAP");
  5180.                                 }
  5181.                                 requestMessage.castAsSoap().mtomRestoreAfterXSDConformance(xomReferences);
  5182.                             }
  5183.                            
  5184.                         }
  5185.                         else {
  5186.                            
  5187.                             // Init Validatore
  5188.                             msgDiag.mediumDebug("Validazione della richiesta (initValidator)...");
  5189.                             ValidatoreMessaggiApplicativiRest validatoreMessaggiApplicativi =
  5190.                                 new ValidatoreMessaggiApplicativiRest(registroServiziReader, idServizio, requestMessage, readInterface, proprietaPorta,
  5191.                                         protocolFactory, pddContext);
  5192.                            
  5193.                             if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(validazioneContenutoApplicativoApplicativo.getTipo()) &&
  5194.                                     requestMessage.castAsRest().hasContent()) {
  5195.                                
  5196.                                 // Validazione XSD
  5197.                                 msgDiag.mediumDebug("Validazione xsd della richiesta ...");
  5198.                                 validatoreMessaggiApplicativi.validateWithSchemiXSD(true);
  5199.                                
  5200.                             }
  5201.                             else {
  5202.                                
  5203.                                 // Validazione Interface
  5204.                                 validatoreMessaggiApplicativi.validateRequestWithInterface(true);
  5205.                                
  5206.                             }
  5207.                            
  5208.                         }
  5209.                        
  5210.                         msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaEffettuata");
  5211.    
  5212.                     }catch(ValidatoreMessaggiApplicativiException ex){
  5213.                         msgDiag.addKeywordErroreProcessamento(ex);
  5214.                         logError(logCore, "[ValidazioneContenutiApplicativi Richiesta] "+ex.getMessage(),ex);
  5215.                         if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())) {
  5216.                             msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita.warningOnly");
  5217.                         }
  5218.                         else {
  5219.                             msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita");
  5220.                         }
  5221.                         if(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato()) == false){
  5222.                            
  5223.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_RICHIESTA, "true");
  5224.                            
  5225.                             // validazione abilitata
  5226.                             if(this.msgContext.isGestioneRisposta()){
  5227.                                
  5228.                                 IntegrationFunctionError integrationFunctionError = null;
  5229.                                 if(ex.getErrore()!=null &&
  5230.                                         (
  5231.                                                 //CodiceErroreIntegrazione.CODICE_417_COSTRUZIONE_VALIDATORE_TRAMITE_INTERFACCIA_FALLITA.equals(ex.getErrore().getCodiceErrore()) ||
  5232.                                                 CodiceErroreIntegrazione.CODICE_418_VALIDAZIONE_RICHIESTA_TRAMITE_INTERFACCIA_FALLITA.equals(ex.getErrore().getCodiceErrore())
  5233.                                         )
  5234.                                     ){
  5235.                                     integrationFunctionError = IntegrationFunctionError.INVALID_REQUEST_CONTENT;
  5236.                                 }
  5237.                                 else{
  5238.                                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  5239.                                 }
  5240.                                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  5241.                                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5242.                                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ex.getErrore());
  5243.                                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,ex);
  5244.                                
  5245.                                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5246.                                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5247.                                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5248.                                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5249.                             }
  5250.                             openspcoopstate.releaseResource();
  5251.                             return;
  5252.                         }
  5253.                     }catch(Exception ex){
  5254.                         msgDiag.addKeywordErroreProcessamento(ex);
  5255.                         logError(logCore, "Riscontrato errore durante la validazione dei contenuti applicativi (richiesta applicativa)",ex);
  5256.                         if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())) {
  5257.                             msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita.warningOnly");
  5258.                         }
  5259.                         else {
  5260.                             msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita");
  5261.                         }
  5262.                         if(CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato()) == false){
  5263.                            
  5264.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_RICHIESTA, "true");
  5265.                            
  5266.                             // validazione abilitata
  5267.                             if(this.msgContext.isGestioneRisposta()){
  5268.                                
  5269.                                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5270.                                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5271.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_531_VALIDAZIONE_TRAMITE_INTERFACCIA_FALLITA));
  5272.    
  5273.                                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,ex);
  5274.                                
  5275.                                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5276.                                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5277.                                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5278.                                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5279.                             }
  5280.                             openspcoopstate.releaseResource();
  5281.                             return;
  5282.                         }
  5283.                     }finally{
  5284.                         transaction.getTempiElaborazione().endValidazioneRichiesta();
  5285.                         if(binXSD!=null){
  5286.                             try{
  5287.                                 binXSD.close();
  5288.                             }catch(Exception e){
  5289.                                 // ignore
  5290.                             }
  5291.                         }
  5292.                     }
  5293.                 }
  5294.                 else{
  5295.                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaDisabilitata");
  5296.                 }
  5297.             }
  5298.            
  5299.            
  5300.            
  5301.             // AUTORIZZAZIONE PER CONTENUTO
  5302.             this.msgContext.getIntegrazione().setTipoAutorizzazioneContenuto(tipoAutorizzazionePerContenuto);
  5303.             if(tipoAutorizzazionePerContenuto!=null){
  5304.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_AUTORIZZAZIONE_CONTENUTO, tipoAutorizzazionePerContenuto);
  5305.             }
  5306.             if (CostantiConfigurazione.AUTORIZZAZIONE_NONE.equalsIgnoreCase(tipoAutorizzazionePerContenuto) == false) {
  5307.                
  5308.                 transaction.getTempiElaborazione().startAutorizzazioneContenuti();
  5309.                 try {
  5310.                    
  5311.                     String identitaMittente = null;
  5312.                     if(credenziali!=null && !soggettoAutenticato){
  5313.                         if(!"".equals(credenziali.toString())){
  5314.                             identitaMittente = credenziali.toString();
  5315.                             if(identitaMittente.endsWith(" ")){
  5316.                                 identitaMittente = identitaMittente.substring(0, identitaMittente.length()-1);  
  5317.                             }
  5318.                         }
  5319.                     }
  5320.                     String subjectMessageSecurity = null;
  5321.                     if(messageSecurityContext!=null){
  5322.                         subjectMessageSecurity = messageSecurityContext.getSubject();
  5323.                     }
  5324.                    
  5325.                     IDServizio idServizioPerAutorizzazione = getIdServizioPerAutorizzazione(idServizio, soggettoFruitore, functionAsRouter, bustaRichiesta, ruoloBustaRicevuta);
  5326.                     IDSoggetto idSoggettoMittentePerAutorizzazione = getIDSoggettoMittentePerAutorizzazione(idServizio, soggettoFruitore, functionAsRouter, bustaRichiesta, ruoloBustaRicevuta, supportatoAutenticazioneSoggetti);
  5327.                     Soggetto soggettoMittentePerAutorizzazione = null;
  5328.                     if(idSoggettoMittentePerAutorizzazione!=null){
  5329.                         soggettoMittentePerAutorizzazione = registroServiziReader.getSoggetto(idSoggettoMittentePerAutorizzazione, null, requestInfo);
  5330.                     }
  5331.                    
  5332.                     String tipoMessaggio = "messaggio";
  5333.                     if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString()) || RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  5334.                         tipoMessaggio = "ricevuta asincrona";
  5335.                     }
  5336.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_MESSAGGIO_BUSTA, tipoMessaggio);
  5337.                     if(idSoggettoMittentePerAutorizzazione!=null){
  5338.                         msgDiag.addKeyword(CostantiPdD.KEY_MITTENTE_E_SERVIZIO_DA_AUTORIZZARE, "fruitore ["+idSoggettoMittentePerAutorizzazione.toString()+"] -> servizio ["+idServizioPerAutorizzazione.toString()+"]");
  5339.                     }
  5340.                     else{
  5341.                         msgDiag.addKeyword(CostantiPdD.KEY_MITTENTE_E_SERVIZIO_DA_AUTORIZZARE, "servizio ["+idServizioPerAutorizzazione.toString()+"]");
  5342.                     }
  5343.                     if(identitaMittente!=null)
  5344.                         msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_MITTENTE_MSG, " credenzialiMittente "+identitaMittente);
  5345.                     else
  5346.                         msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_MITTENTE_MSG, "");
  5347.                     if(servizioApplicativoFruitore!=null)
  5348.                         msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE_MSG, " identitaServizioApplicativoFruitore ["+servizioApplicativoFruitore+"]");
  5349.                     else
  5350.                         msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE_MSG, "");
  5351.                     if(subjectMessageSecurity!=null)
  5352.                         msgDiag.addKeyword(CostantiPdD.KEY_SUBJECT_MESSAGE_SECURITY_MSG, " subjectMessageSecurity ["+subjectMessageSecurity+"]");
  5353.                     else
  5354.                         msgDiag.addKeyword(CostantiPdD.KEY_SUBJECT_MESSAGE_SECURITY_MSG, "");
  5355.                     msgDiag.logPersonalizzato("autorizzazioneContenutiBusteInCorso");
  5356.                    
  5357.                     if(datiInvocazione==null){
  5358.                        
  5359.                         IDServizioApplicativo identitaServizioApplicativoFruitore = new IDServizioApplicativo();
  5360.                         identitaServizioApplicativoFruitore.setNome(servizioApplicativoFruitore);
  5361.                         identitaServizioApplicativoFruitore.setIdSoggettoProprietario(idSoggettoMittentePerAutorizzazione);
  5362.                        
  5363.                         datiInvocazione = new DatiInvocazionePortaApplicativa();
  5364.                         datiInvocazione.setBusta(bustaRichiesta);
  5365.                         datiInvocazione.setToken(token);
  5366.                         datiInvocazione.setPddContext(pddContext);
  5367.                         datiInvocazione.setInfoConnettoreIngresso(inRequestContext.getConnettore());
  5368.                         datiInvocazione.setIdServizio(idServizioPerAutorizzazione);
  5369.                         datiInvocazione.setState(openspcoopstate.getStatoRichiesta());
  5370.                         datiInvocazione.setCredenzialiPdDMittente(credenziali);
  5371.                         datiInvocazione.setIdentitaServizioApplicativoFruitore(identitaServizioApplicativoFruitore);
  5372.                         datiInvocazione.setSubjectServizioApplicativoFruitoreFromMessageSecurityHeader(subjectMessageSecurity);
  5373.                         datiInvocazione.setIdPA(idPA);
  5374.                         datiInvocazione.setPa(pa);
  5375.                         datiInvocazione.setIdPD(idPD);
  5376.                         datiInvocazione.setPd(pd);
  5377.                         datiInvocazione.setIdSoggettoFruitore(idSoggettoMittentePerAutorizzazione);
  5378.                         datiInvocazione.setSoggettoFruitore(soggettoMittentePerAutorizzazione);
  5379.                         datiInvocazione.setRuoloBusta(ruoloBustaRicevuta);
  5380.                     }
  5381.                    
  5382.                     // Controllo Autorizzazione
  5383.                     EsitoAutorizzazionePortaApplicativa esito =
  5384.                             GestoreAutorizzazione.verificaAutorizzazioneContenutoPortaApplicativa(tipoAutorizzazionePerContenuto, datiInvocazione, pddContext, protocolFactory, requestMessage, logCore);
  5385.                     CostantiPdD.addKeywordInCache(msgDiag, esito.isEsitoPresenteInCache(),
  5386.                             pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE_CONTENUTI);
  5387.                     if(esito.getDetails()==null){
  5388.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  5389.                     }else{
  5390.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, " ("+esito.getDetails()+")");
  5391.                     }
  5392.                     if(esito.isAutorizzato()==false){
  5393.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  5394.                         try{
  5395.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, esito.getErroreCooperazione().getDescrizione(protocolFactory));
  5396.                         }catch(Exception e){
  5397.                             logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  5398.                         }
  5399.                         msgDiag.addKeyword(CostantiPdD.KEY_POSIZIONE_ERRORE, traduttore.toString(esito.getErroreCooperazione().getCodiceErrore()));
  5400.                         msgDiag.logPersonalizzato("autorizzazioneContenutiBusteFallita");
  5401.                         if(this.msgContext.isGestioneRisposta()){
  5402.                             OpenSPCoop2Message errorMsg = null;
  5403.                             parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5404.                             parametriGenerazioneBustaErrore.setErroreCooperazione(esito.getErroreCooperazione());
  5405.                             IntegrationFunctionError integrationFunctionError = esito.getIntegrationFunctionError();
  5406.                             if(CodiceErroreCooperazione.SICUREZZA_AUTORIZZAZIONE_FALLITA.equals(esito.getErroreCooperazione().getCodiceErrore())
  5407.                                     || CodiceErroreCooperazione.SICUREZZA_FALSIFICAZIONE_MITTENTE.equals(esito.getErroreCooperazione().getCodiceErrore())){
  5408.                                 if(integrationFunctionError==null) {
  5409.                                     integrationFunctionError = IntegrationFunctionError.CONTENT_AUTHORIZATION_DENY;
  5410.                                 }
  5411.                                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  5412.                                 errorMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  5413.                             }
  5414.                             else{
  5415.                                 if(integrationFunctionError==null) {
  5416.                                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  5417.                                 }
  5418.                                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(integrationFunctionError);
  5419.                                 errorMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,esito.getEccezioneProcessamento());
  5420.                             }

  5421.                             // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5422.                             parametriInvioBustaErrore.setOpenspcoopMsg(errorMsg);
  5423.                             parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5424.                             ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5425.                         }
  5426.                        
  5427.                         openspcoopstate.releaseResource();
  5428.                         return;
  5429.                     }else{
  5430.                         msgDiag.logPersonalizzato("autorizzazioneContenutiBusteEffettuata");
  5431.                     }

  5432.                 }catch(Exception ex){
  5433.                     CostantiPdD.addKeywordInCache(msgDiag, false,
  5434.                             pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE_CONTENUTI);
  5435.                     msgDiag.logErroreGenerico(ex,"AutorizzazioneContenuto Messaggio("+bustaRichiesta.getID()+")");
  5436.                     logError(logCore, "Riscontrato errore durante il processo di Autorizzazione del Contenuto per il messaggio con identificativo ["+bustaRichiesta.getID()+"]",ex);
  5437.                     if(this.msgContext.isGestioneRisposta()){
  5438.                        
  5439.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5440.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5441.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_542_AUTORIZZAZIONE_CONTENUTO));
  5442.                         OpenSPCoop2Message errorMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,ex);

  5443.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5444.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorMsg);
  5445.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5446.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5447.                     }
  5448.                     openspcoopstate.releaseResource();
  5449.                     return;
  5450.                 }
  5451.                 finally {
  5452.                     transaction.getTempiElaborazione().endAutorizzazioneContenuti();
  5453.                 }
  5454.             }
  5455.             else{
  5456.                 msgDiag.logPersonalizzato("autorizzazioneContenutiBusteDisabilitata");
  5457.             }
  5458.         }



  5459.        







  5460.         Utilities.printFreeMemory("RicezioneBuste - Recupero configurazione per salvataggio risposta in cache ...");
  5461.         msgDiag.mediumDebug("Recupero configurazione per salvataggio risposta in cache ...");
  5462.         try{
  5463.             ResponseCachingConfigurazione responseCachingConfig = null;
  5464.             if(pa!=null) {
  5465.                 responseCachingConfig = configurazionePdDReader.getConfigurazioneResponseCaching(pa);
  5466.             }
  5467.             else {
  5468.                 responseCachingConfig = configurazionePdDReader.getConfigurazioneResponseCaching();
  5469.             }
  5470.             if(responseCachingConfig!=null && StatoFunzionalita.ABILITATO.equals(responseCachingConfig.getStato())) {
  5471.                
  5472.                 transaction.getTempiElaborazione().startResponseCachingCalcoloDigest();
  5473.                 try {
  5474.                
  5475.                     msgDiag.mediumDebug("Calcolo digest per salvataggio risposta ...");
  5476.                    
  5477.                     HashGenerator hashGenerator = new HashGenerator(propertiesReader.getCachingResponseDigestAlgorithm());
  5478.                     String digest = hashGenerator.buildKeyCache(requestMessage, requestInfo, responseCachingConfig);
  5479.                     requestMessage.addContextProperty(CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST, digest);
  5480.                
  5481.                 }finally {
  5482.                     transaction.getTempiElaborazione().endResponseCachingCalcoloDigest();
  5483.                 }
  5484.             }
  5485.         } catch (Exception e){
  5486.             msgDiag.logErroreGenerico(e,"calcoloDigestSalvataggioRisposta");
  5487.             logError(logCore, "Calcolo Digest Salvataggio Risposta non riuscito: "  + e);
  5488.             if (this.msgContext.isGestioneRisposta()) {
  5489.                
  5490.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5491.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5492.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_561_DIGEST_REQUEST));

  5493.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5494.                
  5495.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5496.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5497.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5498.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5499.             }
  5500.             openspcoopstate.releaseResource();
  5501.             return;
  5502.         }
  5503.        
  5504.        
  5505.        
  5506.        





  5507.         /* ------------- Modalita' di gestione ---------------------------- */
  5508.         try {
  5509.             if ( oneWayStateless || sincronoStateless || asincronoStateless || oneWayVersione11 || routingStateless ) {
  5510.                 openspcoopstate = OpenSPCoopState.toStateless(((OpenSPCoopStateful)openspcoopstate), true);
  5511.                 parametriGenerazioneBustaErrore.setOpenspcoop(openspcoopstate);
  5512.                 parametriInvioBustaErrore.setOpenspcoop(openspcoopstate);
  5513.             }
  5514.         } catch (Exception e) {
  5515.             msgDiag.logErroreGenerico(e,"OpenSPCoopState.toStateless");
  5516.             logError(logCore, "Creazione stato STATEFUL/STATELESS non riuscita: "   + e);
  5517.             if (this.msgContext.isGestioneRisposta()) {
  5518.                
  5519.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5520.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5521.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));

  5522.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5523.                
  5524.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5525.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5526.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5527.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5528.             }
  5529.             openspcoopstate.releaseResource();
  5530.             return;
  5531.         }
















  5532.         /* -------- Gestione Richiesta ---------- */
  5533.         String tipoMsg = Costanti.INBOX;
  5534.         if(functionAsRouter)
  5535.             tipoMsg = Costanti.OUTBOX;
  5536.         GestoreMessaggi msgRequest = new GestoreMessaggi(openspcoopstate, true, idMessageRequest, tipoMsg,msgDiag, inRequestContext.getPddContext());
  5537.         msgRequest.setOneWayVersione11(oneWayVersione11);
  5538.         msgRequest.setRoutingStateless(routingStateless);
  5539.         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true, protocolFactory);














  5540.         /* ------------
  5541.        Controllo di non aver gia' registrato la richiesta
  5542.        (se non l'ho registrata, non significa che non l'abbia gia' ricevuta, puo' darsi che l'abbia ricevuta
  5543.        e gia' completata di elaborare.
  5544.        Il controllo dell'history in Sbustamento effettuera' poi questo controllo e generera' un eventuale riscontro)
  5545.        L'unico caso in cui posso ricevere piu' di una copia di una busta dovrebbe avvenire con profili asincroni in modalita asincrona
  5546.        e con profili oneWay. In questo caso se ricevo una busta che sto gia' processando gestisco il caso particolare.
  5547.        Negli altri casi emetto anche un messaggio Errore di msg gia ricevuto.
  5548.        ------------
  5549.          */
  5550.         msgDiag.mediumDebug("Controllo presenza del messaggio gia' in gestione...");
  5551.         if( (!functionAsRouter) || (!routingStateless) ){
  5552.             try{
  5553.                 if(  msgRequest.existsMessage_noCache() ){

  5554.                     // Se il proprietario attuale e' GestoreMessaggi, forzo l'eliminazione e continuo a processare il messaggio.
  5555.                     String proprietarioMessaggio = msgRequest.getProprietario(this.msgContext.getIdModulo());
  5556.                     if(TimerGestoreMessaggi.ID_MODULO.equals(proprietarioMessaggio)){
  5557.                         msgDiag.logPersonalizzato("messaggioInGestione.marcatoDaEliminare");
  5558.                         String msg = msgDiag.getMessaggio_replaceKeywords("messaggioInGestione.marcatoDaEliminare");
  5559.                         if(propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  5560.                             msgRequest._deleteMessageWithLock(msg,propertiesReader.getMsgGiaInProcessamentoAttesaAttiva(),
  5561.                                 propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  5562.                         }
  5563.                         else {
  5564.                             msgRequest.deleteMessageByNow();
  5565.                         }
  5566.                     }

  5567.                     // Altrimenti gestisco il duplicato
  5568.                     else{

  5569.                         boolean rispostaModalitaSincrona = org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  5570.                         (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) && configurazionePdDReader.ricevutaAsincronaSimmetricaAbilitata(pa)) ||
  5571.                         (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) && configurazionePdDReader.ricevutaAsincronaAsimmetricaAbilitata(pa));

  5572.                         // Se la modalita e' sincrona non deve essere possibile ricevere una busta due volte con lo stesso identificativo
  5573.                         if(rispostaModalitaSincrona){
  5574.                             msgDiag.addKeyword(CostantiPdD.KEY_PROPRIETARIO_MESSAGGIO, proprietarioMessaggio);
  5575.                             msgDiag.logPersonalizzato("messaggioInGestione.gestioneSincrona");
  5576.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.RICHIESTA_DUPLICATA, "true");
  5577.                             if(this.msgContext.isGestioneRisposta()){
  5578.                                
  5579.                                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5580.                                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_537_BUSTA_GIA_RICEVUTA.get537_BustaGiaRicevuta(idMessageRequest));
  5581.                                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.CONFLICT_IN_QUEUE);
  5582.                                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,null);
  5583.                                
  5584.                                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5585.                                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5586.                                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5587.                                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5588.                             }
  5589.                             openspcoopstate.releaseResource();
  5590.                             return;
  5591.                         }

  5592.                         else{
  5593.                             // gestione risposta gia presente
  5594.                             // se profiloTrasmissione=ALPIUUNAVOLTA
  5595.                             //     Se il proprietario attuale e' il modulo consegna contenuti applicativi posso ritornare un soap vuoto, (o riscontro/ricevuta a seconda del profilo)
  5596.                             //     Altrimenti provo ad aspettare un tempo ragionevole e ogni tanto rileggo il proprietario. Non appena raggiunge il modulo consegna contenuti applicativi
  5597.                             //     posso ritornare un soap vuoto (o riscontro/ricevuta a seconda del profilo)
  5598.                             // altrimenti provo ad aspettare che il messaggio non esista piu' o abbia cmq come proprietario GestoreMessaggi per poi eliminarlo.
  5599.                             //
  5600.                             // Se scade il timeout cmq genero un errore di busta gia' in gestione.
  5601.                             msgDiag.addKeyword(CostantiPdD.KEY_PROPRIETARIO_MESSAGGIO, proprietarioMessaggio);
  5602.                             msgDiag.logPersonalizzato("messaggioInGestione.gestioneAsincrona");
  5603.                             long scadenzaWhile = DateManager.getTimeMillis() + propertiesReader.getMsgGiaInProcessamentoAttesaAttiva();
  5604.                             boolean isErroreMsgGiaRicevuto = true;
  5605.                             boolean msgAttesaFineProcessamento = false;
  5606.                             int millisecondiTrascorsi = 0;
  5607.                             while( DateManager.getTimeMillis() < scadenzaWhile  ){

  5608.                                 proprietarioMessaggio = msgRequest.getProprietario(this.msgContext.getIdModulo());

  5609.                                 if( (Inoltro.SENZA_DUPLICATI.equals(bustaRichiesta.getInoltro())) ||
  5610.                                         (this.msgContext.isForzaFiltroDuplicati_msgGiaInProcessamento())  ){

  5611.                                     // Se sono entrato in questo controllo vuole dire che prima esisteva un msg che aveva come proprietario Sbustamento o RicezioneBuste.
  5612.                                     // Quindi se ho raggiunto ConsegnaContenutiApplicativi, GestoreMessaggi o non esiste piu' il messaggio, vuole dire che e' stato elaborato.
  5613.                                     if(ConsegnaContenutiApplicativi.ID_MODULO.equals(proprietarioMessaggio) ||
  5614.                                             TimerGestoreMessaggi.ID_MODULO.equals(proprietarioMessaggio) ||
  5615.                                             (!msgRequest.existsMessage_noCache()) ){
  5616.                                        
  5617.                                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.RICHIESTA_DUPLICATA, "true");
  5618.                                        
  5619.                                         if(this.msgContext.isGestioneRisposta()){
  5620.                                             this.msgContext.setMessageResponse(ricezioneBusteGeneratoreBustaErrore.generaRispostaMsgGiaRicevuto(!this.msgContext.isForzaFiltroDuplicati_msgGiaInProcessamento(),
  5621.                                                     bustaRichiesta,infoIntegrazione, msgDiag, openspcoopstate, logCore, propertiesReader,
  5622.                                                     versioneProtocollo,ruoloBustaRicevuta,implementazionePdDMittente,protocolFactory,
  5623.                                                     identitaPdD,idTransazione,loader,oneWayVersione11,implementazionePdDMittente,
  5624.                                                     tracciamento,
  5625.                                                     correlazioneApplicativa,
  5626.                                                     pddContext, IntegrationFunctionError.CONFLICT));
  5627.                                         }
  5628.                                         openspcoopstate.releaseResource();
  5629.                                         return;
  5630.                                     }

  5631.                                     if(!msgAttesaFineProcessamento){
  5632.                                         msgDiag.addKeyword(CostantiPdD.KEY_TIMEOUT, ""+(propertiesReader.getMsgGiaInProcessamentoAttesaAttiva()/1000));
  5633.                                         msgDiag.logPersonalizzato("messaggioInGestione.attesaFineProcessamento.filtroDuplicatiAbilitato");
  5634.                                         msgAttesaFineProcessamento = true;
  5635.                                     }

  5636.                                 }else{

  5637.                                     if(!msgAttesaFineProcessamento){
  5638.                                         msgDiag.addKeyword(CostantiPdD.KEY_TIMEOUT, ""+(propertiesReader.getMsgGiaInProcessamentoAttesaAttiva()/1000));
  5639.                                         msgDiag.logPersonalizzato("messaggioInGestione.attesaFineProcessamento.filtroDuplicatiDisabilitato");
  5640.                                         msgAttesaFineProcessamento = true;
  5641.                                     }

  5642.                                     boolean existsMessage = msgRequest.existsMessage_noCache();
  5643.                                     if(existsMessage==false){
  5644.                                         msgDiag.logPersonalizzato("messaggioInGestione.attesaFineProcessamento.filtroDuplicatiDisabilitato.attesaTerminata");
  5645.                                         isErroreMsgGiaRicevuto = false;
  5646.                                         break;
  5647.                                     }

  5648.                                     if(TimerGestoreMessaggi.ID_MODULO.equals(proprietarioMessaggio)){
  5649.                                         msgDiag.logPersonalizzato("messaggioInGestione.attesaFineProcessamento.filtroDuplicatiDisabilitato.forzoEliminazione");
  5650.                                         String msg = msgDiag.getMessaggio_replaceKeywords("messaggioInGestione.attesaFineProcessamento.filtroDuplicatiDisabilitato.forzoEliminazione");
  5651.                                         if(propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  5652.                                             msgRequest._deleteMessageWithLock(msg,propertiesReader.getMsgGiaInProcessamentoAttesaAttiva()-millisecondiTrascorsi,
  5653.                                                     propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  5654.                                         }
  5655.                                         else {
  5656.                                             msgRequest.deleteMessageByNow();
  5657.                                         }
  5658.                                         isErroreMsgGiaRicevuto = false;
  5659.                                         break;
  5660.                                     }

  5661.                                 }

  5662.                                 Utilities.sleep(propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  5663.                                 millisecondiTrascorsi = millisecondiTrascorsi + propertiesReader.getMsgGiaInProcessamentoCheckInterval();

  5664.                             }
  5665.                             if(isErroreMsgGiaRicevuto){
  5666.                                 msgDiag.logPersonalizzato("messaggioInGestione.attesaFineProcessamento.timeoutScaduto");
  5667.                                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.RICHIESTA_DUPLICATA, "true");
  5668.                                 if(this.msgContext.isGestioneRisposta()){
  5669.                                    
  5670.                                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5671.                                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_537_BUSTA_GIA_RICEVUTA.get537_BustaGiaRicevuta(idMessageRequest));
  5672.                                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.CONFLICT_IN_QUEUE);
  5673.                                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,null);
  5674.                                    
  5675.                                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5676.                                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5677.                                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5678.                                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore,false);
  5679.                                 }
  5680.                                 openspcoopstate.releaseResource();
  5681.                                 return;
  5682.                             }
  5683.                         }
  5684.                     }
  5685.                 }
  5686.             }catch(Exception e){
  5687.                 msgDiag.logErroreGenerico(e,"ControlloPresenzaMessaggioGiaInGestione");
  5688.                 logError(logCore, "Controllo/gestione presenza messaggio gia in gestione non riuscito",e);
  5689.                 if(this.msgContext.isGestioneRisposta()){
  5690.                    
  5691.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5692.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5693.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));

  5694.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5695.                    
  5696.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5697.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5698.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5699.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5700.                 }
  5701.                 openspcoopstate.releaseResource();
  5702.                 return;
  5703.             }
  5704.         }





















  5705.         /* ----------------   Creo sessione di gestione del messaggio ricevuto  --------------------- */
  5706.         msgDiag.mediumDebug("Registrazione messaggio di richiesta nel RepositoryMessaggi...");
  5707.         try{
  5708.             msgRequest.registraMessaggio(requestMessage,dataIngressoRichiesta,
  5709.                     (oneWayStateless || sincronoStateless || asincronoStateless || routingStateless),
  5710.                     correlazioneApplicativa);
  5711.         }catch(Exception e){
  5712.             msgDiag.logErroreGenerico(e,"msgRequest.registraMessaggio");
  5713.             if(this.msgContext.isGestioneRisposta()){
  5714.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5715.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5716.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_508_SAVE_REQUEST_MSG));

  5717.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5718.                
  5719.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5720.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5721.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5722.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5723.             }
  5724.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata su fileSystem
  5725.             openspcoopstate.releaseResource();
  5726.             return;
  5727.         }












  5728.         /* ----------------   Salvo busta ricevuta (se non l'ho gia' ricevuta)   --------------------- */
  5729.         msgDiag.mediumDebug("Registrazione busta di richiesta nel RepositoryBuste...");
  5730.         try{
  5731.             if( (!oneWayStateless) && (!sincronoStateless) && (!asincronoStateless)  && (!routingStateless) ){
  5732.                 if(repositoryBuste.isRegistrata(bustaRichiesta.getID(),tipoMsg)){
  5733.                     try{
  5734.                         repositoryBuste.aggiornaBusta(bustaRichiesta,tipoMsg,propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),erroriValidazione);
  5735.                         repositoryBuste.impostaUtilizzoPdD(bustaRichiesta.getID(),tipoMsg);
  5736.                     }catch(Exception e){
  5737.                         if(propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  5738.                             String causa = "Aggiornamento dati busta con id ["+bustaRichiesta.getID()+"] tipo["+tipoMsg+"] non riuscito: "+e.getMessage();
  5739.                             try{
  5740.                                 GestoreMessaggi.acquireLock(msgRequest,TimerLock.newInstance(TipoLock._getLockGestioneRepositoryMessaggi()), msgDiag, causa, propertiesReader.getMsgGiaInProcessamentoAttesaAttiva(), propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  5741.                                 // errore che puo' avvenire a causa del Timer delle Buste (vedi spiegazione in classe GestoreMessaggi.deleteMessageWithLock)
  5742.                                 // Si riesegue tutto il codice isRegistrata e update o create con il lock. Stavolta se avviene un errore non e' dovuto al timer.
  5743.                                 if(repositoryBuste.isRegistrata(bustaRichiesta.getID(),tipoMsg)){
  5744.                                     repositoryBuste.aggiornaBusta(bustaRichiesta,tipoMsg,propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),erroriValidazione);
  5745.                                     repositoryBuste.impostaUtilizzoPdD(bustaRichiesta.getID(),tipoMsg);
  5746.                                 }
  5747.                                 else{
  5748.                                     repositoryBuste.registraBusta(bustaRichiesta, tipoMsg, erroriValidazione, propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  5749.                                 }
  5750.                             }finally{
  5751.                                 try{
  5752.                                     GestoreMessaggi.releaseLock(msgRequest,TimerLock.newInstance(TipoLock._getLockGestioneRepositoryMessaggi()),msgDiag, causa);
  5753.                                 }catch(Exception eUnlock){
  5754.                                     // ignore
  5755.                                 }
  5756.                             }
  5757.                         }
  5758.                         else {
  5759.                             throw e;
  5760.                         }
  5761.                     }

  5762.                 }
  5763.                 else{
  5764.                     repositoryBuste.registraBusta(bustaRichiesta, tipoMsg, erroriValidazione, propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  5765.                 }
  5766.                 repositoryBuste.aggiornaInfoIntegrazione(bustaRichiesta.getID(),tipoMsg,infoIntegrazione);
  5767.             }else{
  5768.                 ((StatelessMessage)openspcoopstate.getStatoRichiesta()).setBusta(bustaRichiesta);
  5769.             }
  5770.         }catch(Exception e){
  5771.             msgDiag.logErroreGenerico(e,"repositoryBuste.registraBusta");
  5772.             if(this.msgContext.isGestioneRisposta()){
  5773.                
  5774.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5775.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5776.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO));

  5777.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5778.                
  5779.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5780.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5781.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5782.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5783.             }
  5784.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata su fileSystem
  5785.             openspcoopstate.releaseResource();
  5786.             return;
  5787.         }




  5788.        

  5789.        
  5790.        
  5791.        
  5792.        






  5793.         /* ------------  Forward a Sbustamento o InoltroBuste (a seconda se il modulo assume funzione di Router) ------------- */
  5794.         try{
  5795.             if(functionAsRouter){ // solo stateful
  5796.                 msgDiag.mediumDebug("Invio messaggio al modulo di InoltroBuste (router)...");
  5797.                 msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.mdb.InoltroBuste.ID_MODULO);
  5798.                 // Creazione InoltroBuste
  5799.                 msgDiag.highDebug("Creazione ObjectMessage for send nell'infrastruttura.");
  5800.                 inoltroMSG.setBusta(bustaRichiesta);
  5801.                 RichiestaDelegata rd = new RichiestaDelegata(soggettoFruitore);
  5802.                 rd.setDominio(identitaPdD);
  5803.                 rd.setIdModuloInAttesa(this.msgContext.getIdModulo());
  5804.                 rd.setIdServizio(idServizio);
  5805.                 rd.setIdCorrelazioneApplicativa(correlazioneApplicativa);
  5806.                 rd.setServizioApplicativo(servizioApplicativoFruitore);
  5807.                 rd.setIntegrazione(this.msgContext.getIntegrazione());
  5808.                 rd.setProtocol(this.msgContext.getProtocol());
  5809.                 inoltroMSG.setRichiestaDelegata(rd);
  5810.                 inoltroMSG.setImplementazionePdDSoggettoMittente(implementazionePdDMittente);
  5811.                 inoltroMSG.setImplementazionePdDSoggettoDestinatario(implementazionePdDDestinatario);
  5812.                 inoltroMSG.setPddContext(inRequestContext.getPddContext());

  5813.                 // send jms solo x il comportamento stateful
  5814.                 if (!routingStateless) {
  5815.                    
  5816.                     String classTypeNodeSender = null;
  5817.                     INodeSender nodeSender = null;
  5818.                     try{
  5819.                         classTypeNodeSender = className.getNodeSender(propertiesReader.getNodeSender());
  5820.                         nodeSender = (INodeSender) loader.newInstance(classTypeNodeSender);
  5821.                         AbstractCore.init(nodeSender, pddContext, protocolFactory);
  5822.                     }catch(Exception e){
  5823.                         throw new Exception("Riscontrato errore durante il caricamento della classe ["+classTypeNodeSender+
  5824.                                 "] da utilizzare per la spedizione nell'infrastruttura: "+e.getMessage());
  5825.                     }
  5826.                    
  5827.                     nodeSender.send(inoltroMSG, org.openspcoop2.pdd.mdb.InoltroBuste.ID_MODULO, msgDiag,
  5828.                             identitaPdD,this.msgContext.getIdModulo(), idMessageRequest, msgRequest);
  5829.                 }
  5830.             }else{
  5831.                 msgDiag.mediumDebug("Invio messaggio al modulo di Sbustamento...");
  5832.                 msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.mdb.Sbustamento.ID_MODULO);

  5833.                 // set tipologia di filtro duplicati
  5834.                 if(proprietaPorta!=null && !proprietaPorta.isEmpty()) {
  5835.                     boolean filtroDuplicatiTestEnabled = CostantiProprieta.isFiltroDuplicatiTestEnabled(proprietaPorta, false); // filtro duplicati usato per test
  5836.                     if(filtroDuplicatiTestEnabled) {
  5837.                         pddContext.addObject(CostantiPdD.FILTRO_DUPLICATI_TEST, filtroDuplicatiTestEnabled);
  5838.                     }
  5839.                 }
  5840.                
  5841.                 // setto parametri SbustamentoMessage
  5842.                 msgDiag.highDebug("Creazione ObjectMessage for send nell'infrastruttura.");
  5843.                 richiestaApplicativa.setIdCorrelazioneApplicativa(correlazioneApplicativa);
  5844.                 richiestaApplicativa.setIdentitaServizioApplicativoFruitore(servizioApplicativoFruitore);
  5845.                 sbustamentoMSG.setRichiestaApplicativa(richiestaApplicativa);
  5846.                 sbustamentoMSG.setBusta(bustaRichiesta);
  5847.                 sbustamentoMSG.setErrors(erroriValidazione, integrationFunctionErrorValidazione);
  5848.                 sbustamentoMSG.setMessaggioErroreProtocollo(isMessaggioErroreProtocollo);
  5849.                 sbustamentoMSG.setIsBustaDiServizio(bustaDiServizio);
  5850.                 sbustamentoMSG.setServizioCorrelato(validatore.getServizioCorrelato());
  5851.                 sbustamentoMSG.setTipoServizioCorrelato(validatore.getTipoServizioCorrelato());
  5852.                 sbustamentoMSG.setVersioneServizioCorrelato(validatore.getVersioneServizioCorrelato());
  5853.                 sbustamentoMSG.setRuoloBustaRicevuta(ruoloBustaRicevuta);
  5854.                 sbustamentoMSG.setOneWayVersione11(oneWayVersione11);
  5855.                 sbustamentoMSG.setStateless((oneWayStateless || sincronoStateless || asincronoStateless));
  5856.                 sbustamentoMSG.setImplementazionePdDSoggettoMittente(implementazionePdDMittente);
  5857.                 sbustamentoMSG.setImplementazionePdDSoggettoDestinatario(implementazionePdDDestinatario);
  5858.                 sbustamentoMSG.setPddContext(inRequestContext.getPddContext());
  5859.                 sbustamentoMSG.setDettaglioEccezione(dettaglioEccezione);
  5860.                
  5861.                 if(validatore.getInfoServizio()!=null){
  5862.                     sbustamentoMSG.setFiltroDuplicatiRichiestoAccordo(Inoltro.SENZA_DUPLICATI.equals(validatore.getInfoServizio().getInoltro()));
  5863.                     if(StatoFunzionalitaProtocollo.REGISTRO.equals(moduleManager.getConsegnaAffidabile(bustaRichiesta)))
  5864.                         sbustamentoMSG.setConfermaRicezioneRichiestoAccordo(validatore.getInfoServizio().getConfermaRicezione());
  5865.                     if(StatoFunzionalitaProtocollo.REGISTRO.equals(moduleManager.getConsegnaInOrdine(bustaRichiesta)))  
  5866.                         sbustamentoMSG.setConsegnaOrdineRichiestoAccordo(validatore.getInfoServizio().getOrdineConsegna());
  5867.                 }

  5868.                 // send jms solo x il comportamento stateful
  5869.                 if (!portaStateless) {
  5870.                     logDebug(logCore, RicezioneBuste.ID_MODULO + " :eseguo send a sbustamento");
  5871.                    
  5872.                     String classTypeNodeSender = null;
  5873.                     INodeSender nodeSender = null;
  5874.                     try{
  5875.                         classTypeNodeSender = className.getNodeSender(propertiesReader.getNodeSender());
  5876.                         nodeSender = (INodeSender) loader.newInstance(classTypeNodeSender);
  5877.                         AbstractCore.init(nodeSender, pddContext, protocolFactory);
  5878.                     }catch(Exception e){
  5879.                         throw new Exception("Riscontrato errore durante il caricamento della classe ["+classTypeNodeSender+
  5880.                                 "] da utilizzare per la spedizione nell'infrastruttura: "+e.getMessage());
  5881.                     }
  5882.                    
  5883.                     nodeSender.send(sbustamentoMSG, org.openspcoop2.pdd.mdb.Sbustamento.ID_MODULO, msgDiag,
  5884.                             identitaPdD,this.msgContext.getIdModulo(), idMessageRequest, msgRequest);
  5885.                     logDebug(logCore, RicezioneBuste.ID_MODULO + " :send a sbustamento eseguita");
  5886.                 }
  5887.             }

  5888.         } catch (Exception e) {
  5889.             if(functionAsRouter){
  5890.                 logError(logCore, "Spedizione->InoltroBuste(router) non riuscita",e);
  5891.                 msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send(InoltroBuste)");
  5892.             }else{
  5893.                 logError(logCore, "Spedizione->Sbustamento non riuscita",e);
  5894.                 msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send(Sbustamento)");
  5895.             }
  5896.             if(this.msgContext.isGestioneRisposta()){
  5897.                
  5898.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5899.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5900.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND));
  5901.                
  5902.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5903.                
  5904.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5905.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5906.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5907.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5908.             }
  5909.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata su fileSystem
  5910.             openspcoopstate.releaseResource();
  5911.             return;
  5912.         }






  5913.         /* ------------  Commit connessione al DB (RichiestaSalvata) ------------- */
  5914.         msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta...");
  5915.         try{
  5916.             openspcoopstate.commit();
  5917.             logDebug(logCore, RicezioneBuste.ID_MODULO+ " :RicezioneBuste commit eseguito");
  5918.         }catch (Exception e) {  
  5919.             msgDiag.logErroreGenerico(e,"openspcoopstate.commit()");
  5920.             if(this.msgContext.isGestioneRisposta()){
  5921.                
  5922.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5923.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5924.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_506_COMMIT_JDBC));

  5925.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5926.                
  5927.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5928.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5929.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  5930.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  5931.             }
  5932.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata
  5933.             openspcoopstate.releaseResource();
  5934.             return;
  5935.         }

  5936.         // *** GB ***
  5937.         if(validatore!=null){
  5938.             if(validatore.getValidatoreSintattico()!=null){
  5939.                 validatore.getValidatoreSintattico().setHeaderSOAP(null);
  5940.             }
  5941.             validatore.setValidatoreSintattico(null);
  5942.         }
  5943.         validatore = null;
  5944.         // *** GB ***
  5945.        
  5946.         if ( portaStateless==false && routingStateless== false  ) {

  5947.             // Aggiornamento cache messaggio
  5948.             if(msgRequest!=null)
  5949.                 msgRequest.addMessaggiIntoCache_readFromTable(RicezioneBuste.ID_MODULO, "richiesta");

  5950.             // Aggiornamento cache proprietario messaggio
  5951.             if(msgRequest!=null)
  5952.                 msgRequest.addProprietariIntoCache_readFromTable(RicezioneBuste.ID_MODULO, "richiesta",null,functionAsRouter);

  5953.             // Rilascia connessione al DB
  5954.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta effettuato, rilascio della connessione...");
  5955.             openspcoopstate.releaseResource();
  5956.         }




  5957.        
  5958.        
  5959.        
  5960.         /* FIX bug riferimentoMessaggio errato, contiene un id generato nel flusso di risposta (e poi non usato in seguito a errori) invece di quello della richiesta */
  5961.         bustaRichiesta = bustaRichiesta.newInstance(); // Per evitare che mi venga modificato da ImbustamentoRisposte (Non ho capito il motivo)
  5962.        
  5963.        
  5964.        
  5965.        
  5966.        


  5967.         /* ------------------------------ STATELESS  ROUTING -------------------------------- */
  5968.         if(routingStateless){
  5969.             ((OpenSPCoopStateless)openspcoopstate).setMessageLib(inoltroMSG);
  5970.             ((OpenSPCoopStateless)openspcoopstate).setIDMessaggioSessione(idMessageRequest);

  5971.             // Durante le invocazioni non deve essere utilizzata la connessione al database
  5972.             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);

  5973.             // InoltroBuste
  5974.             InoltroBuste lib = null;
  5975.             try{
  5976.                 lib = new InoltroBuste(logCore);
  5977.                 EsitoLib esito = lib.onMessage(openspcoopstate);

  5978.                 if ( esito.getStatoInvocazione() == EsitoLib.OK ||
  5979.                         esito.getStatoInvocazione() == EsitoLib.ERRORE_GESTITO ){
  5980.                     msgDiag.mediumDebug("Invocazione libreria InoltroBuste riuscito con esito: "+esito.getStatoInvocazione());
  5981.                 }
  5982.                 else if (esito.getStatoInvocazione() == EsitoLib.ERRORE_NON_GESTITO ) {
  5983.                     throw new Exception("Errore non gestito dalla libreria");
  5984.                 }
  5985.                 //else {
  5986.                 //  throw new Exception("Esito libreria sconosciuto");
  5987.                 //}
  5988.             }catch(Exception e){
  5989.                 msgDiag.logErroreGenerico(e,"GestioneRoutingStateless");
  5990.                 logError(logCore, "Errore Generale durante la gestione del routing stateless: "+e.getMessage(),e);

  5991.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  5992.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5993.                         getErroreIntegrazione());

  5994.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  5995.                
  5996.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  5997.                 ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  5998.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  5999.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6000.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6001.                 openspcoopstate.releaseResource();
  6002.                 return;
  6003.             }

  6004.             // ripristino utilizzo connessione al database
  6005.             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6006.         }




  6007.         /* ------------------------------ STATELESS  NO-ROUTING -------------------------------- */
  6008.         /* Il ciclo seguente chiama tutte le librerie della gestione MDB di openspcoop, fino a quando non viene restituito un messaggio
  6009.          * di libreria destinato a questo modulo oppure fino a che non si verifica un errore.
  6010.          * Se la chiamata di libreria ci restituisce uno stato d'errore ed e' stata settata una risposta da inviare al mittente
  6011.          * usciamo dal ciclo e gestiamo la risposta esattamente come facciamo se tutte le librerie sono andate a buon fine. Se ci
  6012.          * viene restituito un errore senza messaggio di risposta, ne creiamo uno noi (generico) e lo inviamo al mittente
  6013.          */

  6014.         if (portaStateless) {
  6015.                        
  6016.             ((OpenSPCoopStateless)openspcoopstate).setMessageLib(sbustamentoMSG);
  6017.             ((OpenSPCoopStateless)openspcoopstate).setIDMessaggioSessione(idMessageRequest);

  6018.             // Durante le invocazioni non deve essere utilizzata la connessione al database
  6019.             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);

  6020.             EsitoLib esito = new EsitoLib();
  6021.             try {
  6022.                 ((OpenSPCoopStateless)openspcoopstate).setDestinatarioResponseMsgLib(""); // Verra aggiornato dalle librerie
  6023.                 while (((OpenSPCoopStateless)openspcoopstate).getDestinatarioResponseMsgLib().startsWith(RicezioneBuste.ID_MODULO) == false) {

  6024.                     boolean libreriaSbustamento = false;
  6025.                     if (  ((OpenSPCoopStateless)openspcoopstate).getDestinatarioRequestMsgLib().startsWith(Sbustamento.ID_MODULO) ) {
  6026.                         libreriaSbustamento = true;
  6027.                     }
  6028.                    
  6029.                     if (  ((OpenSPCoopStateless)openspcoopstate).getDestinatarioResponseMsgLib().startsWith(ImbustamentoRisposte.ID_MODULO) ) {
  6030.                         /* Verifico che non abbia rilasciato la connessione, se si la riprendo */
  6031.                         if( propertiesReader.isRinegoziamentoConnessione(bustaRichiesta.getProfiloDiCollaborazione()) && (oneWayStateless || sincronoStateless || asincronoStateless)
  6032.                                 && openspcoopstate.resourceReleased()){
  6033.                             /* per default disabilitato
  6034.                             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6035.                             ((OpenSPCoopStateless)openspcoopstate).initResource(identitaPdD, ImbustamentoRisposte.ID_MODULO, idTransazione);
  6036.                             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);
  6037.                             */
  6038.                             // update states
  6039.                             registroServiziReader = registroServiziReader.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  6040.                             configurazionePdDReader = configurazionePdDReader.refreshState(registroServiziReader);
  6041.                             tracciamento.updateState(configurazionePdDReader);
  6042.                             msgDiag.updateState(configurazionePdDReader);
  6043.                         }
  6044.                     }

  6045.                     esito = chiamaLibreria(((OpenSPCoopStateless)openspcoopstate), logCore);

  6046.                     if ( oneWayVersione11 && newConnectionForResponse &&
  6047.                             esito.getStatoInvocazione() == EsitoLib.OK &&
  6048.                             libreriaSbustamento) {

  6049.                         ((OpenSPCoopStateless)openspcoopstate).setDestinatarioResponseMsgLib(RicezioneBuste.ID_MODULO);

  6050.                         // Ho finito di gestire la richiesta in questo caso.
  6051.                         ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6052.                         openspcoopstate.commit();
  6053.                         ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);
  6054.                     }

  6055.                     if ( esito.getStatoInvocazione() == EsitoLib.ERRORE_GESTITO ) {

  6056.                         if(oneWayVersione11 && newConnectionForResponse &&
  6057.                                 libreriaSbustamento ){

  6058.                             // Ho finito di gestire la richiesta in questo caso.
  6059.                             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6060.                             openspcoopstate.commit();
  6061.                             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);
  6062.                         }

  6063.                         break;
  6064.                     }
  6065.                    
  6066.                     else if (esito.getStatoInvocazione() == EsitoLib.ERRORE_NON_GESTITO ) {
  6067.                         throw new Exception("Errore non gestito dalla libreria");
  6068.                     }
  6069.                    
  6070.                     if(libreriaSbustamento==true){
  6071.                         // invocazione della libreriaSbustamento terminata, posso rilasciare la connessione se sono in stateless puro
  6072.                         if( propertiesReader.isRinegoziamentoConnessione(bustaRichiesta.getProfiloDiCollaborazione()) && (oneWayStateless || sincronoStateless || asincronoStateless) ){
  6073.                             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6074.                             openspcoopstate.commit();
  6075.                             openspcoopstate.releaseResource();
  6076.                             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);
  6077.                         }
  6078.                     }
  6079.                    
  6080.                     //else {
  6081.                     //  throw new Exception("Esito libreria sconosciuto");
  6082.                     //}
  6083.                 }
  6084.             }catch (Exception e) {
  6085.                 msgDiag.logErroreGenerico(e,"GestioneStateless");
  6086.                 logError(logCore, "Errore Generale durante la gestione stateless: "+e.getMessage(),e);

  6087.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6088.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6089.                         getErroreIntegrazione());
  6090.                
  6091.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6092.                
  6093.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6094.                 ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6095.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6096.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6097.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6098.                 openspcoopstate.releaseResource();
  6099.                 return;
  6100.             }

  6101.             // ripristino utilizzo connessione al database
  6102.             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  6103.         }




  6104.         // refresh risorse con nuovi stati
  6105.         registroServiziReader = registroServiziReader.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  6106.         configurazionePdDReader = configurazionePdDReader.refreshState(registroServiziReader);
  6107.         tracciamento.updateState(configurazionePdDReader);
  6108.         msgDiag.updateState(configurazionePdDReader);

  6109.        
  6110.        

  6111.         /* ------------  GestioneRisposta non effettuata ------------- */
  6112.         msgDiag.mediumDebug("Gestione risposta...");
  6113.         if(this.msgContext.isGestioneRisposta()==false){
  6114.             if(portaStateless)
  6115.                 openspcoopstate.releaseResource();
  6116.             return;
  6117.         }
  6118.        
  6119.         boolean richiestaRispostaProtocollo = true;
  6120.         /* -------Scenario Routing -------------
  6121.          * Una busta e 'potenzialmente ricevibile da questo modulo se:
  6122.          * - profilo sincrono
  6123.          * - impostazione della newConnectionForResponse = false
  6124.          * Se ricevo una busta non sincrona e newConnectionForResponse=true ho quindi terminato.
  6125.          *
  6126.          * Una busta NON DEVE cmq esssre ricevuta.
  6127.          * Es. puo' darsi che la PdD finale mandi il sincrono su di una nuova connessione.
  6128.          */
  6129.        
  6130.         if(functionAsRouter){
  6131.             if( (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())==false) &&
  6132.                     newConnectionForResponse ) {
  6133.                 this.msgContext.setMessageResponse(MessageUtilities.buildEmptyMessage(requestMessage.getFactory(),requestMessage.getMessageType(),MessageRole.RESPONSE));
  6134.                 return;
  6135.             }
  6136.             richiestaRispostaProtocollo = false;
  6137.         }
  6138.         /* -------Scenario Normale -------------
  6139.          * Una busta e' potenzialmente ricevibile da questo modulo se:
  6140.          * - indTelematicoAbilitato && indTelematicoMittente==null
  6141.          * - indTelematicoNonAbilitato
  6142.          * - profilo sincrono (e valgono i punti sopra degli indirizzi telematici)
  6143.          * - profilo non sincrono && newConnectionForReponse = false
  6144.          * Se ricevuo una busta che possiede un indTelMittente e la gestione e' abilitata ho quindi terminato.
  6145.          * Se ricevo una busta non sincrona e newConnectionForResponse=true ho quindi terminato.
  6146.          *  
  6147.          * Una busta DEVE essere ricevuta quindi, superati i controlli sopra se:
  6148.          * - profilo oneway && confermaRicezione  (poiche' se vado su newConnection o indTelematico sono gia' uscito)
  6149.          * - profilo sincrono (poiche' se vi e' un indTelematico sono gia' uscito)
  6150.          * Quindi una risposta dopo i controlli sopra e' sempre aspettata, a meno di eccezioni:
  6151.          * Se ricevo una busta Errore
  6152.          * Se ricevo una busta di Servizio
  6153.          * Se viene richiesta un profilo OneWay senza confermaRicezione
  6154.          */
  6155.         else{
  6156.             if ( utilizzoIndirizzoTelematico && bustaRichiesta.getIndirizzoMittente()!=null &&
  6157.                     moduleManager.isUtilizzoIndirizzoSoggettoPresenteBusta() &&
  6158.                     (!oneWayStateless) && (!sincronoStateless) && (!asincronoStateless)  ){
  6159.                 this.msgContext.setMessageResponse(MessageUtilities.buildEmptyMessage(requestMessage.getFactory(),requestMessage.getMessageType(),MessageRole.RESPONSE));
  6160.                 if(portaStateless){
  6161.                     openspcoopstate.releaseResource();
  6162.                 }
  6163.                 return;
  6164.             } else if( (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())==false) &&
  6165.                     newConnectionForResponse &&
  6166.                     (!oneWayStateless) && (!sincronoStateless) && (!asincronoStateless) ) {
  6167.                 this.msgContext.setMessageResponse(MessageUtilities.buildEmptyMessage(requestMessage.getFactory(),requestMessage.getMessageType(),MessageRole.RESPONSE));
  6168.                 if(portaStateless){
  6169.                     openspcoopstate.releaseResource();
  6170.                 }
  6171.                 return;
  6172.             } else {
  6173.                 if ( isMessaggioErroreProtocollo  ) {
  6174.                     richiestaRispostaProtocollo = false;
  6175.                 } else if ( bustaDiServizio  ) {
  6176.                     richiestaRispostaProtocollo = false;
  6177.                 } else if( StatoFunzionalitaProtocollo.DISABILITATA.equals(moduleManager.getConsegnaAffidabile(bustaRichiesta)) ||
  6178.                         (propertiesReader.isGestioneRiscontri(implementazionePdDMittente)==false) ||
  6179.                         (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  6180.                                 (bustaRichiesta.isConfermaRicezione()==false))
  6181.                 ){
  6182.                     richiestaRispostaProtocollo = false;
  6183.                 }
  6184.                 else if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  6185.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  6186.                     richiestaRispostaProtocollo = false;
  6187.                 }
  6188.             }
  6189.         }



  6190.        
  6191.        
  6192.         /* ---------- Parametri Gestione risposta ------------- */
  6193.        
  6194.         RicezioneBusteGestioneRisposta parametriGestioneRisposta =
  6195.                 new RicezioneBusteGestioneRisposta();

  6196.         parametriGestioneRisposta.setOpenspcoopstate(openspcoopstate);
  6197.        
  6198.         parametriGestioneRisposta.setRegistroServiziReader(registroServiziReader);
  6199.         parametriGestioneRisposta.setConfigurazionePdDReader(configurazionePdDReader);
  6200.         parametriGestioneRisposta.setMsgDiag(msgDiag);
  6201.         parametriGestioneRisposta.setTracciamento(tracciamento);
  6202.         parametriGestioneRisposta.setLogCore(logCore);
  6203.         parametriGestioneRisposta.setPropertiesReader(propertiesReader);
  6204.        
  6205.         parametriGestioneRisposta.setIdentitaPdD(identitaPdD);
  6206.         parametriGestioneRisposta.setIdMessageRequest(idMessageRequest);
  6207.        
  6208.         parametriGestioneRisposta.setMittenteAnonimo(mittenteAnonimo);
  6209.         parametriGestioneRisposta.setImplementazionePdDMittente(implementazionePdDMittente);
  6210.        
  6211.         parametriGestioneRisposta.setHeaderIntegrazioneRichiesta(headerIntegrazioneRichiesta);
  6212.         parametriGestioneRisposta.setTipiIntegrazionePA(tipiIntegrazionePA);
  6213.        
  6214.         parametriGestioneRisposta.setMsgRequest(msgRequest);
  6215.         parametriGestioneRisposta.setRepositoryBuste(repositoryBuste);
  6216.         parametriGestioneRisposta.setRequestMessage(requestMessage);
  6217.        
  6218.         parametriGestioneRisposta.setPortaStateless(portaStateless);
  6219.         parametriGestioneRisposta.setOneWayStateless(oneWayStateless);
  6220.         parametriGestioneRisposta.setOneWayVers11(oneWayVersione11);
  6221.         parametriGestioneRisposta.setSincronoStateless(sincronoStateless);
  6222.         parametriGestioneRisposta.setAsincronoStateless(asincronoStateless);
  6223.         parametriGestioneRisposta.setRoutingStateless(routingStateless);
  6224.        
  6225.         parametriGestioneRisposta.setRichiestaRispostaProtocollo(richiestaRispostaProtocollo);
  6226.        
  6227.         parametriGestioneRisposta.setTipoPorta(tipoPorta);
  6228.         parametriGestioneRisposta.setFunctionAsRouter(functionAsRouter);

  6229.         parametriGestioneRisposta.setPortaApplicativa(pa);
  6230.         parametriGestioneRisposta.setPortaDelegata(pd);
  6231.         parametriGestioneRisposta.setSoggettoMittente(soggettoFruitore);
  6232.         parametriGestioneRisposta.setIdServizio(idServizio);
  6233.         parametriGestioneRisposta.setCorrelazioneApplicativa(correlazioneApplicativa);
  6234.        
  6235.         parametriGestioneRisposta.setPddContext(inRequestContext.getPddContext());
  6236.         parametriGestioneRisposta.setInfoIntegrazione(infoIntegrazione);
  6237.         parametriGestioneRisposta.setTransaction(transaction);
  6238.        
  6239.         parametriGestioneRisposta.setProtocolFactory(protocolFactory);
  6240.         parametriGestioneRisposta.setTraduttore(traduttore);
  6241.         parametriGestioneRisposta.setModuleManager(moduleManager);
  6242.        
  6243.         parametriGestioneRisposta.setBustaRichiesta(bustaRichiesta);
  6244.         parametriGestioneRisposta.setErroriValidazione(erroriValidazione);
  6245.         parametriGestioneRisposta.setVersioneProtocollo(versioneProtocollo);
  6246.         parametriGestioneRisposta.setRuoloBustaRicevuta(ruoloBustaRicevuta);
  6247.         parametriGestioneRisposta.setReadQualifiedAttribute(readQualifiedAttribute);
  6248.         parametriGestioneRisposta.setProprietaManifestAttachments(proprietaManifestAttachments);
  6249.        
  6250.         parametriGestioneRisposta.setMessageSecurityContext(messageSecurityContext);
  6251.         parametriGestioneRisposta.setFlowPropertiesResponse(flowPropertiesResponse);
  6252.        
  6253.         parametriGestioneRisposta.setParametriGenerazioneBustaErrore(parametriGenerazioneBustaErrore);
  6254.         parametriGestioneRisposta.setParametriInvioBustaErrore(parametriInvioBustaErrore);
  6255.         parametriGestioneRisposta.setRicezioneBusteGeneratoreBustaErrore(ricezioneBusteGeneratoreBustaErrore);





  6256.        
  6257.         /* ------------  Lettura parametri del messaggio ricevuto e ValidityCheck -------------- */
  6258.         try {
  6259.             gestioneRisposta(parametriGestioneRisposta);
  6260.         } catch (Exception e) {
  6261.             logError(logCore, "ErroreGenerale",e);
  6262.             msgDiag.logErroreGenerico(e, "Generale");
  6263.            
  6264.             parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6265.             parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6266.                     getErroreIntegrazione());
  6267.            
  6268.             OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6269.            
  6270.             // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6271.             parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6272.             parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6273.             ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6274.             openspcoopstate.releaseResource();
  6275.             return;
  6276.         }
  6277.        
  6278.         }finally{ // try vedi  #try-finally-openspcoopstate#
  6279.             try{
  6280.                 if(openspcoopstate!=null){
  6281.                     openspcoopstate.forceFinallyReleaseResource();
  6282.                 }
  6283.             }catch(Throwable e){
  6284.                 if(msgDiag!=null){
  6285.                     try{
  6286.                         msgDiag.logErroreGenerico(e, "Rilascio risorsa");
  6287.                     }catch(Throwable eLog){
  6288.                         logError(logCore, "Diagnostico errore per Rilascio risorsa: "+eLog.getMessage(),eLog);
  6289.                     }
  6290.                 }
  6291.                 else{
  6292.                     logError(logCore, "Rilascio risorsa: "+e.getMessage(),e);
  6293.                 }
  6294.             }
  6295.         }
  6296.        
  6297.     }

  6298.     private void setCredenziali(Credenziali credenziali,MsgDiagnostico msgDiag){
  6299.         String credenzialiFornite = "";
  6300.         if(credenziali!=null){
  6301.             credenzialiFornite = credenziali.toString();
  6302.         }
  6303.         msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI, credenzialiFornite);
  6304.     }

  6305.     private void gestioneRisposta(RicezioneBusteGestioneRisposta parametriGestioneRisposta) throws Exception{

  6306.         /* ------- Lettura parametri ---------- */
  6307.         IOpenSPCoopState openspcoopstate = parametriGestioneRisposta.getOpenspcoopstate();
  6308.        
  6309.         MsgDiagnostico msgDiag = parametriGestioneRisposta.getMsgDiag();
  6310.         Tracciamento tracciamento = parametriGestioneRisposta.getTracciamento();
  6311.         Logger logCore = parametriGestioneRisposta.getLogCore();
  6312.         OpenSPCoop2Properties propertiesReader = parametriGestioneRisposta.getPropertiesReader();
  6313.        
  6314.         IDSoggetto identitaPdD = parametriGestioneRisposta.getIdentitaPdD();
  6315.         String idMessageRequest = parametriGestioneRisposta.getIdMessageRequest();
  6316.        
  6317.         boolean mittenteAnonimo = parametriGestioneRisposta.isMittenteAnonimo();
  6318.         String implementazionePdDMittente = parametriGestioneRisposta.getImplementazionePdDMittente();
  6319.        
  6320.         /* --- HeaderIntegrazione headerIntegrazioneRichiesta = parametriGestioneRisposta.getHeaderIntegrazioneRichiesta();
  6321.         String[] tipiIntegrazionePA = parametriGestioneRisposta.getTipiIntegrazionePA(); --- */
  6322.        
  6323.         GestoreMessaggi msgRequest = parametriGestioneRisposta.getMsgRequest();
  6324.         RepositoryBuste repositoryBuste = parametriGestioneRisposta.getRepositoryBuste();
  6325.         OpenSPCoop2Message requestMessage = parametriGestioneRisposta.getRequestMessage();
  6326.        
  6327.         boolean portaStateless = parametriGestioneRisposta.isPortaStateless();
  6328.         boolean oneWayStateless = parametriGestioneRisposta.isOneWayStateless();
  6329.         boolean oneWayVersione11 = parametriGestioneRisposta.isOneWayVers11();
  6330.         boolean sincronoStateless = parametriGestioneRisposta.isSincronoStateless();
  6331.         boolean asincronoStateless = parametriGestioneRisposta.isAsincronoStateless();
  6332.         boolean routingStateless = parametriGestioneRisposta.isRoutingStateless();
  6333.        
  6334.         boolean richiestaRispostaProtocollo = parametriGestioneRisposta.isRichiestaRispostaProtocollo();
  6335.        
  6336.         TipoPdD tipoPorta = parametriGestioneRisposta.getTipoPorta();
  6337.         boolean functionAsRouter = parametriGestioneRisposta.isFunctionAsRouter();
  6338.        
  6339.         PdDContext pddContext = parametriGestioneRisposta.getPddContext();
  6340.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  6341.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  6342.         Integrazione infoIntegrazione = parametriGestioneRisposta.getInfoIntegrazione();
  6343.         Transaction transaction = parametriGestioneRisposta.getTransaction();
  6344.        
  6345.         IProtocolFactory<?> protocolFactory = parametriGestioneRisposta.getProtocolFactory();
  6346.         ITraduttore traduttore = parametriGestioneRisposta.getTraduttore();
  6347.         IProtocolVersionManager moduleManager = parametriGestioneRisposta.getModuleManager();
  6348.        
  6349.         Busta bustaRichiesta = parametriGestioneRisposta.getBustaRichiesta();
  6350.         java.util.List<Eccezione> erroriValidazione = parametriGestioneRisposta.getErroriValidazione();
  6351.         String versioneProtocollo = parametriGestioneRisposta.getVersioneProtocollo();
  6352.         RuoloBusta ruoloBustaRicevuta = parametriGestioneRisposta.getRuoloBustaRicevuta();
  6353.         boolean readQualifiedAttribute = parametriGestioneRisposta.isReadQualifiedAttribute();
  6354.         ProprietaManifestAttachments proprietaManifestAttachments = parametriGestioneRisposta.getProprietaManifestAttachments();
  6355.        
  6356.         PortaApplicativa pa = parametriGestioneRisposta.getPortaApplicativa();
  6357.         PortaDelegata pd = parametriGestioneRisposta.getPortaDelegata();
  6358.        
  6359.         IDSoggetto soggettoFruitore = parametriGestioneRisposta.getSoggettoMittente();
  6360.         IDServizio idServizio = parametriGestioneRisposta.getIdServizio();
  6361.         String correlazioneApplicativa = parametriGestioneRisposta.getCorrelazioneApplicativa();
  6362.        
  6363.         MessageSecurityContext messageSecurityContext = parametriGestioneRisposta.getMessageSecurityContext();
  6364.         FlowProperties flowPropertiesResponse = parametriGestioneRisposta.getFlowPropertiesResponse();
  6365.        
  6366.         RicezioneBusteParametriGenerazioneBustaErrore parametriGenerazioneBustaErrore = parametriGestioneRisposta.getParametriGenerazioneBustaErrore();
  6367.         RicezioneBusteParametriInvioBustaErrore parametriInvioBustaErrore = parametriGestioneRisposta.getParametriInvioBustaErrore();
  6368.         RicezioneBusteGeneratoreBustaErrore ricezioneBusteGeneratoreBustaErrore = parametriGestioneRisposta.getRicezioneBusteGeneratoreBustaErrore();
  6369.        
  6370.         RegistroServiziManager registroServiziReader = parametriGestioneRisposta.getRegistroServiziReader();
  6371.         ConfigurazionePdDManager configurazionePdDReader = parametriGestioneRisposta.getConfigurazionePdDReader();
  6372.        
  6373.         Loader loader = Loader.getInstance();
  6374.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  6375.        
  6376.         GestoreMessaggi msgResponse = null;
  6377.         OpenSPCoop2Message responseMessage = MessageUtilities.buildEmptyMessage(requestMessage.getFactory(),requestMessage.getMessageType(),MessageRole.RESPONSE);

  6378.         Busta bustaRisposta = null;
  6379.         String idMessaggioSblocco = null;

  6380.         boolean contenutoRispostaPresente = false;

  6381.         RicezioneBusteMessage ricezioneBusteMSG = null;
  6382.         String idCorrelazioneApplicativaRisposta = null;
  6383.         try{
  6384.             msgDiag.mediumDebug("Attesa/lettura risposta...");

  6385.             if ( portaStateless==false && routingStateless== false  ) {
  6386.                
  6387.                 String classType = null;
  6388.                 INodeReceiver nodeReceiver = null;
  6389.                 try{
  6390.                     classType = ClassNameProperties.getInstance().getNodeReceiver(propertiesReader.getNodeReceiver());
  6391.                     nodeReceiver = (INodeReceiver) loader.newInstance(classType);
  6392.                     AbstractCore.init(nodeReceiver, pddContext, protocolFactory);
  6393.                 }catch(Exception e){
  6394.                     throw new Exception("Riscontrato errore durante il caricamento della classe ["+classType+
  6395.                             "] da utilizzare per la ricezione dall'infrastruttura: "+e.getMessage());
  6396.                 }
  6397.                
  6398.                 ricezioneBusteMSG = (RicezioneBusteMessage) nodeReceiver.receive(msgDiag,identitaPdD,this.msgContext.getIdModulo(),
  6399.                         idMessageRequest,propertiesReader.getNodeReceiverTimeoutRicezioneBuste(),
  6400.                         propertiesReader.getNodeReceiverCheckInterval());
  6401.                
  6402.                 // aggiorno pddContext
  6403.                 pddContext = ricezioneBusteMSG.getPddContext();
  6404.                 if(pddContext!=null){
  6405.                     List<MapKey<String>> enumPddContext = pddContext.keys();
  6406.                     if(enumPddContext!=null && !enumPddContext.isEmpty()) {
  6407.                         for (MapKey<String> key : enumPddContext) {
  6408.                             // -- System.out.println("AGGIORNO KEY BUSTE ["+key+"]");
  6409.                             this.msgContext.getPddContext().addObject(key, pddContext.getObject(key));
  6410.                         }
  6411.                     }
  6412.                 }
  6413.             }
  6414.             else{
  6415.                 ricezioneBusteMSG = (RicezioneBusteMessage) openspcoopstate.getMessageLib();
  6416.             }


  6417.             contenutoRispostaPresente = ricezioneBusteMSG.getBustaRisposta()!=null;
  6418.             if( richiestaRispostaProtocollo && (contenutoRispostaPresente==false)  ){
  6419.                 throw new Exception("Risposta attesa e non ritornata: ErroreInterno");
  6420.             }
  6421.             // Leggo il contenuto
  6422.             if(contenutoRispostaPresente){
  6423.                 bustaRisposta = ricezioneBusteMSG.getBustaRisposta();

  6424.                 this.msgContext.getProtocol().setIdRisposta(bustaRisposta.getID());
  6425.                 this.msgContext.getProtocol().setCollaborazione(bustaRisposta.getCollaborazione());

  6426.             }else{
  6427.                 idMessaggioSblocco = ricezioneBusteMSG.getIdMessaggioSblocco();
  6428.             }

  6429.         } catch (Exception e) {
  6430.             msgDiag.logErroreGenerico(e,"GestioneRisposta("+this.msgContext.getIdModulo()+")");
  6431.             logError(logCore, "Gestione risposta ("+this.msgContext.getIdModulo()+") con errore",e);
  6432.            
  6433.             // per la costruzione dell'errore ho bisogno di una connessione al database
  6434.             if ( portaStateless==false && routingStateless== false  ) {
  6435.                 try{
  6436.                     msgDiag.mediumDebug("Richiesta connessione al database per la gestione della risposta...");
  6437.                     openspcoopstate.updateResource(idTransazione);
  6438.                 }catch(Exception eDB){
  6439.                     setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,logCore,msgDiag,
  6440.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6441.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION),eDB,
  6442.                             "openspcoopstate.updateDatabaseResource");
  6443.                     return;
  6444.                 }
  6445.             }

  6446.             // In caso di Timeout elimino messaggi di richiesta ancora in processamento.
  6447.             if(e instanceof NodeTimeoutException) {
  6448.                 try{
  6449.                     msgDiag.logPersonalizzato("timeoutRicezioneRisposta");
  6450.                     msgRequest.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  6451.                     openspcoopstate.commit();
  6452.                 }catch(Exception eDel){
  6453.                     msgDiag.logErroreGenerico(eDel.getMessage(),"EliminazioneMessaggioScadutoTimeoutRicezioneRisposta");
  6454.                 }
  6455.             }

  6456.             // Spedisco errore
  6457.             parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6458.             parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6459.                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_513_RECEIVE));

  6460.             OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6461.            
  6462.             // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6463.             parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6464.             parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6465.             ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);

  6466.             // rilascio connessione e ritorno messaggio
  6467.             openspcoopstate.releaseResource();
  6468.             return;
  6469.         }



  6470.         //  Aggiornamento Informazioni
  6471.         if(contenutoRispostaPresente){
  6472.             msgDiag.setIdMessaggioRisposta(bustaRisposta.getID());
  6473.             msgDiag.addKeywords(bustaRisposta, false);
  6474.         }else{
  6475.             msgDiag.setIdMessaggioRisposta(idMessaggioSblocco);
  6476.         }
  6477.         parametriGenerazioneBustaErrore.setMsgDiag(msgDiag);
  6478.         parametriInvioBustaErrore.setMsgDiag(msgDiag);
  6479.        
  6480.         if ( portaStateless==false && routingStateless== false  ) {

  6481.             /* ------------  Re-ottengo Connessione al DB -------------- */
  6482.             try{
  6483.                 msgDiag.mediumDebug("Richiesta connessione al database per la gestione della risposta...");
  6484.                 openspcoopstate.updateResource(idTransazione);
  6485.             }catch(Exception e){
  6486.                 setSOAPFault_processamento(IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,logCore,msgDiag,
  6487.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6488.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION),e,
  6489.                         "openspcoopstate.updateDatabaseResource");
  6490.                 return;
  6491.             }

  6492.             // MsgResponse
  6493.             if(contenutoRispostaPresente){
  6494.                 msgResponse = new GestoreMessaggi(openspcoopstate, false, bustaRisposta.getID(),Costanti.OUTBOX,msgDiag,pddContext);
  6495.             }else{
  6496.                 msgResponse = new GestoreMessaggi(openspcoopstate, false,idMessaggioSblocco,Costanti.OUTBOX,msgDiag,pddContext);
  6497.             }
  6498.             //tempiAttraversamentoGestioneMessaggi = msgResponse.getTempiAttraversamentoPdD();
  6499.             //dimensioneMessaggiAttraversamentoGestioneMessaggi = msgResponse.getDimensioneMessaggiAttraversamentoPdD();


  6500.             /* ------------  Lettura Contenuto Messaggio (mapping in Message)  -------------- */
  6501.             if(contenutoRispostaPresente || functionAsRouter){
  6502.                 msgDiag.mediumDebug("Lettura messaggio di risposta...");
  6503.                 try{
  6504.                     responseMessage = msgResponse.getMessage();
  6505.                     if(responseMessage!=null && this.msgContext.getPddContext()!=null) {
  6506.                         Object o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO);
  6507.                         if(o!=null && o instanceof Boolean) {
  6508.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  6509.                         }
  6510.                         o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  6511.                         if(o!=null && o instanceof ParseException) {
  6512.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, o);
  6513.                         }
  6514.                        
  6515.                         o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO);
  6516.                         if(o!=null && o instanceof Boolean) {
  6517.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  6518.                         }
  6519.                         o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  6520.                         if(o!=null && o instanceof ParseException) {
  6521.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, o);
  6522.                         }
  6523.                     }
  6524.                     idCorrelazioneApplicativaRisposta = msgResponse.getIDCorrelazioneApplicativaRisposta();
  6525.                 }catch(Exception e){
  6526.                     // Il router potrebbe ricevere il SOAPFault da reinoltrare
  6527.                     if( (!functionAsRouter) || (contenutoRispostaPresente==true) ){
  6528.                         msgDiag.logErroreGenerico(e,"msgResponse.getMessage()");
  6529.                        
  6530.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6531.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6532.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_511_READ_RESPONSE_MSG));

  6533.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6534.                        
  6535.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6536.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6537.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6538.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6539.                         openspcoopstate.releaseResource();
  6540.                         return;
  6541.                     }
  6542.                 }
  6543.             }
  6544.         }

  6545.         else {
  6546.             responseMessage = ((OpenSPCoopStateless)openspcoopstate).getRispostaMsg();
  6547.             idCorrelazioneApplicativaRisposta = ((OpenSPCoopStateless)openspcoopstate).getIDCorrelazioneApplicativaRisposta();
  6548.             if(responseMessage!=null){
  6549.                 parametriGenerazioneBustaErrore.setParseException(responseMessage.getParseException());
  6550.             }
  6551.             /*tempiAttraversamentoGestioneMessaggi =
  6552.                 ((OpenSPCoopStateless) openspcoopstate).getTempiAttraversamentoPDD();
  6553.             dimensioneMessaggiAttraversamentoGestioneMessaggi =
  6554.                 ((OpenSPCoopStateless) openspcoopstate).getDimensioneMessaggiAttraversamentoPDD();*/
  6555.         }

  6556.         /* ---- Aggiorno informazioni correlazione applicativa risposta ---- */
  6557.         parametriGenerazioneBustaErrore.setCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  6558.         parametriInvioBustaErrore.setCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  6559.         msgDiag.setIdCorrelazioneRisposta(idCorrelazioneApplicativaRisposta);
  6560.         if(this.msgContext.getIntegrazione()!=null)
  6561.             this.msgContext.getIntegrazione().setIdCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);

  6562.         // Gestione Busta di Risposta
  6563.         if(contenutoRispostaPresente){

  6564.             /* ----------- Trasmissione ------------------ */
  6565.             Trasmissione tras = null;
  6566.             if( propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente)){
  6567.                 msgDiag.mediumDebug("Impostazione trasmissione nella busta di risposta...");
  6568.                 // Tracciamento in busta
  6569.                 tras = new Trasmissione();
  6570.                
  6571.                 // origine
  6572.                 tras.setOrigine(identitaPdD.getNome());
  6573.                 tras.setTipoOrigine(identitaPdD.getTipo());
  6574.                 tras.setIdentificativoPortaOrigine(identitaPdD.getCodicePorta());
  6575.                
  6576.                 // trasmissione
  6577.                 // Cerco destinatario con identita che sto assumendo (l'origine di quella trasmissione e' la destinazione di questa!)
  6578.                 // che come mittente non possieda il mittente attuale della busta (senno potrebbe essere il potenziale
  6579.                 // precedente hop che ha aggiunto una trasmissione da lui a questo hop)
  6580.                 for(int i=0;i<bustaRichiesta.sizeListaTrasmissioni();i++){
  6581.                     if( identitaPdD.getTipo().equals(bustaRichiesta.getTrasmissione(i).getTipoDestinazione()) &&
  6582.                             identitaPdD.getNome().equals(bustaRichiesta.getTrasmissione(i).getDestinazione()) ){
  6583.                         boolean tipoOrigineValido = true;
  6584.                         try {
  6585.                             traduttore.toProtocolOrganizationType(bustaRichiesta.getTrasmissione(i).getTipoOrigine());
  6586.                         }catch(Exception e) {
  6587.                             tipoOrigineValido = false;
  6588.                         }
  6589.                         if(tipoOrigineValido) {
  6590.                             tras.setDestinazione(bustaRichiesta.getTrasmissione(i).getOrigine());
  6591.                             tras.setTipoDestinazione(bustaRichiesta.getTrasmissione(i).getTipoOrigine());
  6592.                         }
  6593.                     }
  6594.                 }
  6595.                 if(tras.getDestinazione()==null || tras.getTipoDestinazione()==null){
  6596.                     tras.setDestinazione(bustaRisposta.getDestinatario());
  6597.                     tras.setTipoDestinazione(bustaRisposta.getTipoDestinatario());
  6598.                 }
  6599.                 try{
  6600.                     String dominio = registroServiziReader.getDominio(new IDSoggetto(tras.getTipoDestinazione(),tras.getDestinazione()), null, protocolFactory, requestInfo);
  6601.                     tras.setIdentificativoPortaDestinazione(dominio);
  6602.                 }catch(Exception e){
  6603.                     // ignore
  6604.                 }
  6605.                
  6606.                 // oraRegistrazione
  6607.                 tras.setOraRegistrazione(bustaRisposta.getOraRegistrazione());
  6608.                 tras.setTempo(propertiesReader.getTipoTempoBusta(implementazionePdDMittente));
  6609.                
  6610.                 bustaRisposta.addTrasmissione(tras);
  6611.             }



  6612.             /* ------------  Gestione Funzionalita' speciali per Attachments (Manifest) ------------- */    
  6613.             boolean scartaBody = false;
  6614.             if(!functionAsRouter){
  6615.                 boolean allegaBody = configurazionePdDReader.isAllegaBody(pa);
  6616.                 if(allegaBody){
  6617.                     // E' stato effettuato prima l'inserimento del body come allegato.
  6618.                     // Forzo lo scartamento.
  6619.                     scartaBody = true;
  6620.                 }else{
  6621.                     scartaBody = configurazionePdDReader.isScartaBody(pa);
  6622.                 }
  6623.             }








  6624.             /* ------------  Aggiunta eccezioni di livello info riscontrate dalla validazione, se profilo e' lineeGuida1.1 ------------- */
  6625.             if(!functionAsRouter){
  6626.                 if( bustaRisposta.sizeListaEccezioni()==0 && moduleManager.isIgnoraEccezioniLivelloNonGrave()){
  6627.                     for(int i=0; i<erroriValidazione.size();i++){
  6628.                         Eccezione ec = erroriValidazione.get(i);
  6629.                         if(LivelloRilevanza.INFO.equals(ec.getRilevanza())){
  6630.                             bustaRisposta.addEccezione(ec);
  6631.                         }
  6632.                     }
  6633.                 }
  6634.             }








  6635.             /* ------------  Imbustamento (Prima della Sicurezza)  ------------- */
  6636.            
  6637.             msgDiag.mediumDebug("Imbustamento della risposta...");
  6638.             BustaRawContent<?> headerBustaRisposta = null;
  6639.             boolean gestioneManifestRisposta = false;
  6640.             Imbustamento imbustatore = null;
  6641.             try{
  6642.                 if(functionAsRouter){
  6643.                     gestioneManifestRisposta = configurazionePdDReader.isGestioneManifestAttachments();
  6644.                 }else{
  6645.                     if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  6646.                             RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) &&
  6647.                             pd!=null){ // devo generare la ricevuta alla risposta
  6648.                         gestioneManifestRisposta = configurazionePdDReader.isGestioneManifestAttachments(pd,protocolFactory);
  6649.                     }else{
  6650.                         gestioneManifestRisposta = configurazionePdDReader.isGestioneManifestAttachments(pa,protocolFactory);
  6651.                     }
  6652.                 }
  6653.                 imbustatore = new Imbustamento(logCore, protocolFactory,openspcoopstate.getStatoRichiesta());
  6654.                 if(functionAsRouter &&
  6655.                         !( identitaPdD.getTipo().equals(bustaRisposta.getTipoMittente()) && identitaPdD.getNome().equals(bustaRisposta.getMittente()) )
  6656.                 ){
  6657.                     // Aggiungo trasmissione solo se la busta e' stata generata dalla porta di dominio destinataria della richiesta.
  6658.                     // Se il mittente e' il router, logicamente la busta sara' un errore generato dal router
  6659.                     if( propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente)){
  6660.                         msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento ["+responseMessage.getClass().getName()+"]");
  6661.                         ProtocolMessage protocolMessage = imbustatore.addTrasmissione(responseMessage, tras, readQualifiedAttribute,
  6662.                                 FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  6663.                         if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  6664.                             headerBustaRisposta = protocolMessage.getBustaRawContent();
  6665.                             responseMessage = protocolMessage.getMessage(); // updated
  6666.                         }
  6667.                         msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento ["+responseMessage.getClass().getName()+"]");
  6668.                     }
  6669.                     else{
  6670.                         Validatore v = new Validatore(responseMessage,pddContext,openspcoopstate.getStatoRichiesta(), logCore, protocolFactory);
  6671.                         headerBustaRisposta = v.getHeaderProtocollo_senzaControlli();
  6672.                     }
  6673.                 }else{
  6674.                     msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento ["+responseMessage.getClass().getName()+"]");
  6675.                     ProtocolMessage protocolMessage = imbustatore.imbustamentoRisposta(responseMessage,pddContext,
  6676.                             bustaRisposta,bustaRichiesta,
  6677.                             infoIntegrazione,gestioneManifestRisposta,scartaBody,proprietaManifestAttachments,
  6678.                             FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  6679.                     if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  6680.                         headerBustaRisposta = protocolMessage.getBustaRawContent();
  6681.                         responseMessage = protocolMessage.getMessage(); // updated
  6682.                     }
  6683.                     msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento ["+responseMessage.getClass().getName()+"]");
  6684.                 }
  6685.             }catch(Exception e){
  6686.                
  6687.                 // STATEFUL
  6688.                 if (msgResponse!=null && !portaStateless && !routingStateless){
  6689.                     try {
  6690.                         // Aggiorno proprietario Messaggio
  6691.                         msgDiag.mediumDebug("Aggiornamento proprietario messaggio risposta ...");
  6692.                         msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  6693.                     }catch(Throwable t) {
  6694.                         // ignore
  6695.                     }
  6696.                 }
  6697.                
  6698.                 if(functionAsRouter &&
  6699.                         !( identitaPdD.getTipo().equals(bustaRisposta.getTipoMittente()) && identitaPdD.getNome().equals(bustaRisposta.getMittente()) )
  6700.                 ){
  6701.                     msgDiag.logErroreGenerico(e,"imbustatore.pre-security.addTrasmissione(risposta)");
  6702.                 }else{
  6703.                     msgDiag.logErroreGenerico(e,"imbustatore.pre-security-imbustamento(risposta)");
  6704.                 }

  6705.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6706.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6707.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_526_GESTIONE_IMBUSTAMENTO));
  6708.                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.INTEROPERABILITY_PROFILE_ENVELOPING_RESPONSE_FAILED);
  6709.                
  6710.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6711.                
  6712.                 if(responseMessage!=null && responseMessage.getParseException()!=null){
  6713.                     errorOpenSPCoopMsg.setParseException(responseMessage.getParseException());
  6714.                 }
  6715.                
  6716.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6717.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6718.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6719.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6720.                 openspcoopstate.releaseResource();
  6721.                 return;
  6722.             }




  6723.            
  6724.            
  6725.            
  6726.            
  6727.             /* ------------ Init MTOM Processor  -------------- */
  6728.             MTOMProcessor mtomProcessor = null;
  6729.             if(!functionAsRouter){
  6730.                 if(flowPropertiesResponse!=null){
  6731.                     msgDiag.mediumDebug("init MTOM Processor ...");
  6732.                     mtomProcessor = new MTOMProcessor(flowPropertiesResponse.mtom, flowPropertiesResponse.messageSecurity,
  6733.                             tipoPorta, msgDiag, logCore, pddContext);
  6734.                 }
  6735.             }
  6736.            
  6737.            
  6738.            
  6739.            
  6740.            
  6741.             /* ------------ MTOM Processor BeforeSecurity  -------------- */
  6742.             if(mtomProcessor!=null){
  6743.                 try{
  6744.                     mtomProcessor.mtomBeforeSecurity(responseMessage, RuoloMessaggio.RISPOSTA);
  6745.                 }catch(Exception e){
  6746.                    
  6747.                     // STATEFUL
  6748.                     if (msgResponse!=null && !portaStateless && !routingStateless){
  6749.                         try {
  6750.                             // Aggiorno proprietario Messaggio
  6751.                             msgDiag.mediumDebug("Aggiornamento proprietario messaggio risposta ...");
  6752.                             msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  6753.                         }catch(Throwable t) {
  6754.                             // ignore
  6755.                         }
  6756.                     }
  6757.                    
  6758.                     // L'errore viene registrato dentro il metodo mtomProcessor.mtomBeforeSecurity
  6759.                     //msgDiag.logErroreGenerico(e,"MTOMProcessor(BeforeSec-"+mtomProcessor.getMTOMProcessorType()+")");
  6760.                    
  6761.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6762.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6763.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_557_MTOM_PROCESSOR_ERROR));
  6764.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.ATTACHMENTS_PROCESSING_RESPONSE_FAILED);
  6765.                    
  6766.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6767.                    
  6768.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6769.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6770.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6771.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6772.                     openspcoopstate.releaseResource();
  6773.                     return;
  6774.                 }
  6775.             }




  6776.             /* ------------ Message-Security -------------- */
  6777.             if(!functionAsRouter){
  6778.                 if(flowPropertiesResponse != null && flowPropertiesResponse.messageSecurity!=null &&
  6779.                     flowPropertiesResponse.messageSecurity.getFlowParameters() !=null &&
  6780.                     flowPropertiesResponse.messageSecurity.getFlowParameters().size() > 0){
  6781.                     try{
  6782.                         // Aggiorno valori dinamici
  6783.                         configurazionePdDReader.updateMessageSecurityForSender(flowPropertiesResponse.messageSecurity, logCore, responseMessage, bustaRichiesta, requestInfo, pddContext,
  6784.                                 flowPropertiesResponse.messageSecurityRequest);
  6785.                        
  6786.                         messageSecurityContext.setFunctionAsClient(SecurityConstants.SECURITY_CLIENT);
  6787.                         messageSecurityContext.setOutgoingProperties(flowPropertiesResponse.messageSecurity.getFlowParameters());
  6788.                        
  6789.                         String tipoSicurezza = SecurityConstants.convertActionToString(messageSecurityContext.getOutgoingProperties());
  6790.                         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_SICUREZZA_MESSAGGIO_RISPOSTA, tipoSicurezza);
  6791.                         pddContext.addObject(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RISPOSTA, tipoSicurezza);
  6792.                        
  6793.                         msgDiag.logPersonalizzato("messageSecurity.processamentoRispostaInCorso");
  6794.                        
  6795.                         if(org.openspcoop2.security.message.engine.WSSUtilities.isNormalizeToSaajImpl(messageSecurityContext)){
  6796.                             msgDiag.mediumDebug("Normalize to saajImpl");
  6797.                             //System.out.println("RicezioneBuste.response.normalize");
  6798.                             responseMessage = responseMessage.normalizeToSaajImpl();
  6799.                         }
  6800.                        
  6801.                         DynamicMapBuilderUtils.injectDynamicMap(bustaRichiesta, requestInfo, pddContext, logCore);
  6802.                         if(messageSecurityContext.processOutgoing(responseMessage,pddContext,
  6803.                                 transaction!=null ? transaction.getTempiElaborazione() : null) == false){
  6804.                            
  6805.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO , messageSecurityContext.getMsgErrore() );
  6806.                             msgDiag.logPersonalizzato("messageSecurity.processamentoRispostaInErrore");
  6807.                            
  6808.                             parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6809.                             parametriGenerazioneBustaErrore.setErroreCooperazione(ErroriCooperazione.MESSAGE_SECURITY.
  6810.                                     getErroreMessageSecurity(messageSecurityContext.getMsgErrore(), messageSecurityContext.getCodiceErrore()));
  6811.                             parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.MESSAGE_SECURITY_RESPONSE_FAILED);
  6812.                            
  6813.                             OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  6814.                            
  6815.                             // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6816.                             parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6817.                             parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6818.                             ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6819.                             openspcoopstate.releaseResource();
  6820.                             return;
  6821.                         }
  6822.                         else{
  6823.                             msgDiag.logPersonalizzato("messageSecurity.processamentoRispostaEffettuato");
  6824.                         }
  6825.                        
  6826.                     }catch(Exception e){
  6827.                        
  6828.                         // STATEFUL
  6829.                         if (msgResponse!=null && !portaStateless && !routingStateless){
  6830.                             try {
  6831.                                 // Aggiorno proprietario Messaggio
  6832.                                 msgDiag.mediumDebug("Aggiornamento proprietario messaggio risposta ...");
  6833.                                 msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  6834.                             }catch(Throwable t) {
  6835.                                 // ignore
  6836.                             }
  6837.                         }
  6838.                        
  6839.                         msgDiag.addKeywordErroreProcessamento(e);
  6840.                         msgDiag.logPersonalizzato("messageSecurity.processamentoRispostaInErrore");
  6841.                         logError(logCore, "[MessageSecurityResponse]" + e.getMessage(),e);
  6842.                        
  6843.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6844.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6845.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));

  6846.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6847.                        
  6848.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6849.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6850.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6851.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6852.                         openspcoopstate.releaseResource();
  6853.                         return;
  6854.                     }
  6855.                 }
  6856.                 else{
  6857.                     msgDiag.logPersonalizzato("messageSecurity.processamentoRispostaDisabilitato");
  6858.                 }
  6859.             }

  6860.            
  6861.            
  6862.            
  6863.             /* ------------ MTOM Processor AfterSecurity  -------------- */
  6864.             if(mtomProcessor!=null){
  6865.                 try{
  6866.                     mtomProcessor.mtomAfterSecurity(responseMessage, RuoloMessaggio.RISPOSTA);
  6867.                 }catch(Exception e){
  6868.                    
  6869.                     // STATEFUL
  6870.                     if (msgResponse!=null && !portaStateless && !routingStateless){
  6871.                         try {
  6872.                             // Aggiorno proprietario Messaggio
  6873.                             msgDiag.mediumDebug("Aggiornamento proprietario messaggio risposta ...");
  6874.                             msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  6875.                         }catch(Throwable t) {
  6876.                             // ignore
  6877.                         }
  6878.                     }
  6879.                    
  6880.                     // L'errore viene registrato dentro il metodo mtomProcessor.mtomAfterSecurity
  6881.                     //msgDiag.logErroreGenerico(e,"MTOMProcessor(AfterSec-"+mtomProcessor.getMTOMProcessorType()+")");
  6882.                    
  6883.                     parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6884.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6885.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_557_MTOM_PROCESSOR_ERROR));
  6886.                     parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.ATTACHMENTS_PROCESSING_RESPONSE_FAILED);
  6887.                    
  6888.                     OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6889.                    
  6890.                     // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6891.                     parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6892.                     parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6893.                     ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6894.                     openspcoopstate.releaseResource();
  6895.                     return;
  6896.                 }
  6897.             }
  6898.            
  6899.            
  6900.            
  6901.            
  6902.            
  6903.             /* ------------  Imbustamento (Dopo della Sicurezza)  ------------- */  
  6904.            
  6905.             msgDiag.mediumDebug("Imbustamento della risposta dopo la sicurezza...");
  6906.             try{
  6907.                 if(functionAsRouter &&
  6908.                         !( identitaPdD.getTipo().equals(bustaRisposta.getTipoMittente()) && identitaPdD.getNome().equals(bustaRisposta.getMittente()) )
  6909.                 ){
  6910.                     // Aggiungo trasmissione solo se la busta e' stata generata dalla porta di dominio destinataria della richiesta.
  6911.                     // Se il mittente e' il router, logicamente la busta sara' un errore generato dal router
  6912.                     if( propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDMittente)){
  6913.                         msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  6914.                         ProtocolMessage protocolMessage = imbustatore.addTrasmissione(responseMessage, tras, readQualifiedAttribute,
  6915.                                 FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  6916.                         if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  6917.                             headerBustaRisposta = protocolMessage.getBustaRawContent();
  6918.                             responseMessage = protocolMessage.getMessage(); // updated
  6919.                         }
  6920.                         msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  6921.                     }
  6922.                     // else gia' effettuato nella precedente fase pre-sicurezza
  6923.                 }else{
  6924.                     msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  6925.                     ProtocolMessage protocolMessage = imbustatore.imbustamentoRisposta(responseMessage,pddContext,
  6926.                             bustaRisposta,bustaRichiesta,
  6927.                             infoIntegrazione,gestioneManifestRisposta,scartaBody,proprietaManifestAttachments,
  6928.                             FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  6929.                     if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  6930.                         headerBustaRisposta = protocolMessage.getBustaRawContent();
  6931.                         responseMessage = protocolMessage.getMessage(); // updated
  6932.                     }
  6933.                     msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  6934.                 }
  6935.             }catch(Exception e){
  6936.                
  6937.                 // STATEFUL
  6938.                 if (msgResponse!=null && !portaStateless && !routingStateless){
  6939.                     try {
  6940.                         // Aggiorno proprietario Messaggio
  6941.                         msgDiag.mediumDebug("Aggiornamento proprietario messaggio risposta ...");
  6942.                         msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  6943.                     }catch(Throwable t) {
  6944.                         // ignore
  6945.                     }
  6946.                 }
  6947.                
  6948.                 if(functionAsRouter &&
  6949.                         !( identitaPdD.getTipo().equals(bustaRisposta.getTipoMittente()) && identitaPdD.getNome().equals(bustaRisposta.getMittente()) )
  6950.                 ){
  6951.                     msgDiag.logErroreGenerico(e,"imbustatore.after-security.addTrasmissione(risposta)");
  6952.                 }else{
  6953.                     msgDiag.logErroreGenerico(e,"imbustatore.after-security-imbustamento(risposta)");
  6954.                 }

  6955.                 OpenSPCoop2Message errorOpenSPCoopMsg = null;
  6956.                
  6957.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  6958.                 parametriGenerazioneBustaErrore.setIntegrationFunctionError(IntegrationFunctionError.INTEROPERABILITY_PROFILE_ENVELOPING_RESPONSE_FAILED);
  6959.                 if(e!=null && e instanceof ProtocolException && ((ProtocolException)e).isInteroperabilityError() ) {
  6960.                     parametriGenerazioneBustaErrore.setErroreCooperazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.
  6961.                             getErroreCooperazione(e.getMessage()));
  6962.                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreValidazione(parametriGenerazioneBustaErrore);
  6963.                 }
  6964.                 else {
  6965.                     parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  6966.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_526_GESTIONE_IMBUSTAMENTO));
  6967.                     errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  6968.                 }

  6969.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  6970.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  6971.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  6972.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  6973.                 openspcoopstate.releaseResource();
  6974.                 return;
  6975.             }
  6976.            
  6977.            
  6978.            

  6979.             /* ---------- Tracciamento Busta Ricevuta ------------- */
  6980.             msgDiag.mediumDebug("Tracciamento busta di risposta...");
  6981.             if(this.msgContext.isTracciamentoAbilitato()){
  6982.                 EsitoElaborazioneMessaggioTracciato esitoTraccia =
  6983.                         EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioInviato();
  6984.                 SecurityInfo securityInfoResponse  = null;
  6985.                 if(!functionAsRouter){
  6986.                     if(messageSecurityContext!=null && messageSecurityContext.getDigestReader(responseMessage.getFactory())!=null){
  6987.                         IValidazioneSemantica validazioneSemantica = protocolFactory.createValidazioneSemantica(openspcoopstate.getStatoRichiesta());
  6988.                         securityInfoResponse = validazioneSemantica.readSecurityInformation(messageSecurityContext.getDigestReader(responseMessage.getFactory()),responseMessage);
  6989.                     }
  6990.                 }
  6991.                 tracciamento.registraRisposta(responseMessage,securityInfoResponse,headerBustaRisposta,bustaRisposta,esitoTraccia,
  6992.                         Tracciamento.createLocationString(false,this.msgContext.getSourceLocation()),
  6993.                         correlazioneApplicativa,idCorrelazioneApplicativaRisposta);
  6994.             }
  6995.             IValidatoreErrori validatoreErrori = protocolFactory.createValidatoreErrori(openspcoopstate.getStatoRichiesta());
  6996.             IProtocolManager protocolManager = protocolFactory.createProtocolManager();
  6997.             ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  6998.             pValidazioneErrori.setIgnoraEccezioniNonGravi(protocolManager.isIgnoraEccezioniNonGravi());
  6999.             pValidazioneErrori.setVersioneProtocollo(versioneProtocollo);
  7000.             if( validatoreErrori.isBustaErrore(bustaRisposta,responseMessage,pValidazioneErrori) ) {
  7001.                 if(mittenteAnonimo){
  7002.                     msgDiag.logPersonalizzato("generazioneMessaggioErroreRisposta.mittenteAnonimo");
  7003.                 }
  7004.                 else{
  7005.                     msgDiag.logPersonalizzato("generazioneMessaggioErroreRisposta");
  7006.                 }
  7007.             }else{
  7008.                 if(mittenteAnonimo){
  7009.                     msgDiag.logPersonalizzato("generazioneMessaggioRisposta.mittenteAnonimo");
  7010.                 }
  7011.                 else{
  7012.                     msgDiag.logPersonalizzato("generazioneMessaggioRisposta");
  7013.                 }
  7014.             }
  7015.                

  7016.             /* -------- Elimino accesso daPdD --------- */
  7017.             msgDiag.mediumDebug("Eliminazione accesso da PdD...");
  7018.             repositoryBuste.eliminaUtilizzoPdDFromOutBox(bustaRisposta.getID());

  7019.         }

  7020.        
  7021.        
  7022.        
  7023.        
  7024.        
  7025.        
  7026.        
  7027.         /* ----- Header Integrazione ------ */
  7028.         if(pa!=null){
  7029.             msgDiag.mediumDebug("Gestione header di integrazione messaggio di risposta...");
  7030.             HeaderIntegrazione headerIntegrazioneRisposta = new HeaderIntegrazione(idTransazione);
  7031.             headerIntegrazioneRisposta.setBusta(new HeaderIntegrazioneBusta());
  7032.             headerIntegrazioneRisposta.getBusta().setTipoMittente(bustaRichiesta.getTipoMittente());
  7033.             headerIntegrazioneRisposta.getBusta().setMittente(bustaRichiesta.getMittente());
  7034.             headerIntegrazioneRisposta.getBusta().setTipoDestinatario(bustaRichiesta.getTipoDestinatario());
  7035.             headerIntegrazioneRisposta.getBusta().setDestinatario(bustaRichiesta.getDestinatario());
  7036.             headerIntegrazioneRisposta.getBusta().setTipoServizio(bustaRichiesta.getTipoServizio());
  7037.             headerIntegrazioneRisposta.getBusta().setServizio(bustaRichiesta.getServizio());
  7038.             headerIntegrazioneRisposta.getBusta().setVersioneServizio(bustaRichiesta.getVersioneServizio());
  7039.             headerIntegrazioneRisposta.getBusta().setAzione(bustaRichiesta.getAzione());
  7040.             if(bustaRichiesta.getCollaborazione()!=null) {
  7041.                 headerIntegrazioneRisposta.getBusta().setIdCollaborazione(bustaRichiesta.getCollaborazione());
  7042.             }
  7043.             else if(bustaRisposta!=null && bustaRisposta.getCollaborazione()!=null) {
  7044.                 headerIntegrazioneRisposta.getBusta().setIdCollaborazione(bustaRisposta.getCollaborazione());
  7045.             }
  7046.             headerIntegrazioneRisposta.getBusta().setID(bustaRichiesta.getID());
  7047.             headerIntegrazioneRisposta.getBusta().setProfiloDiCollaborazione(bustaRichiesta.getProfiloDiCollaborazione());
  7048.             headerIntegrazioneRisposta.setIdApplicativo(correlazioneApplicativa);
  7049.                
  7050.             String[] tipiIntegrazionePA_response = null;
  7051.             msgDiag.mediumDebug("Header integrazione...");
  7052.             if(functionAsRouter ){
  7053.                 msgDiag.highDebug("Header integrazione (Default gestori integrazione Router)");
  7054.                 if(RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.containsKey(protocolFactory.getProtocol()))
  7055.                     tipiIntegrazionePA_response = RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.get(protocolFactory.getProtocol());
  7056.                 else
  7057.                     tipiIntegrazionePA_response = RicezioneBuste.defaultGestoriIntegrazionePA;
  7058.             }else{
  7059.                 msgDiag.highDebug("Header integrazione (Gestori integrazione...)");
  7060.                 if(pa!=null && this.msgContext.isTracciamentoAbilitato()){
  7061.                     msgDiag.mediumDebug("Lettura header di integrazione...");
  7062.                     try {
  7063.                         tipiIntegrazionePA_response = configurazionePdDReader.getTipiIntegrazione(pa);
  7064.                     } catch (Exception e) {
  7065.                         msgDiag.logErroreGenerico(e,"configurazionePdDReader.getTipiIntegrazione(pa)");
  7066.                        
  7067.                         parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  7068.                         parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  7069.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE));

  7070.                         OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  7071.                        
  7072.                         // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  7073.                         parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  7074.                         parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  7075.                         ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  7076.                         openspcoopstate.releaseResource();
  7077.                         return;
  7078.                     }
  7079.                     msgDiag.highDebug("Header integrazione (Gestori integrazione terminato)");
  7080.                     if (tipiIntegrazionePA_response == null){
  7081.                         if(RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.containsKey(protocolFactory.getProtocol()))
  7082.                             tipiIntegrazionePA_response = RicezioneBuste.defaultPerProtocolloGestoreIntegrazionePA.get(protocolFactory.getProtocol());
  7083.                         else
  7084.                             tipiIntegrazionePA_response = RicezioneBuste.defaultGestoriIntegrazionePA;
  7085.                     }
  7086.                 }
  7087.             }
  7088.            
  7089.             OutResponsePAMessage outResponsePAMessage = new OutResponsePAMessage();
  7090.             outResponsePAMessage.setBustaRichiesta(bustaRichiesta);
  7091.             outResponsePAMessage.setMessage(responseMessage);
  7092.             Map<String, List<String>> propertiesIntegrazioneRisposta = new HashMap<>();
  7093.             outResponsePAMessage.setHeaders(propertiesIntegrazioneRisposta);
  7094.             outResponsePAMessage.setPortaDelegata(pd);
  7095.             outResponsePAMessage.setPortaApplicativa(pa);
  7096.             outResponsePAMessage.setSoggettoMittente(soggettoFruitore);
  7097.             outResponsePAMessage.setServizio(idServizio);
  7098.            
  7099.             if(tipiIntegrazionePA_response!=null) {
  7100.                 for (int i = 0; i < tipiIntegrazionePA_response.length; i++) {
  7101.                     try {
  7102.                         IGestoreIntegrazionePA gestore = null;
  7103.                         try {
  7104.                             gestore = (IGestoreIntegrazionePA) pluginLoader.newIntegrazionePortaApplicativa(tipiIntegrazionePA_response[i]);
  7105.                         }catch(Exception e){
  7106.                             throw e;
  7107.                         }
  7108.                         if(gestore!=null){
  7109.                             String classType = null;
  7110.                             try {
  7111.                                 classType = gestore.getClass().getName();
  7112.                                 AbstractCore.init(gestore, pddContext, protocolFactory);
  7113.                             } catch (Exception e) {
  7114.                                 throw new Exception(
  7115.                                         "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  7116.                                                 + "] da utilizzare per la gestione dell'integrazione delle erogazioni (Risposta Update/Delete) di tipo ["+ tipiIntegrazionePA_response[i] + "]: " + e.getMessage());
  7117.                             }
  7118.                             if(gestore instanceof IGestoreIntegrazionePASoap){
  7119.                                 if(propertiesReader.deleteHeaderIntegrazioneResponsePA()){
  7120.                                     if(responseMessage==null){
  7121.                                         responseMessage = MessageUtilities.buildEmptyMessage(requestMessage.getFactory(),requestMessage.getMessageType(), MessageRole.RESPONSE);
  7122.                                         outResponsePAMessage.setMessage(responseMessage);
  7123.                                     }
  7124.                                     gestore.setOutResponseHeader(headerIntegrazioneRisposta,outResponsePAMessage);
  7125.                                 }else{
  7126.                                     // gia effettuato l'update dell'header in InoltroBuste
  7127.                                 }
  7128.                             }else{
  7129.                                 if(responseMessage==null){
  7130.                                     responseMessage = MessageUtilities.buildEmptyMessage(requestMessage.getFactory(),requestMessage.getMessageType(), MessageRole.RESPONSE);
  7131.                                     outResponsePAMessage.setMessage(responseMessage);
  7132.                                 }
  7133.                                 gestore.setOutResponseHeader(headerIntegrazioneRisposta,outResponsePAMessage);
  7134.                             }
  7135.                         } else {
  7136.                             throw new Exception("Gestore non inizializzato");
  7137.                         }
  7138.                            
  7139.                     } catch (Exception e) {
  7140.                         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazionePA_response[i]);
  7141.                         msgDiag.addKeywordErroreProcessamento(e);
  7142.                         msgDiag.logPersonalizzato("headerIntegrazione.creazioneFallita");
  7143.                         logError(logCore, msgDiag.getMessaggio_replaceKeywords("headerIntegrazione.creazioneFallita"), e);
  7144.                     }
  7145.                 }
  7146.             }
  7147.            
  7148.             // Imposto header di trasporto per la risposta
  7149.             this.msgContext.setResponseHeaders(propertiesIntegrazioneRisposta);
  7150.            
  7151.         }          
  7152.            
  7153.            



  7154.         // STATELESS
  7155.         if (oneWayStateless || sincronoStateless || asincronoStateless) {
  7156.             msgDiag.mediumDebug("Aggiorno proprietario messaggio richiesta ...");
  7157.             try {
  7158.                 /* Lo stateless che non è onewayVersione11 non salva niente su database */
  7159.                 //msgRequest.setReadyForDrop(true);
  7160.                 //msgRequest.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  7161.                 //repositoryBuste.eliminaBustaStatelessFromInBox(idMessageRequest);

  7162.                 // Committo modifiche (I commit servono per eventuali modifiche ai duplicati)
  7163.                 openspcoopstate.commit();
  7164.             } catch (Exception e) {
  7165.                 logError(logCore, "Riscontrato errore durante l'aggiornamento proprietario messaggio", e);
  7166.                 msgDiag.logErroreGenerico(e, "openspcoopstate.commit(stateless risposta)");
  7167.                
  7168.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  7169.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  7170.                         getErroreIntegrazione());
  7171.                
  7172.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  7173.                
  7174.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  7175.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  7176.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  7177.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  7178.                 openspcoopstate.releaseResource();
  7179.                 return;
  7180.             }
  7181.         }



  7182.         /* ----- OneWay stateful/stateless ibrido ------ */
  7183.         if (oneWayVersione11) {
  7184.             msgDiag.mediumDebug("Commit della gestione oneWay stateful/stateless ibrido ...");
  7185.             try {
  7186.                 // Committo modifiche
  7187.                 openspcoopstate.commit();
  7188.             } catch (Exception e) {
  7189.                 logError(logCore, "Riscontrato errore durante il commit della gestione oneWay stateful/stateless ibrido", e);
  7190.                 msgDiag.logErroreGenerico(e, "openspcoopstate.commit(oneway1.1 risposta)");
  7191.                
  7192.                 parametriGenerazioneBustaErrore.setBusta(bustaRichiesta);
  7193.                 parametriGenerazioneBustaErrore.setErroreIntegrazione(ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  7194.                         getErroreIntegrazione());
  7195.                
  7196.                 OpenSPCoop2Message errorOpenSPCoopMsg = ricezioneBusteGeneratoreBustaErrore.generaBustaErroreProcessamento(parametriGenerazioneBustaErrore,e);
  7197.                
  7198.                 // Nota: la bustaRichiesta e' stata trasformata da generaErroreProcessamento
  7199.                 parametriInvioBustaErrore.setOpenspcoopMsg(errorOpenSPCoopMsg);
  7200.                 parametriInvioBustaErrore.setBusta(parametriGenerazioneBustaErrore.getBusta());
  7201.                 ricezioneBusteGeneratoreBustaErrore.sendRispostaBustaErrore(parametriInvioBustaErrore);
  7202.                 openspcoopstate.releaseResource();
  7203.                 return;
  7204.             }
  7205.         }


  7206.         // STATEFUL
  7207.         if (!portaStateless && !routingStateless){

  7208.             /* ---------- Gestione Transazione Modulo ---------------- */      
  7209.             // Aggiorno proprietario Messaggio
  7210.             msgDiag.mediumDebug("Aggiornamento proprietario messaggio...");
  7211.             if(msgResponse!=null) {
  7212.                 msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  7213.             }

  7214.             // Commit JDBC
  7215.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della risposta...");
  7216.             openspcoopstate.commit();

  7217.             // Aggiornamento cache messaggio
  7218.             if(msgResponse!=null)
  7219.                 msgResponse.addMessaggiIntoCache_readFromTable(RicezioneBuste.ID_MODULO, "risposta");

  7220.             // Aggiornamento cache proprietario messaggio
  7221.             if(msgResponse!=null)
  7222.                 msgResponse.addProprietariIntoCache_readFromTable(RicezioneBuste.ID_MODULO, "risposta",idMessageRequest,functionAsRouter);

  7223.         }





  7224.         // Rilascio connessione al DB
  7225.         msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta effettuato, rilascio della connessione...");
  7226.         openspcoopstate.releaseResource();

  7227.         // Risposta
  7228.         msgDiag.mediumDebug("Imposto risposta nel context...");
  7229.         this.msgContext.setMessageResponse(responseMessage);
  7230.         msgDiag.mediumDebug("Lavoro Terminato.");



  7231.    
  7232.     }
  7233.    
  7234.    







  7235.     private boolean gestioneRispostaAsincrona_checkPresenzaRichiesta(long scadenzaControllo,int checkInterval,Busta bustaRichiesta,
  7236.             IOpenSPCoopState openspcoopstate,MsgDiagnostico msgDiag,boolean newConnectionForResponse,
  7237.             PdDContext pddContext) throws Exception{
  7238.         boolean attendiTerminazioneRichiesta = false;

  7239.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  7240.                
  7241.         // Puo' potenzialmente essere una ricevuta alla richiesta (new connection for response)
  7242.         // o alla risposta (e cmq la risposta l'ho generata io e quindi e' chiaro che ho finito di gestire la richiesta)
  7243.         boolean isRicevutaRichiesta = false;
  7244.         boolean isRicevutaRisposta = false;
  7245.         if(newConnectionForResponse){
  7246.             if( ((org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()))
  7247.                     ||
  7248.                     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()))) &&
  7249.                     bustaRichiesta.getRiferimentoMessaggio()!=null) {  
  7250.                 // Le ricevute hanno il riferimento messaggio anche nelle linee guida!
  7251.                 ProfiloDiCollaborazione profiloCollaborazione = new ProfiloDiCollaborazione(openspcoopstate.getStatoRichiesta(),protocolFactory);
  7252.                 isRicevutaRichiesta = profiloCollaborazione.asincrono_isRicevutaRichiesta(bustaRichiesta.getRiferimentoMessaggio());
  7253.                 isRicevutaRisposta =  profiloCollaborazione.asincrono_isRicevutaRisposta(bustaRichiesta.getRiferimentoMessaggio());
  7254.             }
  7255.         }


  7256.         while( DateManager.getTimeMillis() < scadenzaControllo ){

  7257.             msgDiag.mediumDebug("RICHIESTA  NOW["+DateManager.getTimeMillis()+"] < SCADENZA["+scadenzaControllo+"]");

  7258.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  
  7259.                 if( (bustaRichiesta.getRiferimentoMessaggio()!=null) ||
  7260.                         ( bustaRichiesta.getCollaborazione()!=null && (bustaRichiesta.getCollaborazione().equals(bustaRichiesta.getID())==false) )
  7261.                 ){

  7262.                     if(
  7263.                             ( newConnectionForResponse==false )
  7264.                             ||
  7265.                             ( (!isRicevutaRichiesta) && (!isRicevutaRisposta) )
  7266.                     ){  
  7267.                         String idRichiesta = bustaRichiesta.getRiferimentoMessaggio();
  7268.                         if(idRichiesta==null){
  7269.                             // LineeGuida non sara' presente il riferimentoMessaggio ma l'elemento collaborazione
  7270.                             idRichiesta = bustaRichiesta.getCollaborazione();
  7271.                         }
  7272.                         GestoreMessaggi checkRichiesta = new GestoreMessaggi(openspcoopstate, false, idRichiesta,Costanti.OUTBOX,msgDiag,pddContext);
  7273.                         attendiTerminazioneRichiesta =  checkRichiesta.existsMessageInProcessamento();
  7274.                         if(!attendiTerminazioneRichiesta)
  7275.                             break;
  7276.                         /*else{
  7277.                             String proprietario = checkRichiesta.getProprietario(RicezioneBuste.ID_MODULO);
  7278.                             msgDiag.infoOpenSPCoop("RICHIESTA  ID["+bustaRichiesta.getRiferimentoMessaggio()+"] OUTBOX attendiTerminazioneRichiesta["+attendiTerminazioneRichiesta+"] PROPRIETARIO["+proprietario+"]");
  7279.                         }*/
  7280.                     }else{
  7281.                         break; // si tratta di una ricevuta alla richiesta o alla risposta asincrona simmetrica in un caso di newConnectionForResponse
  7282.                     }
  7283.                 }else{
  7284.                     break; // non si tratta di una risposta asincrona simmetrica, ma di una richiesta
  7285.                 }
  7286.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {
  7287.                 if( (bustaRichiesta.getRiferimentoMessaggio()!=null) ||
  7288.                         ( bustaRichiesta.getCollaborazione()!=null && (bustaRichiesta.getCollaborazione().equals(bustaRichiesta.getID())==false) )
  7289.                 ){

  7290.                     if(
  7291.                             ( newConnectionForResponse==false )
  7292.                             ||
  7293.                             ( (!isRicevutaRichiesta) && (!isRicevutaRisposta) )
  7294.                     ){  
  7295.                         String idRichiesta = bustaRichiesta.getRiferimentoMessaggio();
  7296.                         if(idRichiesta==null){
  7297.                             // LineeGuida non sara' presente il riferimentoMessaggio ma l'elemento collaborazione
  7298.                             idRichiesta = bustaRichiesta.getCollaborazione();
  7299.                         }
  7300.                         GestoreMessaggi checkRichiesta =
  7301.                             new GestoreMessaggi(openspcoopstate, false, idRichiesta,Costanti.INBOX,msgDiag,pddContext);
  7302.                         attendiTerminazioneRichiesta =  checkRichiesta.existsMessageInProcessamento();
  7303.                         if(!attendiTerminazioneRichiesta)
  7304.                             break;
  7305.                         /*else{
  7306.                             String proprietario = checkRichiesta.getProprietario(RicezioneBuste.ID_MODULO);
  7307.                             msgDiag.infoOpenSPCoop("RICHIESTA  ID["+bustaRichiesta.getRiferimentoMessaggio()+"] INBOX attendiTerminazioneRichiesta["+attendiTerminazioneRichiesta+"] PROPRIETARIO["+proprietario+"]");
  7308.                         }*/
  7309.                     }else{
  7310.                         break; // si tratta di una ricevuta alla richiesta o risposta asincrona asimmetrica in un caso di newConnectionForResponse
  7311.                     }
  7312.                 }else{
  7313.                     break; // non si tratta di una richiesta-stato asincrona asimmetrica, ma di una richiesta
  7314.                 }
  7315.             }else{
  7316.                 break;
  7317.             }

  7318.             if(bustaRichiesta.getProfiloDiCollaborazione()!=null){
  7319.                 msgDiag.mediumDebug("Busta di risposta con profilo ["+bustaRichiesta.getProfiloDiCollaborazione().getEngineValue()+"] non gestibile, si attende il completamento" +
  7320.                         " della gestione della richiesta");
  7321.             }
  7322.             else{
  7323.                 msgDiag.mediumDebug("Busta di risposta con profilo null?? non gestibile, si attende il completamento" +
  7324.                         " della gestione della richiesta");
  7325.             }

  7326.             Utilities.sleep(checkInterval);
  7327.         }
  7328.         return attendiTerminazioneRichiesta;
  7329.     }

  7330.     private boolean gestioneRispostaAsincrona_checkPresenzaRicevutaRichiesta(long scadenzaControllo,int checkInterval,Busta bustaRichiesta,
  7331.             IOpenSPCoopState openspcoopstate,MsgDiagnostico msgDiag,boolean newConnectionForResponse,
  7332.             PdDContext pddContext)throws Exception{
  7333.         boolean attendiTerminazioneRicevutaRichiesta = false;

  7334.         IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  7335.        
  7336.         // Puo' potenzialmente essere una ricevuta alla richiesta (new connection for response)
  7337.         // o alla risposta (e cmq la risposta l'ho generata io e quindi e' chiaro che ho finito di gestire la richiesta)
  7338.         boolean isRicevutaRichiesta = false;
  7339.         boolean isRicevutaRisposta = false;
  7340.         if(newConnectionForResponse){
  7341.             if( ((org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()))
  7342.                     ||
  7343.                     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()))) &&
  7344.                     bustaRichiesta.getRiferimentoMessaggio()!=null) {
  7345.                 // Le ricevute hanno il riferimento messaggio anche nelle linee guida!
  7346.                 ProfiloDiCollaborazione profiloCollaborazione = new ProfiloDiCollaborazione(openspcoopstate.getStatoRichiesta(),protocolFactory);
  7347.                 isRicevutaRichiesta = profiloCollaborazione.asincrono_isRicevutaRichiesta(bustaRichiesta.getRiferimentoMessaggio());
  7348.                 isRicevutaRisposta =  profiloCollaborazione.asincrono_isRicevutaRisposta(bustaRichiesta.getRiferimentoMessaggio());
  7349.             }
  7350.         }

  7351.         while( DateManager.getTimeMillis() < scadenzaControllo ){

  7352.             msgDiag.mediumDebug("RICEVUTA RICHIESTA  NOW["+DateManager.getTimeMillis()+"] < SCADENZA["+scadenzaControllo+"]");

  7353.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  
  7354.                 if( (bustaRichiesta.getRiferimentoMessaggio()!=null) ||
  7355.                         ( bustaRichiesta.getCollaborazione()!=null && (bustaRichiesta.getCollaborazione().equals(bustaRichiesta.getID())==false) )
  7356.                 ){

  7357.                     if(
  7358.                             ( newConnectionForResponse==false )
  7359.                             ||
  7360.                             ( (!isRicevutaRichiesta) && (!isRicevutaRisposta) )
  7361.                     ){
  7362.                         String idRicevutaRichiesta = bustaRichiesta.getRiferimentoMessaggio();
  7363.                         if(idRicevutaRichiesta==null){
  7364.                             // LineeGuida non sara' presente il riferimentoMessaggio ma l'elemento collaborazione
  7365.                             idRicevutaRichiesta = bustaRichiesta.getCollaborazione();
  7366.                         }
  7367.                         GestoreMessaggi checkRicevutaRichiesta = new GestoreMessaggi(openspcoopstate, false, idRicevutaRichiesta,Costanti.INBOX,msgDiag,pddContext);
  7368.                         attendiTerminazioneRicevutaRichiesta =  checkRicevutaRichiesta.existsMessageInProcessamentoByReference();
  7369.                         if(!attendiTerminazioneRicevutaRichiesta)
  7370.                             break;
  7371.                         /*else{
  7372.                             String proprietario = checkRicevutaRichiesta.getProprietario(RicezioneBuste.ID_MODULO);
  7373.                             msgDiag.infoOpenSPCoop("RICHIESTA  ID["+bustaRichiesta.getRiferimentoMessaggio()+"] INBOX attendiTerminazioneRichiesta["+attendiTerminazioneRicevutaRichiesta+"] PROPRIETARIO["+proprietario+"]");
  7374.                         }*/
  7375.                     }else{
  7376.                         break; // si tratta di una ricevuta alla richiesta o risposta asincrona simmetrica in un caso di newConnectionForResponse
  7377.                     }
  7378.                 }else{
  7379.                     break; // non si tratta di una risposta asincrona simmetrica, ma di una richiesa
  7380.                 }
  7381.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {
  7382.                 if( (bustaRichiesta.getRiferimentoMessaggio()!=null) ||
  7383.                         ( bustaRichiesta.getCollaborazione()!=null && (bustaRichiesta.getCollaborazione().equals(bustaRichiesta.getID())==false) )
  7384.                 ){

  7385.                     if(
  7386.                             ( newConnectionForResponse==false )
  7387.                             ||
  7388.                             ( (!isRicevutaRichiesta) && (!isRicevutaRisposta) )
  7389.                     ){
  7390.                         String idRicevutaRichiesta = bustaRichiesta.getRiferimentoMessaggio();
  7391.                         if(idRicevutaRichiesta==null){
  7392.                             // LineeGuida non sara' presente il riferimentoMessaggio ma l'elemento collaborazione
  7393.                             idRicevutaRichiesta = bustaRichiesta.getCollaborazione();
  7394.                         }
  7395.                         GestoreMessaggi checkRicevutaRichiesta = new GestoreMessaggi(openspcoopstate, false, idRicevutaRichiesta,Costanti.OUTBOX,msgDiag,pddContext);
  7396.                         attendiTerminazioneRicevutaRichiesta =  checkRicevutaRichiesta.existsMessageInProcessamentoByReference();
  7397.                         if(!attendiTerminazioneRicevutaRichiesta)
  7398.                             break;
  7399.                         /*else{
  7400.                             String proprietario = checkRicevutaRichiesta.getProprietario(RicezioneBuste.ID_MODULO);
  7401.                             msgDiag.infoOpenSPCoop("RICHIESTA  ID["+bustaRichiesta.getRiferimentoMessaggio()+"] OUTBOX attendiTerminazioneRichiesta["+attendiTerminazioneRicevutaRichiesta+"] PROPRIETARIO["+proprietario+"]");
  7402.                         }*/
  7403.                     }else{
  7404.                         break; // si tratta di una ricevuta alla richiesta o risposta asincrona asimmetrica in un caso di newConnectionForResponse
  7405.                     }
  7406.                 }else{
  7407.                     break; // non si tratta di una richiesta-stato asincrona asimmetrica, ma di una richiesta
  7408.                 }
  7409.             }else{
  7410.                 break;
  7411.             }

  7412.             if(bustaRichiesta.getProfiloDiCollaborazione()!=null)
  7413.                 msgDiag.mediumDebug("Busta di risposta con profilo ["+bustaRichiesta.getProfiloDiCollaborazione().getEngineValue()+"] non gestibile, si attende il completamento" +
  7414.                 " della gestione della ricevuta alla richiesta");
  7415.             else{
  7416.                 msgDiag.mediumDebug("Busta di risposta con profilo null??? non gestibile, si attende il completamento" +
  7417.                         " della gestione della ricevuta alla richiesta");
  7418.             }

  7419.             Utilities.sleep(checkInterval);
  7420.         }

  7421.         return attendiTerminazioneRicevutaRichiesta;
  7422.     }


  7423.    

  7424.     private EsitoLib chiamaLibreria(OpenSPCoopStateless openspcoopstate, Logger log) throws OpenSPCoopStateException, GenericLibException{

  7425.         /* --------------------------- SBUSTAMENTO ------------------------ */
  7426.         if (openspcoopstate.getDestinatarioRequestMsgLib().startsWith(Sbustamento.ID_MODULO)) {
  7427.             Sbustamento lib = new Sbustamento(log);
  7428.             return lib.onMessage(openspcoopstate);  
  7429.         }

  7430.         /* ---------------------------ConsegnaContenutiApplicativi----------------------------- */
  7431.         else if (openspcoopstate.getDestinatarioRequestMsgLib().startsWith(ConsegnaContenutiApplicativi.ID_MODULO)) {
  7432.             ConsegnaContenutiApplicativi lib = new ConsegnaContenutiApplicativi(log);
  7433.             EsitoLib result = lib.onMessage(openspcoopstate);
  7434.             if (result.getStatoInvocazione()==EsitoLib.OK) openspcoopstate.setDestinatarioRequestMsgLib("");
  7435.             return result;
  7436.         }

  7437.         /* ----------------------        -ImbustamentoRisposte         ------------------------------- */
  7438.         else if (openspcoopstate.getDestinatarioResponseMsgLib().startsWith(ImbustamentoRisposte.ID_MODULO)) {
  7439.             ImbustamentoRisposte lib = new ImbustamentoRisposte(log);
  7440.             return lib.onMessage(openspcoopstate);
  7441.         }

  7442.         /* ---------------------       -InoltroRisposte----------------------------- */
  7443.         else if (openspcoopstate.getDestinatarioResponseMsgLib().startsWith(InoltroRisposte.ID_MODULO)) {
  7444.             InoltroRisposte lib = new InoltroRisposte(log);
  7445.             return lib.onMessage(openspcoopstate);
  7446.         }

  7447.         else throw new OpenSPCoopStateException(RicezioneBuste.ID_MODULO + ".chiamaLibreria: nome libreria non valido");

  7448.     }
  7449.    
  7450.    
  7451.     private IDServizio getIdServizioPerAutorizzazione(IDServizio idServizio,IDSoggetto soggettoFruitore,
  7452.             boolean functionAsRouter,Busta bustaRichiesta,RuoloBusta ruoloBustaRicevuta) throws Exception{


  7453.         IDSoggetto soggettoDestinatarioPerAutorizzazione = null;
  7454.         if(functionAsRouter){
  7455.             soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7456.                     idServizio.getSoggettoErogatore().getCodicePorta());
  7457.         }
  7458.         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  7459.                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  7460.             soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7461.                     idServizio.getSoggettoErogatore().getCodicePorta());
  7462.         }else if (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  7463.             if(ruoloBustaRicevuta==null){
  7464.                 // router
  7465.                 soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7466.                         idServizio.getSoggettoErogatore().getCodicePorta());
  7467.             }
  7468.             else{
  7469.                 if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString()) || RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  7470.                     soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7471.                             idServizio.getSoggettoErogatore().getCodicePorta());
  7472.                 }else{
  7473.                     if(soggettoFruitore==null){
  7474.                         throw new Exception("Soggetto fruitore non identificato");
  7475.                     }
  7476.                     soggettoDestinatarioPerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7477.                             soggettoFruitore.getCodicePorta());
  7478.                 }  
  7479.             }
  7480.         }else if (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  7481.             if(ruoloBustaRicevuta==null){
  7482.                 // router
  7483.                 soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7484.                         idServizio.getSoggettoErogatore().getCodicePorta());
  7485.             }
  7486.             else{
  7487.                 if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString()) || RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  7488.                     soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7489.                             idServizio.getSoggettoErogatore().getCodicePorta());
  7490.                 }else{
  7491.                     if(soggettoFruitore==null){
  7492.                         throw new Exception("Soggetto fruitore non identificato");
  7493.                     }
  7494.                     soggettoDestinatarioPerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7495.                             soggettoFruitore.getCodicePorta());
  7496.                 }
  7497.             }
  7498.         }else{
  7499.             soggettoDestinatarioPerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7500.                     idServizio.getSoggettoErogatore().getCodicePorta());
  7501.         }

  7502.         IDServizio idServizioPerAutorizzazione = IDServizioFactory.getInstance().
  7503.                 getIDServizioFromValues(idServizio.getTipo(), idServizio.getNome(), soggettoDestinatarioPerAutorizzazione, idServizio.getVersione());
  7504.         idServizioPerAutorizzazione.setUriAccordoServizioParteComune(idServizio.getUriAccordoServizioParteComune());
  7505.         idServizioPerAutorizzazione.setAzione(idServizio.getAzione());
  7506.         idServizioPerAutorizzazione.setTipologia(idServizio.getTipologia());
  7507.        
  7508.         return idServizioPerAutorizzazione;
  7509.     }
  7510.    
  7511.     private IDSoggetto getIDSoggettoMittentePerAutorizzazione(IDServizio idServizio,IDSoggetto soggettoFruitore,
  7512.             boolean functionAsRouter,Busta bustaRichiesta,RuoloBusta ruoloBustaRicevuta, boolean supportatoAutenticazioneSoggetti) throws Exception{
  7513.         IDSoggetto soggettoMittentePerAutorizzazione = null;
  7514.         if(functionAsRouter){
  7515.             if(soggettoFruitore==null){
  7516.                 throw new Exception("Soggetto fruitore non identificato");
  7517.             }
  7518.             soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7519.                     soggettoFruitore.getCodicePorta());
  7520.         }
  7521.         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  7522.                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  7523.             if(soggettoFruitore==null){
  7524.                 if(supportatoAutenticazioneSoggetti){
  7525.                     return null; // invocazione anonima
  7526.                 }else{
  7527.                     throw new Exception("Soggetto fruitore non identificato");      
  7528.                 }
  7529.             }
  7530.             soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7531.                     soggettoFruitore.getCodicePorta());
  7532.         }else if (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  7533.             if(ruoloBustaRicevuta==null){
  7534.                 if(soggettoFruitore==null){
  7535.                     if(supportatoAutenticazioneSoggetti){
  7536.                         return null; // invocazione anonima
  7537.                     }else{
  7538.                         throw new Exception("Soggetto fruitore non identificato");      
  7539.                     }
  7540.                 }
  7541.                 soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7542.                         soggettoFruitore.getCodicePorta());
  7543.             }else{
  7544.                 if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString()) || RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  7545.                     if(soggettoFruitore==null){
  7546.                         if(supportatoAutenticazioneSoggetti){
  7547.                             return null; // invocazione anonima
  7548.                         }else{
  7549.                             throw new Exception("Soggetto fruitore non identificato");      
  7550.                         }
  7551.                     }
  7552.                     soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7553.                             soggettoFruitore.getCodicePorta());
  7554.                 }else{
  7555.                     soggettoMittentePerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7556.                             idServizio.getSoggettoErogatore().getCodicePorta());
  7557.                 }      
  7558.             }
  7559.         }else if (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  7560.             if(ruoloBustaRicevuta==null){
  7561.                 if(soggettoFruitore==null){
  7562.                     if(supportatoAutenticazioneSoggetti){
  7563.                         return null; // invocazione anonima
  7564.                     }else{
  7565.                         throw new Exception("Soggetto fruitore non identificato");      
  7566.                     }
  7567.                 }
  7568.                 soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7569.                         soggettoFruitore.getCodicePorta());
  7570.             }else{
  7571.                 if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString()) || RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  7572.                     if(soggettoFruitore==null){
  7573.                         if(supportatoAutenticazioneSoggetti){
  7574.                             return null; // invocazione anonima
  7575.                         }else{
  7576.                             throw new Exception("Soggetto fruitore non identificato");      
  7577.                         }
  7578.                     }
  7579.                     soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7580.                             soggettoFruitore.getCodicePorta());
  7581.                 }else{
  7582.                     soggettoMittentePerAutorizzazione = new IDSoggetto(idServizio.getSoggettoErogatore().getTipo(),idServizio.getSoggettoErogatore().getNome(),
  7583.                             idServizio.getSoggettoErogatore().getCodicePorta());
  7584.                 }
  7585.             }
  7586.         }else{
  7587.             if(soggettoFruitore==null){
  7588.                 if(supportatoAutenticazioneSoggetti){
  7589.                     return null; // invocazione anonima
  7590.                 }else{
  7591.                     throw new Exception("Soggetto fruitore non identificato");      
  7592.                 }
  7593.             }
  7594.             soggettoMittentePerAutorizzazione = new IDSoggetto(soggettoFruitore.getTipo(),soggettoFruitore.getNome(),
  7595.                     soggettoFruitore.getCodicePorta());
  7596.         }
  7597.         return soggettoMittentePerAutorizzazione;
  7598.     }
  7599.    
  7600.    
  7601.     @SuppressWarnings("deprecation")
  7602.     private void overwriteIdSoggetto(IDServizio idServizio, IDSoggetto idSoggetto){
  7603.         idServizio.setSoggettoErogatore(idSoggetto);
  7604.     }
  7605.     @SuppressWarnings("deprecation")
  7606.     private void cleanDatiServizio(IDServizio idServizio){
  7607.         idServizio.setVersione(null);
  7608.         idServizio.setNome(null);
  7609.         idServizio.setTipo(null);
  7610.     }
  7611. }