RicezioneContenutiApplicativiIntegrationManagerService.java

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

  21. package org.openspcoop2.pdd.services.service;

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

  31. import javax.servlet.http.HttpServletResponse;
  32. import javax.xml.soap.SOAPFault;

  34. import org.openspcoop2.core.config.DumpConfigurazione;
  35. import org.openspcoop2.core.config.PortaDelegata;
  36. import org.openspcoop2.core.constants.TipoPdD;
  37. import org.openspcoop2.core.id.IDPortaDelegata;
  38. import org.openspcoop2.message.OpenSPCoop2Message;
  39. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  40. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  41. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  42. import org.openspcoop2.message.constants.MessageRole;
  43. import org.openspcoop2.message.constants.MessageType;
  44. import org.openspcoop2.message.constants.ServiceBinding;
  45. import org.openspcoop2.message.exception.ParseException;
  46. import org.openspcoop2.message.exception.ParseExceptionUtils;
  47. import org.openspcoop2.message.soap.SoapUtils;
  48. import org.openspcoop2.message.utils.MessageUtilities;
  49. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  50. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  51. import org.openspcoop2.pdd.core.CostantiPdD;
  52. import org.openspcoop2.pdd.core.GestoreMessaggi;
  53. import org.openspcoop2.pdd.core.PdDContext;
  54. import org.openspcoop2.pdd.core.connettori.IConnettore;
  55. import org.openspcoop2.pdd.core.connettori.RepositoryConnettori;
  56. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  57. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  58. import org.openspcoop2.pdd.core.handlers.PostOutResponseContext;
  59. import org.openspcoop2.pdd.core.handlers.PreInAcceptRequestContext;
  60. import org.openspcoop2.pdd.core.handlers.PreInRequestContext;
  61. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  62. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  63. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  64. import org.openspcoop2.pdd.logger.Dump;
  65. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  66. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  67. import org.openspcoop2.pdd.logger.transazioni.ConfigurazioneTracciamento;
  68. import org.openspcoop2.pdd.services.DumpRaw;
  69. import org.openspcoop2.pdd.services.ServicesUtils;
  70. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherInfo;
  71. import org.openspcoop2.pdd.services.connector.ConnectorUtils;
  72. import org.openspcoop2.pdd.services.connector.messages.HttpServletConnectorInMessage;
  73. import org.openspcoop2.pdd.services.connector.messages.HttpServletConnectorOutMessage;
  74. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  75. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativiContext;
  76. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  77. import org.openspcoop2.pdd.services.skeleton.IntegrationManager;
  78. import org.openspcoop2.pdd.services.skeleton.IntegrationManagerException;
  79. import org.openspcoop2.pdd.services.skeleton.IntegrationManagerMessage;
  80. import org.openspcoop2.pdd.services.skeleton.IntegrationManagerUtility;
  81. import org.openspcoop2.pdd.services.skeleton.ProtocolHeaderInfo;
  82. import org.openspcoop2.protocol.basic.registry.ServiceIdentificationReader;
  83. import org.openspcoop2.protocol.engine.SecurityTokenUtilities;
  84. import org.openspcoop2.protocol.engine.URLProtocolContextImpl;
  85. import org.openspcoop2.protocol.engine.constants.Costanti;
  86. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  87. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  88. import org.openspcoop2.protocol.sdk.builder.InformazioniErroriInfrastrutturali;
  89. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  90. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  91. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  92. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  93. import org.openspcoop2.protocol.sdk.constants.IDService;
  94. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  95. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  96. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  97. import org.openspcoop2.protocol.utils.ErroriProperties;
  98. import org.openspcoop2.utils.LimitExceededIOException;
  99. import org.openspcoop2.utils.MapKey;
  100. import org.openspcoop2.utils.TimeoutIOException;
  101. import org.openspcoop2.utils.Utilities;
  102. import org.openspcoop2.utils.date.DateManager;
  103. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  104. import org.openspcoop2.utils.transport.TransportUtils;
  105. import org.slf4j.Logger;

  107. /**
  108.  * RicezioneContenutiApplicativiIntegrationManagerService
  109.  *
  110.  * @author Poli Andrea (apoli@link.it)
  111.  * @author $Author$
  112.  * @version $Rev$, $Date$
  113.  */
  114. public class RicezioneContenutiApplicativiIntegrationManagerService {

  116.     public IntegrationManagerMessage process(String tipoOperazione, String portaDelegata, IntegrationManagerMessage msg,
  117.             String idInvocazionePerRiferimento,
  118.             Logger logCore, javax.servlet.http.HttpServletRequest req, HttpServletResponse res,
  119.             IProtocolFactory<?> protocolFactory, Date dataAccettazioneRichiesta, Date dataIngressoRichiesta) throws IntegrationManagerException {

  121.         String idModulo = RicezioneContenutiApplicativi.ID_MODULO+IntegrationManager.ID_MODULO;
  122.         
  123.         ErroriProperties erroriProperties = null;
  124.         try {
  125.             erroriProperties = ErroriProperties.getInstance(logCore);
  126.         }catch(Exception Ignoree) {
  127.             // non succede
  128.         }
  129.         
  130.         // Proprieta' OpenSPCoop
  131.         OpenSPCoop2Properties openSPCoopProperties = OpenSPCoop2Properties.getInstance();
  132.         if (openSPCoopProperties == null) {
  133.             String msgError = "Inizializzazione di GovWay non correttamente effettuata: OpenSPCoopProperties";
  134.             logCore.error(msgError);
  135.             try{
  136.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  137.                         get5XX_ErroreProcessamento(msgError,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),
  138.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, erroriProperties);
  139.             }catch(Throwable eError){
  140.                 logCore.error("Errore generazione SOAPFault",eError);
  141.                 throw new RuntimeException(eError); // errore che non dovrebbe accadare
  142.             }
  143.         }

  145.         RequestInfo requestInfo = null;
  146.         try{
  147.             // Request Info
  148.             URLProtocolContext urlProtocolContext = new URLProtocolContextImpl(req,logCore,true,true,openSPCoopProperties.getCustomContexts());
  149.             urlProtocolContext.setInterfaceName(portaDelegata);
  150.             if(protocolFactory==null) {
  151.                 throw new Exception("ProtocolFactory is null");
  152.             }
  153.             requestInfo = ConnectorUtils.getRequestInfo(protocolFactory, urlProtocolContext);
  154.             if(requestInfo==null) {
  155.                 throw new Exception("RequestInfo is null");
  156.             }
  157.         }catch(Exception e){
  158.             String msgError = "Lettura RequestInfo non riuscita: "+Utilities.readFirstErrorValidMessageFromException(e);
  159.             logCore.error(msgError);
  160.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  161.                     get5XX_ErroreProcessamento(msgError),
  162.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  163.         }
  164.         
  165.         
  166.         
  167.         
  168.         

  170.         /* ------------  PreInHandler (PreInAcceptRequestContext) ------------- */
  171.         
  172.         // build context
  173.         PreInAcceptRequestContext preInAcceptRequestContext = new PreInAcceptRequestContext();
  174.         preInAcceptRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  175.         preInAcceptRequestContext.setIdModulo(idModulo);
  176.         preInAcceptRequestContext.setRequestInfo(requestInfo);  
  177.         preInAcceptRequestContext.setLogCore(logCore);
  178.         preInAcceptRequestContext.setReq(null);
  179.         
  180.         // invocazione handler
  181.         GestoreHandlers.preInRequest(preInAcceptRequestContext, logCore, logCore);
  182.         
  183.         
  184.         
  185.         
  186.         // Configurazione Reader
  187.         ConfigurazionePdDManager configPdDManager = null;
  188.         try{
  189.             configPdDManager = ConfigurazionePdDManager.getInstance();
  190.             if(configPdDManager==null || configPdDManager.isInitializedConfigurazionePdDReader()==false){
  191.                 throw new Exception("ConfigurazionePdDManager not initialized");
  192.             }
  193.         }catch(Throwable e){
  194.             String msgError = "Inizializzazione di GovWay non correttamente effettuata: ConfigurazionePdDManager";
  195.             logCore.error(msgError,e);
  196.             try{
  197.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  198.                         get5XX_ErroreProcessamento(msgError,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),
  199.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, erroriProperties);
  200.             }catch(Throwable eError){
  201.                 logCore.error("Errore generazione SOAPFault",eError);
  202.                 throw new RuntimeException(eError); // errore che non dovrebbe accadare
  203.             }
  204.         }
  205.             
  206.         
  207.         // Identifico Servizio per comprendere correttamente il messageType
  208.         ServiceIdentificationReader serviceIdentificationReader = null;
  209.         try{
  210.             serviceIdentificationReader = ServicesUtils.getServiceIdentificationReader(logCore, requestInfo,
  211.                     configPdDManager.getRegistroServiziManager(), configPdDManager);
  212.         }catch(Exception e){
  213.             String msgError = "Inizializzazione RegistryReader fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  214.             logCore.error(msgError,e);
  215.             try{
  216.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  217.                         get5XX_ErroreProcessamento(msgError),
  218.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, erroriProperties);
  219.             }catch(Throwable eError){
  220.                 logCore.error("Errore generazione SOAPFault",eError);
  221.                 throw new RuntimeException(eError); // errore che non dovrebbe accadare
  222.             }
  223.         }
  224.         
  225.         // Provo a creare un context (per l'id di transazione nei diagnostici)
  226.         RicezioneContenutiApplicativiContext context = null;
  227.         try {
  228.             context = new RicezioneContenutiApplicativiContext(IDService.PORTA_DELEGATA_INTEGRATION_MANAGER, dataAccettazioneRichiesta,requestInfo);
  229.             String idTransazione = (String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  230.             if(openSPCoopProperties.isTransazioniEnabled()) {
  231.                 TransactionContext.createTransaction(idTransazione, "RicezioneContenutiApplicativiIM.1");
  232.             }
  233.             requestInfo.setIdTransazione(idTransazione);
  234.         }catch(Throwable e) {
  235.             context = null;
  236.             // non loggo l'errore tanto poi provo a ricreare il context subito dopo e li verra' registrato l'errore
  237.         }
  238.         
  239.         // Logger dei messaggi diagnostici
  240.         String nomePorta = portaDelegata;
  241.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.DELEGATA,IntegrationManager.ID_MODULO,nomePorta,requestInfo,configPdDManager);
  242.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_INTEGRATION_MANAGER);
  243.         msgDiag.addKeyword(CostantiPdD.KEY_TIPO_OPERAZIONE_IM, tipoOperazione);
  244.         if(context!=null) {
  245.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  246.         }
  247.         
  248.         try{
  249.             msgDiag.logPersonalizzato("ricezioneRichiesta.firstLog");
  250.         }catch(Exception e){
  251.             logCore.error("Errore generazione diagnostico di ingresso",e);
  252.         }
  253.         
  254.         // emitDiagnostic preAccept handler
  255.         GestoreHandlers.emitDiagnostic(msgDiag, preInAcceptRequestContext, context!=null ? context.getPddContext() : null, 
  256.                 logCore, logCore);
  257.                 
  258.         // GeneratoreErrore
  259.         RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore = null;
  260.         try{
  261.             generatoreErrore = 
  262.                         new RicezioneContenutiApplicativiInternalErrorGenerator(logCore, idModulo, requestInfo);
  263.         }catch(Exception e){
  264.             String msgError = "Inizializzazione Generatore Errore fallita: "+Utilities.readFirstErrorValidMessageFromException(e);
  265.             msgDiag.logErroreGenerico(e,"Inizializzazione Generatore Errore");
  266.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  267.                     get5XX_ErroreProcessamento(msgError),
  268.                     IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, erroriProperties);
  269.         }
  270.         
  271.         // Aggiorno RequestInfo
  272.         try{
  273.             msgDiag.mediumDebug("Accesso configurazione della richiesta in corso...");
  274.         }catch(Exception e){
  275.             logCore.error("Errore generazione diagnostico",e);
  276.         }
  277.         ConnectorDispatcherInfo cInfo = null;
  278.         try{
  279.             cInfo = RicezioneContenutiApplicativiServiceUtils.updatePortaDelegataRequestInfo(requestInfo, logCore, null, null,
  280.                     generatoreErrore, serviceIdentificationReader, msgDiag, 
  281.                     context!=null ? context.getPddContext(): null);
  282.             if(cInfo!=null){
  283.                 try{
  284.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  285.                             getErroreIntegrazione(),
  286.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  287.                 }catch(Throwable eError){
  288.                     logCore.error("Errore generazione SOAPFault",eError);
  289.                     throw new RuntimeException(eError); // errore che non dovrebbe accadare
  290.                 }
  291.             }
  292.         }catch(Exception e){
  293.             String msgError = "Aggiornamento RequestInfo fallito: "+Utilities.readFirstErrorValidMessageFromException(e);
  294.             logCore.error(msgError,e);
  295.             try{
  296.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  297.                         get5XX_ErroreProcessamento(msgError),
  298.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  299.             }catch(Throwable eError){
  300.                 logCore.error("Errore generazione SOAPFault",eError);
  301.                 throw new RuntimeException(eError); // errore che non dovrebbe accadare
  302.             }
  303.         }finally {
  304.             if(cInfo!=null) {
  305.                 RicezioneContenutiApplicativiServiceUtils.emitTransaction(context,logCore, idModulo, IDService.PORTA_DELEGATA_INTEGRATION_MANAGER, protocolFactory, requestInfo,
  306.                         null, dataAccettazioneRichiesta, cInfo);
  307.             }
  308.         }
  309.         
  310.         // DumpRaw
  311.         DumpRaw dumpRaw = null;
  312.         try{
  313.             try{
  314.                 msgDiag.mediumDebug("Lettura configurazione dump binario ...");
  315.             }catch(Exception e){
  316.                 logCore.error("Errore generazione diagnostico",e);
  317.             }
  318.             boolean dumpBinario = configPdDManager.dumpBinarioPD();
  319.             PortaDelegata pd = null;
  320.             if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getInterfaceName()!=null) {
  321.                 IDPortaDelegata idPD = new IDPortaDelegata();
  322.                 idPD.setNome(requestInfo.getProtocolContext().getInterfaceName());
  323.                 pd = configPdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  324.             }
  325.             try{
  326.                 msgDiag.mediumDebug("Lettura configurazione dump ...");
  327.             }catch(Exception e){
  328.                 logCore.error("Errore generazione diagnostico",e);
  329.             }
  330.             DumpConfigurazione dumpConfigurazione = configPdDManager.getDumpConfigurazione(pd);
  331.             ConfigurazioneTracciamento configurazioneTracciamento = new ConfigurazioneTracciamento(logCore, configPdDManager, pd);
  332.             boolean fileTraceHeaders = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioHeaderEnabled();
  333.             boolean fileTracePayload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioPayloadEnabled();
  334.             dumpRaw = new DumpRaw(logCore,requestInfo.getIdentitaPdD(), idModulo, TipoPdD.DELEGATA, 
  335.                     dumpBinario, 
  336.                     dumpConfigurazione,
  337.                     fileTraceHeaders, fileTracePayload);
  338.         }catch(Throwable e){
  339.             String msgError = "Inizializzazione di GovWay non correttamente effettuata: DumpRaw";
  340.             logCore.error(msgError,e);
  341.             try{
  342.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  343.                         get5XX_ErroreProcessamento(msgError,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),
  344.                         IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, erroriProperties);
  345.             }catch(Throwable eError){
  346.                 logCore.error("Errore generazione SOAPFault",eError);
  347.                 throw new RuntimeException(eError); // errore che non dovrebbe accadare
  348.             }
  349.         }


  352.         
  353.         
  354.         
  355.         
  356.         /* ------------  Gestione ------------- */
  357.         
  358.         OpenSPCoopStateful stato = null;
  359.         
  360.         try{
  361.             try{
  362.                 msgDiag.mediumDebug("Creazione contesto ...");
  363.             }catch(Exception e){
  364.                 logCore.error("Errore generazione diagnostico",e);
  365.             }
  366.             // viene generato l'UUID
  367.             if(context==null) {
  368.                 context = new RicezioneContenutiApplicativiContext(IDService.PORTA_DELEGATA_INTEGRATION_MANAGER, dataAccettazioneRichiesta,requestInfo);
  369.             }
  370.             if(preInAcceptRequestContext!=null && preInAcceptRequestContext.getPreContext()!=null && !preInAcceptRequestContext.getPreContext().isEmpty()) {
  371.                 context.getPddContext().addAll(preInAcceptRequestContext.getPreContext(), false);
  372.             }
  373.             context.setDataIngressoRichiesta(dataIngressoRichiesta);
  374.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  375.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO, requestInfo);
  376.             RicezionePropertiesConfig rConfig = RicezioneContenutiApplicativiServiceUtils.readPropertiesConfig(requestInfo, logCore,null);
  377.             if(rConfig!=null) {
  378.                 if (rConfig.getApiImplementation() != null && !rConfig.getApiImplementation().isEmpty()) {
  379.                    context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE, rConfig.getApiImplementation());
  380.                 }
  381.                 if (rConfig.getSoggettoFruitore() != null && !rConfig.getSoggettoFruitore().isEmpty()) {
  382.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_FRUITORE, rConfig.getSoggettoFruitore());
  383.                 }
  384.                 if (rConfig.getSoggettoErogatore() != null && !rConfig.getSoggettoErogatore().isEmpty()) {
  385.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_SOGGETTO_EROGATORE, rConfig.getSoggettoErogatore());
  386.                 }
  387.             }
  388.             context.getPddContext().addObject(CostantiPdD.TIPO_OPERAZIONE_IM, tipoOperazione);
  389.             context.setTipoPorta(TipoPdD.DELEGATA);
  390.             msgDiag.setPddContext(context.getPddContext(), protocolFactory);
  391.             
  392.             if(dumpRaw!=null && dumpRaw.isActiveDump()){
  393.                 dumpRaw.setPddContext(msgDiag.getPorta(), context.getPddContext());
  394.             }
  395.         }catch(Exception e){
  396.             msgDiag.logErroreGenerico(e,"invocaPortaDelegata_engine("+tipoOperazione+").newRicezioneContenutiApplicativiContext()");
  397.             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  398.                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  399.         }
  400.         
  401.         try{
  402.             if(openSPCoopProperties.isTransazioniEnabled()) {
  403.                 // NOTA: se gia' esiste con l'id di transazione, non viene ricreata
  404.                 TransactionContext.createTransaction((String)context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE),"RicezioneContenutiApplicativiIM.2");
  405.             }
  406.         }catch(Exception e){
  407.             logCore.error("Errore durante la creazione della transazione",e);
  408.         }
  409.         
  410.         try{
  411.             msgDiag.logPersonalizzato("ricezioneRichiesta.firstAccessRequestStream");
  412.         }catch(Exception e){
  413.             logCore.error("Errore generazione diagnostico di ingresso (stream access)",e);
  414.         }
  415.         
  416.         if(dumpRaw!=null && dumpRaw.isActiveDump()){
  417.             dumpRaw.serializeContext(context, protocolFactory.getProtocol());
  418.         }
  419.         
  420.         // PddContext
  421.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE,context.getPddContext()); 
  422.         context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, idTransazione);
  423.         context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.TIPO_OPERAZIONE_IM, tipoOperazione.toString());
  424.         context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.ID_MESSAGGIO, idInvocazionePerRiferimento);
  425.         context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PORTA_DELEGATA, portaDelegata);
  426.         context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  427.         
  428.         EsitoTransazione esito = null;
  429.         String errore = null;
  430.         OpenSPCoop2Message msgRequest = null;
  431.         OpenSPCoop2Message msgResponse = null;
  432.         IntegrationManagerMessage msgReturn = null;
  433.         String descrizioneSoapFault = "";
  434.         URLProtocolContext urlProtocolContext = null;
  435.         try{

  437.             
  438.             /* ------------  PreInHandler ------------- */
  439.             
  440.             // build context
  441.             PreInRequestContext preInRequestContext = new PreInRequestContext(context.getPddContext());
  442.             preInRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  443.             preInRequestContext.setIdModulo(idModulo);
  444.             preInRequestContext.setProtocolFactory(protocolFactory);
  445.             preInRequestContext.setRequestInfo(requestInfo);
  446.             Map<String, Object> transportContext = new HashMap<>();
  447.             HttpServletConnectorInMessage httpIn = null;
  448.             try{
  449.                 httpIn = new HttpServletConnectorInMessage(requestInfo, req, IntegrationManager.ID_SERVICE, IntegrationManager.ID_MODULO);
  450.                 transportContext.put(PreInRequestContext.SERVLET_REQUEST, httpIn);
  451.             }catch(Exception e){
  452.                 ConnectorUtils.getErrorLog().error("HttpServletConnectorInMessage init error: "+e.getMessage(),e);
  453.                 /**throw new ServletException(e.getMessage(),e);*/
  454.             }
  455.             HttpServletConnectorOutMessage httpOut = null;
  456.             try{
  457.                 httpOut = new HttpServletConnectorOutMessage(requestInfo, protocolFactory, res, IntegrationManager.ID_SERVICE, IntegrationManager.ID_MODULO);
  458.                 transportContext.put(PreInRequestContext.SERVLET_RESPONSE, httpOut);
  459.             }catch(Exception e){
  460.                 ConnectorUtils.getErrorLog().error("HttpServletConnectorOutMessage init error: "+e.getMessage(),e);
  461.                 /**throw new ServletException(e.getMessage(),e);*/
  462.             }
  463.             preInRequestContext.setTransportContext(transportContext);  
  464.             preInRequestContext.setLogCore(logCore);
  465.             
  466.             // invocazione handler
  467.             GestoreHandlers.preInRequest(preInRequestContext, msgDiag, logCore);
  468.             
  469.             // aggiungo eventuali info inserite nel preInHandler
  470.             context.getPddContext().addAll(preInRequestContext.getPddContext(), false);
  471.             
  472.             // Lettura risposta parametri NotifierInputStream
  473.             NotifierInputStreamParams notifierInputStreamParams = preInRequestContext.getNotifierInputStreamParams();
  474.             context.setNotifierInputStreamParams(notifierInputStreamParams);
  475.             
  476.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.tipologiaMessaggio");
  477.             
  478.             
  479.             
  480.             

  482.             /* ------------  Validazione INPUT in base all'operaizone invocata ------------- */
  483.             if("invocaPortaDelegata".equals(tipoOperazione)){
  484.                 // check presenza body applicativo
  485.                 if(msg==null || msg.getMessage()==null){
  486.                     msgDiag.logPersonalizzato("invocazionePortaDelegata.contenutoApplicativoNonPresente");
  487.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  488.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  489.                             IntegrationFunctionError.BAD_REQUEST, erroriProperties);
  490.                 }
  491.             }
  492.             else if("invocaPortaDelegataPerRiferimento".equals(tipoOperazione)){
  493.                 //   check presenza riferimento
  494.                 if(idInvocazionePerRiferimento==null){
  495.                     msgDiag.logPersonalizzato("invocazionePortaDelegataPerRiferimento.riferimentoMessaggioNonPresente");
  496.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  497.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  498.                             IntegrationFunctionError.BAD_REQUEST, erroriProperties);
  499.                 }
  500.             }
  501.             else if("sendRispostaAsincronaSimmetrica".equals(tipoOperazione)){
  502.                 // check presenza body applicativo
  503.                 if(msg==null || msg.getMessage()==null){
  504.                     msgDiag.logPersonalizzato("invocazionePortaDelegata.contenutoApplicativoNonPresente");
  505.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  506.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  507.                             IntegrationFunctionError.BAD_REQUEST, erroriProperties);
  508.                 }
  509.                 //  check presenza id di correlazione asincrona
  510.                 if(msg.getProtocolHeaderInfo()==null || msg.getProtocolHeaderInfo().getRiferimentoMessaggio()==null){
  511.                     msgDiag.logPersonalizzato("invocazionePortaDelegata.profiloAsincrono.riferimentoMessaggioNonPresente");
  512.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  513.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  514.                             IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND, erroriProperties);
  515.                 }
  516.             }
  517.             else if("sendRichiestaStatoAsincronaAsimmetrica".equals(tipoOperazione)){
  518.                 //  check presenza body applicativo
  519.                 if(msg==null || msg.getMessage()==null){
  520.                     msgDiag.logPersonalizzato("invocazionePortaDelegata.contenutoApplicativoNonPresente");
  521.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  522.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  523.                             IntegrationFunctionError.BAD_REQUEST, erroriProperties);
  524.                 }
  525.                 //  check presenza id di correlazione asincrona
  526.                 if(msg.getProtocolHeaderInfo()==null || msg.getProtocolHeaderInfo().getRiferimentoMessaggio()==null){
  527.                     msgDiag.logPersonalizzato("invocazionePortaDelegata.profiloAsincrono.riferimentoMessaggioNonPresente");
  528.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  529.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  530.                             IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND, erroriProperties);
  531.                 }
  532.             }
  533.             else{
  534.                 throw new Exception("Tipo operazione ["+tipoOperazione+"] non gestita");
  535.             }
  536.             
  537.             
  538.             
  539.             /* ------------  Lettura parametri della richiesta ------------- */
  540.         
  541.             // Credenziali utilizzate nella richiesta
  542.             Credenziali credenziali = new Credenziali(requestInfo.getProtocolContext().getCredential());
  543.             // Credenziali credenziali = (Credenziali) msgContext.get("openspcoop.credenziali");

  545.             String credenzialiFornite = "";
  546.             if(credenziali!=null){
  547.                 credenzialiFornite = credenziali.toString();
  548.                 msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_SA_FRUITORE, credenzialiFornite);
  549.             }

  551.             String invPerRiferimento = "";
  552.             if(idInvocazionePerRiferimento!=null)
  553.                 invPerRiferimento = " idInvocazionePerRiferimento["+idInvocazionePerRiferimento+"]";

  555.             String riferimentoMessaggio = "";
  556.             if(msg.getProtocolHeaderInfo()!=null && msg.getProtocolHeaderInfo().getRiferimentoMessaggio()!=null){
  557.                 riferimentoMessaggio = " riferimentoMessaggio["+msg.getProtocolHeaderInfo().getRiferimentoMessaggio()+"]";
  558.             }

  560.             String param = "PD["+portaDelegata+"]"+credenzialiFornite+invPerRiferimento+riferimentoMessaggio;
  561.             msgDiag.addKeyword(CostantiPdD.KEY_PARAMETRI_OPERAZIONE_IM, param);
  562.             msgDiag.logPersonalizzato("logInvocazioneOperazione");

  564.             
  565.             
  566.             // Properties Trasporto
  567.             Map<String, List<String>> headerTrasporto = null;
  568.             if(openSPCoopProperties.integrationManager_readInformazioniTrasporto()){
  569.                 headerTrasporto = new HashMap<>();
  570.                 java.util.Enumeration<?> enTrasporto = req.getHeaderNames();
  571.                 while(enTrasporto.hasMoreElements()){
  572.                     String nomeHeader = (String)enTrasporto.nextElement();

  574.                     Enumeration<String> enValues = req.getHeaders(nomeHeader);
  575.                     List<String> values = new ArrayList<>();
  576.                     if(enValues!=null) {
  577.                         @SuppressWarnings("unused")
  578.                         int i = 0;
  579.                         while (enValues.hasMoreElements()) {
  580.                             String value = (String) enValues.nextElement();
  581.                             values.add(value);
  582.                             //logCore.info("Header ["+nomeHeader+"] valore-"+i+" ["+value+"]");
  583.                             i++;
  584.                         }
  585.                     }
  586.                     if(values.isEmpty()) {
  587.                         //logCore.info("Header ["+nomeHeader+"] valore ["+req.getHeader(nomeHeader)+"]");
  588.                         values.add(req.getHeader(nomeHeader));
  589.                     }
  590.                     
  591.                     headerTrasporto.put(nomeHeader,values);
  592.                 } 
  593.             }
  594.             
  595.             
  596.             // Parametri della porta delegata invocata
  597.             urlProtocolContext = new URLProtocolContextImpl(logCore);
  598.             urlProtocolContext.setInterfaceName(portaDelegata);
  599.             urlProtocolContext.setFunctionParameters(portaDelegata);
  600.             urlProtocolContext.setRequestURI(portaDelegata);
  601.             urlProtocolContext.setFunction(URLProtocolContext.IntegrationManager_FUNCTION);
  602.             urlProtocolContext.setProtocol(protocolFactory.getProtocol(),
  603.                     requestInfo.getProtocolContext().getProtocolWebContext());
  604.             if(openSPCoopProperties.integrationManager_readInformazioniTrasporto()){
  605.                 urlProtocolContext.setHeaders(headerTrasporto);
  606.             }
  607.             

  609.             //  Messaggio di richiesta
  610.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.inCorso");
  611.             Utilities.printFreeMemory("IntegrationManager - Pre costruzione richiesta");
  612.             if(idInvocazionePerRiferimento!=null){

  614.                 if(dumpRaw!=null && dumpRaw.isActiveDump()){
  615.                     String contentTypeRichiesta = null; // idInvocazionePerRiferimento
  616.                     Integer contentLengthRichiesta = null;
  617.                     String rawMessage = idInvocazionePerRiferimento;
  618.                     dumpRaw.serializeRequest(contentTypeRichiesta, contentLengthRichiesta, requestInfo.getProtocolContext().getCredential(), 
  619.                             urlProtocolContext, rawMessage, null);
  620.                 }
  621.                 
  622.                 stato = new OpenSPCoopStateful();
  623.                 stato.initResource(openSPCoopProperties.getIdentitaPortaDefault(protocolFactory.getProtocol(), requestInfo),IntegrationManager.ID_MODULO,idTransazione);
  624.                 configPdDManager = configPdDManager.refreshState(stato.getStatoRichiesta(),stato.getStatoRisposta());
  625.                 msgDiag.updateState(configPdDManager);
  626.                 
  627.                 // Leggo Messaggio
  628.                 try{
  629.                     GestoreMessaggi gestoreMessaggio = new GestoreMessaggi(stato, true,idInvocazionePerRiferimento,Costanti.INBOX,msgDiag,context.getPddContext());
  630.                     msgRequest = gestoreMessaggio.getMessage(); 
  631.                 }catch(Exception e){
  632.                     msgDiag.logErroreGenerico(e,"gestoreMessaggio.getMessagePerRiferimento("+idInvocazionePerRiferimento+")");
  633.                     throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  634.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_520_READ_MSG_FROM_INTEGRATION_MANAGER),
  635.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  636.                 }

  638.                 // Rilascio Connessione DB
  639.                 stato.releaseResource();
  640.                 stato = null;

  642.             }else{

  644.                 if(dumpRaw!=null && dumpRaw.isActiveDump()){
  645.                     String contentTypeRichiesta = "text/xml"; // per ora e' cablato.
  646.                     Integer contentLengthRichiesta = null;
  647.                     String rawMessage = null;
  648.                     if(msg.getMessage()!=null){
  649.                         try{
  650.                             contentLengthRichiesta = msg.getMessage().length;
  651.                             rawMessage = new String(msg.getMessage());
  652.                         }catch(Throwable t){
  653.                             logCore.error("Dump error: "+t.getMessage(),t);
  654.                         }
  655.                     }
  656.                     dumpRaw.serializeRequest(contentTypeRichiesta, contentLengthRichiesta, requestInfo.getProtocolContext().getCredential(), 
  657.                             urlProtocolContext, rawMessage, null);
  658.                 }
  659.                 
  660.                 // Ricostruzione Messaggio
  661.                 try{
  662.                     MessageType messageType = MessageType.SOAP_11; // todo parametrico
  663.                     String contentType = MessageUtilities.getDefaultContentType(messageType); // todo parametrico
  664.                     String soapAction = "OpenSPCoop"; // todo parametrico
  665.                     ByteArrayInputStream bin = new ByteArrayInputStream(msg.getMessage());
  666.                     
  667.                     OpenSPCoop2MessageParseResult pr = null;
  668.                     OpenSPCoop2MessageFactory factory = org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(logCore,requestInfo, MessageRole.REQUEST);
  669.                     if(msg.getImbustamento()){
  670.                         pr = factory.envelopingMessage(messageType, MessageRole.REQUEST, contentType, soapAction, bin, 
  671.                                 notifierInputStreamParams, openSPCoopProperties.getAttachmentsProcessingMode(), 
  672.                                 openSPCoopProperties.isDeleteInstructionTargetMachineXml(),
  673.                                 openSPCoopProperties.useSoapMessageReader(), openSPCoopProperties.getSoapMessageReaderBufferThresholdKb());
  674.                     }
  675.                     else{
  676.                         pr = factory.createMessage(messageType, MessageRole.REQUEST, contentType, 
  677.                                 bin, notifierInputStreamParams, openSPCoopProperties.getAttachmentsProcessingMode());
  678.                     }
  679.                     if(pr.getParseException()!=null){
  680.                         context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  681.                     }
  682.                     msgRequest = pr.getMessage_throwParseException();
  683.                     msgRequest.setTransportRequestContext(urlProtocolContext);
  684.                 }catch(Exception e){
  685.                     
  686.                     Throwable tParsing = null;
  687.                     ParseException parseException = null;
  688.                     if(context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION)){
  689.                         parseException = (ParseException) context.getPddContext().removeObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  690.                         if(parseException!=null) {
  691.                             tParsing = parseException.getParseException();
  692.                         }
  693.                     }
  694.                     if(tParsing==null){
  695.                         tParsing = ParseExceptionUtils.getParseException(e);
  696.                     }
  697.                     if(tParsing==null){
  698.                         tParsing = e;
  699.                     }
  700.                     
  701.                     String msgErrore = tParsing.getMessage();
  702.                     if(msgErrore==null){
  703.                         msgErrore = tParsing.toString();
  704.                     }
  705.                     
  706.                     context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  707.                     
  708.                     ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();
  709.                     DumpConfigurazione dumpConfig = null;
  710.                     if(portaDelegata!=null) {                           
  711.                         IDPortaDelegata identificativoPortaDelegata = new IDPortaDelegata();
  712.                         identificativoPortaDelegata.setNome(portaDelegata);
  713.                         PortaDelegata portaDelegataObject = configurazionePdDReader.getPortaDelegataSafeMethod(identificativoPortaDelegata, requestInfo);
  714.                         if(portaDelegataObject!=null) {
  715.                             dumpConfig = configurazionePdDReader.getDumpConfigurazione(portaDelegataObject);
  716.                         }
  717.                     }
  718.                     if(dumpConfig==null) {
  719.                         dumpConfig = ConfigurazionePdDManager.getInstance().getDumpConfigurazionePortaDelegata();
  720.                     }
  721.                     
  722.                     Dump dumpApplicativo = new Dump(openSPCoopProperties.getIdentitaPortaDefault(protocolFactory.getProtocol(), requestInfo),
  723.                             IntegrationManager.ID_MODULO,TipoPdD.DELEGATA,portaDelegata,context.getPddContext(),
  724.                             null,null,
  725.                             dumpConfig);
  726.                     dumpApplicativo.dumpRichiestaIngressoByIntegrationManagerError(msg.getMessage(),urlProtocolContext);
  727.                             //IntegrationManager.buildInfoConnettoreIngresso(req, credenziali, urlProtocolContext));
  728.                     
  729.                     IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  730.                     if( parseException!=null && parseException.getSourceException()!=null &&
  731.                             TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  732.                         integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  733.                     }
  734.                     else if( parseException!=null && parseException.getSourceException()!=null &&
  735.                             LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  736.                         integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  737.                     }
  738.                     
  739.                     if(msg.getImbustamento()==false){
  740.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  741.                         msgDiag.logPersonalizzato("buildMsg.nonRiuscito");
  742.                         throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_421_MSG_SOAP_NON_COSTRUIBILE_TRAMITE_RICHIESTA_APPLICATIVA.
  743.                                 getErrore421_MessaggioSOAPNonGenerabile(msgErrore),
  744.                                 integrationFunctionError, erroriProperties);
  745.                     } else {
  746.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  747.                         msgDiag.logPersonalizzato("buildMsg.imbustamentoSOAP.nonRiuscito");
  748.                         throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_422_IMBUSTAMENTO_SOAP_NON_RIUSCITO_RICHIESTA_APPLICATIVA.
  749.                                 getErrore422_MessaggioSOAPNonGenerabileTramiteImbustamentoSOAP(msgErrore),
  750.                                 integrationFunctionError, erroriProperties);
  751.                     }
  752.                 }
  753.             }
  754.             Utilities.printFreeMemory("IntegrationManager - Post costruzione richiesta");
  755.             if(msgRequest!=null) {
  756.                 msgRequest.setProtocolName(protocolFactory.getProtocol());
  757.                 msgRequest.setTransactionId( idTransazione);
  758.                 Object nomePortaInvocataObject = context.getPddContext().getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  759.                 if(nomePortaInvocataObject!=null && nomePortaInvocataObject instanceof String) {
  760.                     msgRequest.addContextProperty(CostantiPdD.NOME_PORTA_INVOCATA, (String) nomePortaInvocataObject );
  761.                 }
  762.             }

  764.             


  767.             //  Costruisco HeaderIntegrazione IntegrationManager
  768.             HeaderIntegrazione headerIntegrazioneRichiesta = new HeaderIntegrazione(idTransazione);


  771.             // Identificazione Porta Delegata INPUT-BASED
  772.             ProtocolHeaderInfo protocolHeaderInfo = msg.getProtocolHeaderInfo();
  773.             if(protocolHeaderInfo!=null){

  775.                 if(protocolHeaderInfo.getTipoMittente()!=null && (!"".equals(protocolHeaderInfo.getTipoMittente())))
  776.                     headerIntegrazioneRichiesta.getBusta().setTipoMittente(protocolHeaderInfo.getTipoMittente());
  777.                 if(protocolHeaderInfo.getMittente()!=null && (!"".equals(protocolHeaderInfo.getMittente())))
  778.                     headerIntegrazioneRichiesta.getBusta().setMittente(protocolHeaderInfo.getMittente());

  780.                 if(protocolHeaderInfo.getTipoDestinatario()!=null && (!"".equals(protocolHeaderInfo.getTipoDestinatario())))
  781.                     headerIntegrazioneRichiesta.getBusta().setTipoDestinatario(protocolHeaderInfo.getTipoDestinatario());
  782.                 if(protocolHeaderInfo.getDestinatario()!=null && (!"".equals(protocolHeaderInfo.getDestinatario())))
  783.                     headerIntegrazioneRichiesta.getBusta().setDestinatario(protocolHeaderInfo.getDestinatario());

  785.                 if(protocolHeaderInfo.getTipoServizio()!=null && (!"".equals(protocolHeaderInfo.getTipoServizio())))
  786.                     headerIntegrazioneRichiesta.getBusta().setTipoServizio(protocolHeaderInfo.getTipoServizio());
  787.                 if(protocolHeaderInfo.getServizio()!=null && (!"".equals(protocolHeaderInfo.getServizio())))
  788.                     headerIntegrazioneRichiesta.getBusta().setServizio(protocolHeaderInfo.getServizio());

  790.                 if(protocolHeaderInfo.getAzione()!=null && (!"".equals(protocolHeaderInfo.getAzione())))
  791.                     headerIntegrazioneRichiesta.getBusta().setAzione(protocolHeaderInfo.getAzione());

  793.                 if(protocolHeaderInfo.getID()!=null && (!"".equals(protocolHeaderInfo.getID())))
  794.                     headerIntegrazioneRichiesta.getBusta().setID(protocolHeaderInfo.getID());

  796.                 if(protocolHeaderInfo.getIdCollaborazione()!=null && (!"".equals(protocolHeaderInfo.getIdCollaborazione())))
  797.                     headerIntegrazioneRichiesta.getBusta().setIdCollaborazione(protocolHeaderInfo.getIdCollaborazione());

  799.                 if(protocolHeaderInfo.getRiferimentoMessaggio()!=null && (!"".equals(protocolHeaderInfo.getRiferimentoMessaggio())))
  800.                     headerIntegrazioneRichiesta.getBusta().setRiferimentoMessaggio(protocolHeaderInfo.getRiferimentoMessaggio());
  801.             }
  802.             if(msg.getIdApplicativo()!=null && (!"".equals(msg.getIdApplicativo())))
  803.                 headerIntegrazioneRichiesta.setIdApplicativo(msg.getIdApplicativo());
  804.             if(msg.getServizioApplicativo()!=null && (!"".equals(msg.getServizioApplicativo())))
  805.                 headerIntegrazioneRichiesta.setServizioApplicativo(msg.getServizioApplicativo());

  807.             //  Contesto di Richiesta
  808.             context.setTipoPorta(TipoPdD.DELEGATA);
  809.             context.setCredenziali(credenziali);
  810.             context.setIdModulo(idModulo);
  811.             context.setGestioneRisposta(true); // siamo in un webServices, la risposta deve essere aspettata
  812.             context.setInvocazionePDPerRiferimento(idInvocazionePerRiferimento!=null);
  813.             context.setIdInvocazionePDPerRiferimento(idInvocazionePerRiferimento);
  814.             context.setMessageRequest(msgRequest);
  815.             context.setUrlProtocolContext(urlProtocolContext);
  816.             context.setHeaderIntegrazioneRichiesta(headerIntegrazioneRichiesta);
  817.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME, protocolFactory.getProtocol());
  818.             context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO, requestInfo);
  819.             context.setProprietaErroreAppl(generatoreErrore.getProprietaErroreAppl());
  820.             if(context.getMsgDiagnostico()==null) {
  821.                 context.setMsgDiagnostico(msgDiag);
  822.             }
  823.             
  824.             
  825.             /* --------------- SecurityToken --------------- */
  826.             try {
  827.                 if(requestInfo!=null && requestInfo.getProtocolContext()!=null && requestInfo.getProtocolContext().getCredential()!=null && 
  828.                         requestInfo.getProtocolContext().getCredential().getCertificate()!=null &&
  829.                         requestInfo.getProtocolContext().getCredential().getCertificate().getCertificate()!=null) {
  830.                     SecurityTokenUtilities.newSecurityToken(context.getPddContext());
  831.                 }
  832.             }catch(Exception e){
  833.                 logCore.error("Costruzione SecurityToken non riuscito: "+e.getMessage(),e);
  834.             }
  835.             
  836.             // Log elaborazione dati completata
  837.             msgDiag.logPersonalizzato("ricezioneRichiesta.elaborazioneDati.completata");
  838.             
  839.             // Invocazione...
  840.             RicezioneContenutiApplicativi gestoreRichiesta = new RicezioneContenutiApplicativi(context,generatoreErrore);
  841.             gestoreRichiesta.process(req);
  842.             msgResponse = context.getMessageResponse();
  843.             if(context.getMsgDiagnostico()!=null){
  844.                 msgDiag = context.getMsgDiagnostico();
  845.                 // Aggiorno informazioni
  846.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_OPERAZIONE_IM, tipoOperazione);
  847.             }

  849.             // Check parsing request
  850.             if((msgRequest!=null && msgRequest.getParseException() != null) || 
  851.                     (context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  852.             
  853.                 // Senno l'esito viene forzato essere 5XX
  854.                 try{
  855.                     esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext,EsitoTransazioneName.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO);
  856.                 }catch(Exception eBuildError){
  857.                     esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  858.                 }
  859.                 
  860.                 context.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  861.                 ParseException parseException = null;
  862.                 if( msgRequest!=null && msgRequest.getParseException() != null ){
  863.                     parseException = msgRequest.getParseException();
  864.                 }
  865.                 else{
  866.                     parseException = (ParseException) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  867.                 }
  868.                 String msgErrore = null;
  869.                 if(parseException!=null && parseException.getParseException()!=null) {
  870.                     msgErrore = parseException.getParseException().getMessage();
  871.                     if(msgErrore==null){
  872.                         msgErrore = parseException.getParseException().toString();
  873.                     }
  874.                 }   
  875.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  876.                 if(parseException!=null) {
  877.                     logCore.error("parsingExceptionRichiesta",parseException.getSourceException());
  878.                 }
  879. //              msgDiag.logPersonalizzato("parsingExceptionRichiesta");
  880. //              throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.
  881. //                      getErrore432_MessaggioRichiestaMalformato(parseException.getParseException()));
  882.                 // Per l'IntegrationManager esiste un codice specifico
  883.                 
  884.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.UNPROCESSABLE_REQUEST_CONTENT;
  885.                 if( parseException!=null && parseException.getSourceException()!=null &&
  886.                         TimeoutIOException.isTimeoutIOException(parseException.getSourceException())) {
  887.                     integrationFunctionError = IntegrationFunctionError.REQUEST_TIMED_OUT;
  888.                 }
  889.                 else if( parseException!=null && parseException.getSourceException()!=null &&
  890.                         LimitExceededIOException.isLimitExceededIOException(parseException.getSourceException())) {
  891.                     integrationFunctionError = IntegrationFunctionError.REQUEST_SIZE_EXCEEDED;
  892.                 }
  893.                 
  894.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_INTEGRATION_MANAGER,"buildMsg.nonRiuscito");
  895.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_421_MSG_SOAP_NON_COSTRUIBILE_TRAMITE_RICHIESTA_APPLICATIVA.
  896.                         getErrore421_MessaggioSOAPNonGenerabile(msgErrore),
  897.                         integrationFunctionError, erroriProperties);
  898.             }
  899.             
  900.             // Raccolgo l'eventuale header di integrazione
  901.             Map<String, List<String>> headerIntegrazioneRisposta = context.getResponseHeaders();
  902.             ProtocolHeaderInfo protocolHeaderInfoResponse = null; 
  903.             if(headerIntegrazioneRisposta!=null){
  904.                 Map<MapKey<String>,String> keyValue = openSPCoopProperties.getKeyValue_HeaderIntegrazioneTrasporto();
  905.                 protocolHeaderInfoResponse = new ProtocolHeaderInfo();

  907.                 protocolHeaderInfoResponse.setID(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_ID_MESSAGGIO)));
  908.                 protocolHeaderInfoResponse.setRiferimentoMessaggio(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_RIFERIMENTO_MESSAGGIO)));
  909.                 protocolHeaderInfoResponse.setIdCollaborazione(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_COLLABORAZIONE)));

  911.                 protocolHeaderInfoResponse.setMittente(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_MITTENTE)));
  912.                 protocolHeaderInfoResponse.setTipoMittente(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_MITTENTE)));

  914.                 protocolHeaderInfoResponse.setDestinatario(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_DESTINATARIO)));
  915.                 protocolHeaderInfoResponse.setTipoDestinatario(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_DESTINATARIO)));

  917.                 protocolHeaderInfoResponse.setServizio(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_SERVIZIO)));
  918.                 protocolHeaderInfoResponse.setTipoServizio(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_TIPO_SERVIZIO)));

  920.                 protocolHeaderInfoResponse.setAzione(TransportUtils.getFirstValue(headerIntegrazioneRisposta,keyValue.get(CostantiPdD.HEADER_INTEGRAZIONE_AZIONE)));
  921.             }

  923.             InformazioniErroriInfrastrutturali informazioniErrori = ServicesUtils.readInformazioniErroriInfrastrutturali(context.getPddContext());
  924.             
  925.             //  IntepretazioneRisposta
  926.             if(msgResponse!=null){
  927.                 
  928.                 esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext,
  929.                         200, requestInfo.getIntegrationServiceBinding(),
  930.                          msgResponse, 
  931.                         context.getProprietaErroreAppl(), informazioniErrori, 
  932.                         context.getPddContext()!=null ? context.getPddContext() : null);            
  933.                                                 
  934.                 IntegrationManagerException exc = null;
  935.                 try{
  936.                     if(ServiceBinding.SOAP.equals(msgResponse.getServiceBinding())){
  937.                         OpenSPCoop2SoapMessage soapMessage = msgResponse.castAsSoap();
  938.                         if(soapMessage.hasSOAPFault()){
  939.     
  940.                             descrizioneSoapFault = " ("+SoapUtils.safe_toString(soapMessage.getFactory(), soapMessage.getSOAPBody().getFault(), false, logCore)+")";
  941.                             
  942.                             // Potenziale MsgErroreApplicativo
  943.                             SOAPFault fault = soapMessage.getSOAPBody().getFault();
  944.                             ProprietaErroreApplicativo pea = context.getProprietaErroreAppl();
  945.                             if(pea!=null && fault.getFaultActor()!=null && fault.getFaultActor().equals(pea.getFaultActor())){
  946.                                 String prefix = org.openspcoop2.protocol.basic.Costanti.ERRORE_INTEGRAZIONE_PREFIX_CODE;
  947.                                 if(context.getProprietaErroreAppl().getFaultPrefixCode()!=null){
  948.                                     prefix = context.getProprietaErroreAppl().getFaultPrefixCode();
  949.                                 }
  950.                                 
  951.                                 String faultCode = null;
  952.                                 if(fault.getFaultCodeAsQName()!=null) {
  953.                                     faultCode = fault.getFaultCodeAsQName().getLocalPart();
  954.                                 }
  955.                                 else {
  956.                                     faultCode = fault.getFaultCode();
  957.                                 }
  958.                                 exc = IntegrationManagerUtility.mapMessageIntoProtocolException(soapMessage, faultCode, fault.getFaultString(), 
  959.                                                 requestInfo.getIdentitaPdD(), idModulo);
  960.                                 if(exc==null) {// non si dovrebbe arrivare a questo if
  961.                                     if(openSPCoopProperties.isErroreApplicativoIntoDetails() && fault.getDetail()!=null){
  962.                                         exc = IntegrationManagerUtility.mapXMLIntoProtocolException(protocolFactory,fault.getDetail().getFirstChild(),
  963.                                                 prefix, 
  964.                                                 IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  965.                                     }else{
  966.                                         exc = IntegrationManagerUtility.mapXMLIntoProtocolException(protocolFactory,fault.getFaultString(),
  967.                                                 prefix, 
  968.                                                 IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  969.                                     }
  970.                                 }
  971.                                 if(exc== null)
  972.                                     throw new Exception("Costruzione Eccezione fallita: null");
  973.                             }
  974.                         }
  975.                     }
  976.                 }catch(Exception e){
  977.                     try{
  978.                         if( (msgResponse!=null && msgResponse.getParseException() != null) ||
  979.                                 (context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  980.                             informazioniErrori.setContenutoRispostaNonRiconosciuto(true);
  981.                             ParseException parseException = null;
  982.                             if( msgResponse!=null && msgResponse.getParseException() != null ){
  983.                                 parseException = msgResponse.getParseException();
  984.                             }
  985.                             else{
  986.                                 parseException = (ParseException) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  987.                             }
  988.                             String msgErrore = parseException.getParseException().getMessage();
  989.                             if(msgErrore==null){
  990.                                 msgErrore = parseException.getParseException().toString();
  991.                             }
  992.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  993.                             logCore.error("parsingExceptionRisposta",parseException.getSourceException());
  994.                             msgDiag.logPersonalizzato("parsingExceptionRisposta");
  995.                             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  996.                                     getErrore440_MessaggioRispostaMalformato(parseException.getParseException()),
  997.                                     IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT, erroriProperties);
  998.                         }
  999.                         else{
  1000.                             msgDiag.logErroreGenerico(e,"buildProtocolException("+tipoOperazione+")");
  1001.                             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1002.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_524_CREAZIONE_PROTOCOL_EXCEPTION),
  1003.                                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  1004.                         }
  1005.                     }finally{
  1006.                         // ricalcolo esito
  1007.                         esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext, 
  1008.                                 500, requestInfo.getIntegrationServiceBinding(),
  1009.                                 msgResponse, 
  1010.                                 context.getProprietaErroreAppl(), informazioniErrori, 
  1011.                                 (context.getPddContext()!=null ? context.getPddContext() : null));      
  1012.                     }
  1013.                 }   
  1014.                 if(exc!=null){
  1015.                     throw exc;
  1016.                 }

  1018.                 // Se non ho lanciato l'eccezione, costruisco una risposta
  1019.                 try{
  1020.                     msgReturn = new IntegrationManagerMessage(msgResponse,false);
  1021.                 }catch(Exception e){
  1022.                     try{
  1023.                         if( (msgResponse!=null && msgResponse.getParseException() != null) ||
  1024.                                 (context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION))){
  1025.                             informazioniErrori.setContenutoRispostaNonRiconosciuto(true);
  1026.                             ParseException parseException = null;
  1027.                             if( msgResponse!=null && msgResponse.getParseException() != null ){
  1028.                                 parseException = msgResponse.getParseException();
  1029.                             }
  1030.                             else{
  1031.                                 parseException = (ParseException) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  1032.                             }
  1033.                             String msgErrore = parseException.getParseException().getMessage();
  1034.                             if(msgErrore==null){
  1035.                                 msgErrore = parseException.getParseException().toString();
  1036.                             }
  1037.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1038.                             logCore.error("parsingExceptionRisposta",parseException.getSourceException());
  1039.                             msgDiag.logPersonalizzato("parsingExceptionRisposta");
  1040.                             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_440_PARSING_EXCEPTION_RISPOSTA.
  1041.                                     getErrore440_MessaggioRispostaMalformato(parseException.getParseException()),
  1042.                                     IntegrationFunctionError.UNPROCESSABLE_RESPONSE_CONTENT, erroriProperties);
  1043.                         }
  1044.                         else{
  1045.                             msgDiag.logErroreGenerico(e,"buildMessage_response("+tipoOperazione+")");
  1046.                             throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1047.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_523_CREAZIONE_PROTOCOL_MESSAGE),
  1048.                                     IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  1049.                         }
  1050.                     }finally{
  1051.                         // ricalcolo esito
  1052.                         esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext, 
  1053.                                 500, requestInfo.getIntegrationServiceBinding(),
  1054.                                 msgResponse, 
  1055.                                 context.getProprietaErroreAppl(), informazioniErrori, 
  1056.                                 (context.getPddContext()!=null ?context.getPddContext() : null));       
  1057.                     }
  1058.                 }
  1059.                 
  1060.                 msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, descrizioneSoapFault);
  1061.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI,"integrationManager.consegnaRispostaApplicativaEffettuata");
  1062.                 
  1063.             }else{
  1064.                 /*
  1065.                 // Con la nuova versione di RicezioneContenutiApplicativi, in caso di oneway non viene ritornato un messaggio SOAP empty, ma proprio null
  1066.                 // Una risposta deve esistere per forza.
  1067.                 msgDiag.logErroreGenerico("Risposta non presente","gestioneRisposta("+tipoOperazione+")");
  1068.                 throw new IntegrationManagerException(CostantiPdD.CODICE_511_READ_RESPONSE_MSG,
  1069.                         CostantiPdD.MSG_5XX_SISTEMA_NON_DISPONIBILE);
  1070.                 */
  1071.                 msgReturn = new IntegrationManagerMessage();
  1072.                 
  1073.                 esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext, 
  1074.                         200, requestInfo.getIntegrationServiceBinding(),
  1075.                         msgResponse, 
  1076.                         context.getProprietaErroreAppl(), informazioniErrori, 
  1077.                         (context.getPddContext()!=null ? context.getPddContext() : null));  
  1078.                 // ok oneway
  1079.                 
  1080.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI,"integrationManager.consegnaRispostaApplicativaVuota");
  1081.             }       

  1083.             msgReturn.setProtocolHeaderInfo(protocolHeaderInfoResponse);
  1084.             
  1085.             if(dumpRaw!=null && dumpRaw.isActiveDump()){
  1086.                 String contentTypeRisposta = "text/xml"; // per ora e' cablato.
  1087.                 String rawMessage = null;
  1088.                 Integer contentLengthRisposta = null;
  1089.                 if(msgReturn.getMessage()!=null){
  1090.                     try{
  1091.                         contentLengthRisposta = msgReturn.getMessage().length;
  1092.                         rawMessage = new String(msgReturn.getMessage());
  1093.                     }catch(Throwable t){
  1094.                         logCore.error("Dump error: "+t.getMessage(),t);
  1095.                     }
  1096.                 }
  1097.                 dumpRaw.serializeResponse(rawMessage, null, null, contentLengthRisposta, contentTypeRisposta, 200);
  1098.             }
  1099.             
  1100.             return msgReturn;
  1101.             
  1102.         }catch(Exception e){
  1103.             
  1104.             if(dumpRaw!=null && dumpRaw.isActiveDump()){
  1105.                 String contentTypeRisposta = "text/xml"; // per ora e' cablato.
  1106.                 String rawMessage = "[Exception "+e.getClass().getName()+"]: "+ e.getMessage(); // Non riesco ad avere il marshal xml della risposta ritornata
  1107.                 Integer contentLengthRisposta = null;
  1108.                 dumpRaw.serializeResponse(rawMessage, null,null, contentLengthRisposta, contentTypeRisposta, 500);
  1109.             }
  1110.             
  1111.             errore = e.getMessage();
  1112.             msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, descrizioneSoapFault);
  1113.             
  1114.             // Controllo Eccezioni
  1115.             if(e instanceof IntegrationManagerException){
  1116.                 // Lanciata all'interno del metodo
  1117.                 
  1118.                 if(esito==null){
  1119.                     // Altrimenti l'esito era settato
  1120.                     try{
  1121.                         esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext,EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1122.                     }catch(Exception eBuildError){
  1123.                         esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1124.                     }
  1125.                 }
  1126.                 
  1127.                 IntegrationManagerException eSPC = (IntegrationManagerException)e;
  1128.                 //String prefix = eSPC.getProprietaErroreApplicativo().getFaultPrefixCode();
  1129.                 //boolean isFaultAsGenericCode = eSPC.getProprietaErroreApplicativo().isFaultAsGenericCode();
  1130.                 if(descrizioneSoapFault!=null && !"".equals(descrizioneSoapFault)){
  1131.                     // stesse informazioni presenti gia nel fault
  1132.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA,"ProtocolException/"+eSPC.getCodiceEccezione());
  1133.                 }else{
  1134.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA,"ProtocolException/"+eSPC.getCodiceEccezione() + " " + eSPC.getDescrizioneEccezione());
  1135.                 }
  1136.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI,"integrationManager.consegnaRispostaApplicativaFallita");
  1137.                 
  1138.                 throw eSPC;
  1139.             }else{
  1140.                 msgDiag.logErroreGenerico(e,"invocaPortaDelegata("+tipoOperazione+")");
  1141.                 try{
  1142.                     esito = protocolFactory.createEsitoBuilder().getEsito(urlProtocolContext,EsitoTransazioneName.ERRORE_PROCESSAMENTO_PDD_5XX);
  1143.                 }catch(Exception eBuildError){
  1144.                     esito = EsitoTransazione.ESITO_TRANSAZIONE_ERROR;
  1145.                 }
  1146.                 
  1147.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA,errore);
  1148.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI,"integrationManager.consegnaRispostaApplicativaFallita");
  1149.                 
  1150.                 throw new IntegrationManagerException(protocolFactory,ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  1151.                         IntegrationFunctionError.INTERNAL_REQUEST_ERROR, erroriProperties);
  1152.             }
  1153.             
  1154.         }finally{
  1155.             
  1156.             try{
  1157.                 if(stato!=null)
  1158.                     stato.releaseResource();
  1159.             }catch(Exception eClose){}
  1160.             
  1161.             
  1162.             
  1163.             
  1164.             // *** Chiudo connessione verso PdD Destinazione per casi stateless ***
  1165.             String location = "...";
  1166.             try{
  1167.                 IConnettore c = null;
  1168.                 //if(context!=null && context.getIdMessage()!=null){
  1169.                 if(idTransazione!=null) {
  1170.                     c = RepositoryConnettori.removeConnettorePD(
  1171.                             //context.getIdMessage()
  1172.                             idTransazione);
  1173.                 }
  1174.                 if(c!=null){
  1175.                     location = c.getLocation();
  1176.                     c.disconnect();
  1177.                 }
  1178.             }catch(Exception e){
  1179.                 msgDiag.logDisconnectError(e, location);
  1180.             }
  1181.             
  1182.             
  1183.             
  1184.             
  1185.             /* ------------  PostOutResponseHandler ------------- */
  1186.             PostOutResponseContext postOutResponseContext = new PostOutResponseContext(logCore, protocolFactory);
  1187.             try{
  1188.                 context.getPddContext().addObject(CostantiPdD.DATA_ACCETTAZIONE_RICHIESTA, dataAccettazioneRichiesta);
  1189.                 if(dataIngressoRichiesta!=null){
  1190.                     context.getPddContext().addObject(CostantiPdD.DATA_INGRESSO_RICHIESTA, dataIngressoRichiesta);
  1191.                 }
  1192.                 postOutResponseContext.setPddContext(context.getPddContext());
  1193.                 postOutResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  1194.                 postOutResponseContext.setDataPrimaSpedizioneRisposta(DateManager.getDate());
  1195.                 postOutResponseContext.setDataRispostaSpedita(DateManager.getDate());
  1196.                 postOutResponseContext.setEsito(esito);
  1197.                 postOutResponseContext.setMessaggio(msgResponse);
  1198.                 
  1199.                 if(msgRequest!=null){
  1200.                     postOutResponseContext.setInputRequestMessageSize(msgRequest.getIncomingMessageContentLength());
  1201.                     postOutResponseContext.setOutputRequestMessageSize(msgRequest.getOutgoingMessageContentLength());
  1202.                 }else{
  1203.                     if(msg!=null && msg.getMessage()!=null)
  1204.                         postOutResponseContext.setInputRequestMessageSize(Long.valueOf(msg.getMessage().length));
  1205.                 }
  1206.                 if(msgResponse!=null){
  1207.                     postOutResponseContext.setInputResponseMessageSize(msgResponse.getIncomingMessageContentLength());
  1208.                     if(msgReturn!=null && msgReturn.getMessage()!=null)
  1209.                         postOutResponseContext.setOutputResponseMessageSize(Long.valueOf(msgReturn.getMessage().length));
  1210.                 }
  1211.                 
  1212.                 if(errore!=null){
  1213.                     postOutResponseContext.setReturnCode(500);
  1214.                 }else{
  1215.                     postOutResponseContext.setReturnCode(200);
  1216.                 }
  1217. //              if(context!=null){
  1218.                 if(context.getTipoPorta()!=null)
  1219.                     postOutResponseContext.setTipoPorta(context.getTipoPorta());
  1220.                 else
  1221.                     postOutResponseContext.setTipoPorta(TipoPdD.DELEGATA);
  1222.                 postOutResponseContext.setProtocollo(context.getProtocol());
  1223.                 postOutResponseContext.setIntegrazione(context.getIntegrazione());
  1224. //              }else{
  1225. //                  postOutResponseContext.setTipoPorta(TipoPdD.DELEGATA);
  1226. //              }
  1227.                 postOutResponseContext.setIdModulo(idModulo);
  1228.                                 
  1229.             }catch(Exception e){
  1230.                 msgDiag.logErroreGenerico(e,"postOutResponse, preparazione contesto");
  1231.             }
  1232.             
  1233.             GestoreHandlers.postOutResponse(postOutResponseContext, msgDiag, logCore);
  1234.         }
  1235.     }
  1236.     
  1237. }
Created with JaCoCo 0.8.8.202204050719