RicezioneBusteServiceUtils.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.util.Date;
  24. import java.util.HashMap;
  25. import java.util.List;
  26. import java.util.Map;

  28. import javax.servlet.http.HttpServletRequest;

  30. import org.apache.commons.lang.StringUtils;
  31. import org.openspcoop2.core.config.CorsConfigurazione;
  32. import org.openspcoop2.core.config.PortaApplicativa;
  33. import org.openspcoop2.core.config.ServizioApplicativo;
  34. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  35. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  36. import org.openspcoop2.core.constants.TipoPdD;
  37. import org.openspcoop2.core.id.IDPortaApplicativa;
  38. import org.openspcoop2.core.id.IDServizio;
  39. import org.openspcoop2.core.id.IDServizioApplicativo;
  40. import org.openspcoop2.core.id.IDSoggetto;
  41. import org.openspcoop2.core.registry.PortaDominio;
  42. import org.openspcoop2.core.registry.Soggetto;
  43. import org.openspcoop2.core.transazioni.utils.PropertiesSerializator;
  44. import org.openspcoop2.message.OpenSPCoop2Message;
  45. import org.openspcoop2.message.config.ServiceBindingConfiguration;
  46. import org.openspcoop2.message.constants.MessageType;
  47. import org.openspcoop2.message.constants.ServiceBinding;
  48. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  49. import org.openspcoop2.pdd.config.CachedConfigIntegrationReader;
  50. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  51. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  52. import org.openspcoop2.pdd.core.CostantiPdD;
  53. import org.openspcoop2.pdd.core.GestoreRichieste;
  54. import org.openspcoop2.pdd.core.PdDContext;
  55. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  56. import org.openspcoop2.pdd.core.handlers.PostOutResponseContext;
  57. import org.openspcoop2.pdd.core.handlers.transazioni.PreInRequestHandler;
  58. import org.openspcoop2.pdd.core.transazioni.Transaction;
  59. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  60. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  61. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  62. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  63. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherInfo;
  64. import org.openspcoop2.pdd.services.connector.ConnectorDispatcherUtils;
  65. import org.openspcoop2.pdd.services.connector.ConnectorException;
  66. import org.openspcoop2.pdd.services.connector.messages.ConnectorInMessage;
  67. import org.openspcoop2.pdd.services.connector.messages.ConnectorOutMessage;
  68. import org.openspcoop2.pdd.services.core.RicezioneBusteContext;
  69. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  70. import org.openspcoop2.protocol.basic.registry.IdentificazionePortaApplicativa;
  71. import org.openspcoop2.protocol.basic.registry.ServiceIdentificationReader;
  72. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  73. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  74. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  75. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  76. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  77. import org.openspcoop2.protocol.sdk.constants.IDService;
  78. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  79. import org.openspcoop2.protocol.sdk.registry.IRegistryReader;
  80. import org.openspcoop2.protocol.sdk.registry.RegistryNotFound;
  81. import org.openspcoop2.protocol.sdk.state.IState;
  82. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  83. import org.openspcoop2.protocol.sdk.state.RequestInfoConfigUtilities;
  84. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  85. import org.openspcoop2.utils.date.DateManager;
  86. import org.openspcoop2.utils.transport.TransportUtils;
  87. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;
  88. import org.openspcoop2.utils.transport.http.HttpConstants;
  89. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  90. import org.slf4j.Logger;

  92. /**
  93.  * RicezioneBusteServiceUtils
  94.  *
  95.  * @author Poli Andrea (apoli@link.it)
  96.  * @author $Author$
  97.  * @version $Rev$, $Date$
  98.  */
  99. public class RicezioneBusteServiceUtils {

  101.     public static RicezionePropertiesConfig readPropertiesConfig(RequestInfo requestInfo, Logger logCore, IState state) {
  102.         if (requestInfo != null && requestInfo.getProtocolContext() != null && requestInfo.getProtocolContext().getInterfaceName() != null && !"".equals(requestInfo.getProtocolContext().getInterfaceName())) {
  103.             try {
  104.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance(state);
  105.                 RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance(state);
  106.                 IDPortaApplicativa idPA = new IDPortaApplicativa();
  107.                 idPA.setNome(requestInfo.getProtocolContext().getInterfaceName());
  108.                 PortaApplicativa pa = configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  109.                 if (pa != null) {
  110.                     RicezionePropertiesConfig config = new RicezionePropertiesConfig();
  111.                     
  112.                     config.setApiImplementation(configurazionePdDManager.getProprietaConfigurazione(pa));
  113.                     
  114.                     IDSoggetto idSoggettoProprietario = new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario());
  115.                     Soggetto soggetto = registroServiziManager.getSoggetto(idSoggettoProprietario, null, requestInfo);
  116.                     config.setSoggettoErogatore(registroServiziManager.getProprietaConfigurazione(soggetto));
  117.                     
  118.                     return config;
  119.                 }               
  120.             } catch (Exception e) {
  121.                 logCore.error("Errore durante la lettura delle proprietà di configurazione della porta applicativa [" + requestInfo.getProtocolContext().getInterfaceName() + "]: " + e.getMessage(), e);
  122.             }

  124.             return null;
  125.         } else {
  126.             return null;
  127.         }
  128.     }
  129.     
  130.     public static ConnectorDispatcherInfo updatePortaApplicativaRequestInfo(RequestInfo requestInfo, Logger logCore, 
  131.             ConnectorInMessage req, ConnectorOutMessage res, RicezioneBusteExternalErrorGenerator generatoreErrore,
  132.             ServiceIdentificationReader serviceIdentificationReader,
  133.             MsgDiagnostico msgDiag, PdDContext pddContextNullable) throws ConnectorException{
  134.         
  135.         URLProtocolContext protocolContext = requestInfo.getProtocolContext();
  136.         ServiceBindingConfiguration bindingConfig = requestInfo.getBindingConfig();

  138.         IDPortaApplicativa idPA = null;
  139.         try{
  140.             if(requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getIdPortaApplicativaDefault()!=null) {
  141.                 idPA = requestInfo.getRequestConfig().getIdPortaApplicativaDefault();
  142.             }
  143.             else {
  144.                 idPA = serviceIdentificationReader.findPortaApplicativa(protocolContext, true);
  145.                 if(requestInfo.getRequestConfig()!=null) {
  146.                     requestInfo.getRequestConfig().setIdPortaApplicativaDefault(idPA);
  147.                 }
  148.             }
  149.         }catch(RegistryNotFound notFound){
  150.             if(bindingConfig.existsContextUrlMapping()==false){
  151.                 if(pddContextNullable!=null) {
  152.                     pddContextNullable.addObject(org.openspcoop2.core.constants.Costanti.API_NON_INDIVIDUATA, "true");
  153.                 }
  154.                 logCore.error("Porta Applicativa non trovata: "+notFound.getMessage(),notFound);
  155.                 msgDiag.addKeywordErroreProcessamento(notFound);
  156.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  157.                 ConnectorDispatcherInfo c = ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore, serviceIdentificationReader.getErroreIntegrazioneNotFound(), 
  158.                         IntegrationFunctionError.API_IN_UNKNOWN, notFound, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  159.                 try {
  160.                     EsitoTransazione esito = requestInfo.getProtocolFactory().createEsitoBuilder().getEsito(requestInfo.getProtocolContext(),EsitoTransazioneName.API_NON_INDIVIDUATA);
  161.                     c.setEsitoTransazione(esito);
  162.                 }catch(Throwable t) {
  163.                     logCore.error("Errore durante l'impostazione dell'esito 'API_NON_INDIVIDUATA'");
  164.                 }
  165.                 return c;
  166.             }
  167.         }
  168.         if(idPA!=null){
  169.             return updatePortaApplicativaRequestInfo(requestInfo, logCore, 
  170.                     null, req, res, generatoreErrore, 
  171.                     serviceIdentificationReader, 
  172.                     msgDiag,
  173.                     protocolContext,idPA, pddContextNullable);
  174.         }
  175.         
  176.         return null;
  177.     }
  178.     
  179.     public static ConnectorDispatcherInfo updatePortaApplicativaRequestInfo(RequestInfo requestInfo, Logger logCore, 
  180.             OpenSPCoop2Message requestMessage,
  181.             RicezioneBusteExternalErrorGenerator generatoreErrore,
  182.             ServiceIdentificationReader serviceIdentificationReader,
  183.             MsgDiagnostico msgDiag, 
  184.             URLProtocolContext protocolContext, IDPortaApplicativa idPA, PdDContext pddContextNullable) throws ConnectorException{
  185.         return updatePortaApplicativaRequestInfo(requestInfo, logCore, 
  186.                 requestMessage, null, null, generatoreErrore, 
  187.                 serviceIdentificationReader, 
  188.                 msgDiag, 
  189.                 protocolContext, idPA, pddContextNullable);
  190.     }
  191.     private static ConnectorDispatcherInfo updatePortaApplicativaRequestInfo(RequestInfo requestInfo, Logger logCore, 
  192.             OpenSPCoop2Message requestMessage, ConnectorInMessage req, ConnectorOutMessage res, RicezioneBusteExternalErrorGenerator generatoreErrore,
  193.             ServiceIdentificationReader serviceIdentificationReader,
  194.             MsgDiagnostico msgDiag, 
  195.             URLProtocolContext protocolContext, IDPortaApplicativa idPA, PdDContext pddContextNullable) throws ConnectorException{

  197.             
  198.         // da ora in avanti, avendo localizzato una PA, se avviene un errore genero l'errore stesso
  199.         protocolContext.setInterfaceName(idPA.getNome());
  200.         if(protocolContext.getFunctionParameters()==null) {
  201.             protocolContext.setFunctionParameters(idPA.getNome());
  202.         }
  203.         
  204.         if(requestInfo==null) {
  205.             throw new ConnectorException("Param requestInfo is null");
  206.         }
  207.         
  208.         IProtocolFactory<?> pf = requestInfo.getProtocolFactory();
  209.         ServiceBindingConfiguration bindingConfig = requestInfo.getBindingConfig();
  210.         ServiceBinding integrationServiceBinding = requestInfo.getIntegrationServiceBinding();
  211.         ServiceBinding protocolServiceBinding = requestInfo.getProtocolServiceBinding();
  212.         
  213.         // read IDServizio
  214.         IDServizio idServizio = null;
  215.         if(requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getIdServizio()!=null) {
  216.             idServizio = requestInfo.getRequestConfig().getIdServizio().clone(); // effettuo clone altrimenti viene cambiato dopo e la modifica potrebbe risultare anche in altri thread
  217.         }
  218.         else {
  219.             if(idPA.getIdentificativiErogazione()!=null){
  220.                 if(idPA.getIdentificativiErogazione().getIdServizio()!=null) {
  221.                     idServizio = idPA.getIdentificativiErogazione().getIdServizio().clone(); // effettuo clone altrimenti nella cache viene memorizzata l'azione impostata dopo!
  222.                 }
  223.             }
  224.             
  225.             if(idServizio==null){
  226.                 try{
  227.                     idServizio = serviceIdentificationReader.convertToIDServizio(idPA);
  228.                     if(idServizio!=null) {
  229.                         idServizio = idServizio.clone(); // effettuo clone altrimenti nella cache viene memorizzata l'azione impostata dopo!
  230.                     }
  231.                 }catch(RegistryNotFound notFound){
  232.                     if(res!=null) {
  233.                         logCore.debug("Conversione Dati PortaDelegata in identificativo servizio fallita (notFound): "+notFound.getMessage(),notFound);
  234.                         msgDiag.addKeywordErroreProcessamento(notFound);
  235.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  236.                         return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore, serviceIdentificationReader.getErroreIntegrazioneNotFound(), 
  237.                                 IntegrationFunctionError.API_IN_UNKNOWN, notFound, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  238.                     }
  239.                     return null;
  240.                 }
  241.             }
  242.             
  243.             if(requestInfo.getRequestConfig()!=null) {
  244.                 requestInfo.getRequestConfig().setIdServizio(idServizio);
  245.             }
  246.         }
  247.         
  248.         ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  249.                 
  250.         PortaApplicativa paDefault = null;
  251.         if(idServizio!=null){
  252.             
  253.             CachedConfigIntegrationReader configIntegrationReader = (CachedConfigIntegrationReader) serviceIdentificationReader.getConfigIntegrationReader();
  254.             IRegistryReader registryReader = serviceIdentificationReader.getRegistryReader();
  255.             RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance();
  256.             
  257.             // Aggiorno service binding rispetto al servizio localizzato
  258.             try{
  259.                 integrationServiceBinding = pf.createProtocolConfiguration().getIntegrationServiceBinding(idServizio, registryReader);
  260.                 requestInfo.setIntegrationServiceBinding(integrationServiceBinding);
  261.                 
  262.                 protocolServiceBinding = pf.createProtocolConfiguration().getProtocolServiceBinding(integrationServiceBinding, protocolContext);
  263.                 requestInfo.setProtocolServiceBinding(protocolServiceBinding);
  264.                 
  265.                 generatoreErrore.updateServiceBinding(protocolServiceBinding);
  266.             }catch(RegistryNotFound notFound){
  267.                 if(res!=null) {
  268.                     logCore.debug("Lettura ServiceBinding fallita (notFound): "+notFound.getMessage(),notFound);
  269.                     msgDiag.addKeywordErroreProcessamento(notFound);
  270.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  271.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  272.                             ErroriIntegrazione.ERRORE_405_SERVIZIO_NON_TROVATO.getErroreIntegrazione(),
  273.                             IntegrationFunctionError.API_IN_UNKNOWN, notFound, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  274.                 }
  275.                 return null;
  276.             }catch(Exception error){
  277.                 if(res!=null) {
  278.                     logCore.error("Lettura ServiceBinding fallita: "+error.getMessage(),error);
  279.                     msgDiag.addKeywordErroreProcessamento(error);
  280.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  281.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  282.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Lettura ServiceBinding fallita"),
  283.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, error, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  284.                 }
  285.                 return null;
  286.             }
  287.             
  288.             // Provo ad ottenere il reader soap
  289.             OpenSPCoop2MessageSoapStreamReader soapStreamReader = null;
  290.             if(ServiceBinding.SOAP.equals(protocolServiceBinding)) {
  291.                 try{
  292.                     if(req!=null) {
  293.                         soapStreamReader = req.getSoapReader();
  294.                     }
  295.                     else if(requestMessage!=null && ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())) {
  296.                         soapStreamReader = requestMessage.castAsSoap().getSoapReader();
  297.                     }
  298.                 }catch(Exception e){
  299.                     logCore.debug("SOAPStream lettura non riuscita: "+e.getMessage(),e);
  300.                 }
  301.             }
  302.             
  303.             // PortaApplicativa Default
  304.             try{
  305.                 if(requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getPortaApplicativaDefault()!=null) {
  306.                     paDefault = requestInfo.getRequestConfig().getPortaApplicativaDefault();
  307.                 }
  308.                 else {
  309.                     paDefault = configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, null); // passo null volutamente, per non utilizzare la configurazione
  310.                     if(requestInfo.getRequestConfig()!=null) {
  311.                         requestInfo.getRequestConfig().setPortaApplicativaDefault(paDefault);
  312.                     }
  313.                 }
  314.             }catch(Exception e){
  315.                 logCore.debug("Recupero porta default fallita: "+e.getMessage(),e);
  316.             }
  317.             
  318.             // Verifico che la modalità di riconoscimento dell'azione sia compatibile
  319.             RequestInfoConfigUtilities.checkRequestInfoConfig(paDefault, logCore, protocolServiceBinding, soapStreamReader, requestInfo);
  320.             // Aggiorno chiave per considerare anche il soapStreamReader
  321.             GestoreRichieste.updateRequestConfig(requestInfo, protocolServiceBinding, soapStreamReader);
  322.             if(requestInfo!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getIdServizio()!=null) {
  323.                 idServizio = requestInfo.getRequestConfig().getIdServizio(); // se ho fatto lo switch per chiave più specifica per soap, uso il nuovo oggetto per evitare che nella chiave precedente venga memorizzata l'azione
  324.             }
  325.             
  326.             // provo a leggere anche l'azione
  327.             // l'eventuale errore lo genero dopo
  328.             try{
  329.                 //PortaApplicativa paSearchAzione = configIntegrationReader.getPortaApplicativa(idPA);
  330.                 PortaApplicativa paSearchAzione = paDefault;
  331.                 idServizio.setAzione(configIntegrationReader.getAzione(paSearchAzione, protocolContext, requestInfo, requestInfo.getProtocolFactory(), 
  332.                         requestMessage, // sara' valorizzato solamente per riconoscere l'azione nel caso di invocazione /PA senza indicare la porta applicativa 
  333.                         soapStreamReader));
  334.             }catch(Exception e){
  335.                 logCore.debug("Azione non trovata: "+e.getMessage(),e);
  336.             }
  337.                         
  338.             // Lettura eventuale MessageFactory da utilizzare
  339.             try {
  340.                 if(paDefault!=null && paDefault.getOptions()!=null && !StringUtils.isEmpty(paDefault.getOptions())) {
  341.                     Map<String, List<String>> props = PropertiesSerializator.convertoFromDBColumnValue(paDefault.getOptions());
  342.                     if(props!=null && props.size()>0) {
  343.                         String msgFactory = TransportUtils.getFirstValue(props,CostantiPdD.OPTIONS_MESSAGE_FACTORY);
  344.                         if(msgFactory!=null) {
  345.                             requestInfo.setMessageFactory(msgFactory);
  346.                         }
  347.                     }
  348.                 }
  349.             }catch(Throwable e){
  350.                 logCore.debug("Lettura Message Factory fallita: "+e.getMessage(),e);
  351.             }
  352.             
  353.             // Lettura Azione
  354.             try{
  355.                 if(requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getIdPortaApplicativa()!=null) {
  356.                     idPA = requestInfo.getRequestConfig().getIdPortaApplicativa();
  357.                     
  358.                     if(requestInfo.getRequestConfig().getIdPortaApplicativaDefault()!=null && !requestInfo.getRequestConfig().getIdPortaApplicativaDefault().equals(idPA)) {
  359.                         // pa specifica
  360.                         
  361.                         if(pddContextNullable!=null) {
  362.                             pddContextNullable.addObject(CostantiPdD.NOME_PORTA_INVOCATA, requestInfo.getRequestConfig().getIdPortaApplicativaDefault().getNome()); // prima di aggiornare la porta applicativa
  363.                         }
  364.                         
  365.                         msgDiag.addKeyword(CostantiPdD.KEY_PORTA_APPLICATIVA, idPA.getNome());
  366.                         msgDiag.updatePorta(idPA.getNome(), requestInfo);
  367.                         protocolContext.setInterfaceName(idPA.getNome());
  368.                     }
  369.                 }
  370.                 else {
  371.                     if(idServizio.getAzione()!=null) {
  372.                         
  373.                         IdentificazionePortaApplicativa identificazione = new IdentificazionePortaApplicativa(logCore, pf, 
  374.                                 serviceIdentificationReader.getRegistryReader(), serviceIdentificationReader.getConfigIntegrationReader(), // questi reader sono gia' 'cached'
  375.                                 requestInfo, paDefault);
  376.                         if(identificazione.find(idServizio.getAzione())) {
  377.                             IDPortaApplicativa idPA_action = identificazione.getIDPortaApplicativa(idServizio.getAzione());
  378.                             if(idPA_action!=null) {
  379.                                 
  380.                                 if(pddContextNullable!=null) {
  381.                                     pddContextNullable.addObject(CostantiPdD.NOME_PORTA_INVOCATA, idPA.getNome()); // prima di aggiornare la porta applicativa
  382.                                 }
  383.                                 
  384.                                 msgDiag.addKeyword(CostantiPdD.KEY_PORTA_APPLICATIVA, idPA_action.getNome());
  385.                                 msgDiag.updatePorta(idPA_action.getNome(), requestInfo);
  386.                                 protocolContext.setInterfaceName(idPA_action.getNome());
  387.                                 idPA = idPA_action;
  388.                             }
  389.                         }
  390.                     }
  391.                     if(idPA!=null && requestInfo.getRequestConfig()!=null) {
  392.                         requestInfo.getRequestConfig().setIdPortaApplicativa(idPA);
  393.                     }
  394.                 }
  395.             }catch(Exception e){
  396.                 logCore.debug("Gestione porta specifica per azione fallita: "+e.getMessage(),e);
  397.             }
  398.             
  399.             // SetPA usato poi successivamente
  400.             if(idPA!=null && requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getPortaApplicativa()==null) {
  401.                 try{
  402.                     PortaApplicativa pa = configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, null); // passo null volutamente, per accedere alla configurazione
  403.                     requestInfo.getRequestConfig().setPortaApplicativa(pa);
  404.                 }catch(Exception e){
  405.                     logCore.debug("Recupero porta applicativa fallito: "+e.getMessage(),e);
  406.                 }
  407.             }
  408.             
  409.             // Set servizi applicativi erogatori
  410.             if(requestInfo.getRequestConfig()!=null && requestInfo.getRequestConfig().getPortaApplicativa()!=null && 
  411.                     requestInfo.getRequestConfig().sizeServiziApplicativiErogatori()<=0) {
  412.                 String [] sa = null;
  413.                 try{
  414.                     sa = configurazionePdDManager.getServiziApplicativi(requestInfo.getRequestConfig().getPortaApplicativa());
  415.                 }catch(Exception e){
  416.                     logCore.debug("Recupero servizi applicativi erogatori falliti: "+e.getMessage(),e);
  417.                 }
  418.                 if(sa!=null && sa.length>0) {
  419.                     IDSoggetto soggettoProprietario = new IDSoggetto(requestInfo.getRequestConfig().getPortaApplicativa().getTipoSoggettoProprietario(), requestInfo.getRequestConfig().getPortaApplicativa().getNomeSoggettoProprietario());
  420.                     for (String s : sa) {
  421.                         IDServizioApplicativo idSA = new IDServizioApplicativo();
  422.                         idSA.setNome(s);
  423.                         idSA.setIdSoggettoProprietario(soggettoProprietario);
  424.                         try{
  425.                             ServizioApplicativo serv = configurazionePdDManager.getServizioApplicativo(idSA, null); // passo null volutamente, per accedere alla configurazione
  426.                             if(serv!=null) {
  427.                                 requestInfo.getRequestConfig().addServizioApplicativoErogatore(serv, requestInfo.getIdTransazione());
  428.                             }
  429.                         }catch(Exception e){
  430.                             logCore.debug("Recupero servizio applicativo erogatore fallito ("+idSA.toString()+"): "+e.getMessage(),e);
  431.                         }
  432.                     }
  433.                 }
  434.             }
  435.             
  436.             // Set identità soggetti erogatori usati poi successivamente
  437.             if(idServizio!=null && idServizio.getSoggettoErogatore()!=null && requestInfo.getRequestConfig()!=null) {
  438.                 if(requestInfo.getRequestConfig().getSoggettoErogatoreRegistry()==null) {
  439.                     try{
  440.                         org.openspcoop2.core.registry.Soggetto soggettoRegistry = registroServiziManager.getSoggetto(idServizio.getSoggettoErogatore(), null, null); // passo null volutamente, per accedere alla configurazione
  441.                         requestInfo.getRequestConfig().setSoggettoErogatoreRegistry(soggettoRegistry);
  442.                     }catch(Exception e){
  443.                         logCore.debug("Recupero soggetto erogatore dal registro fallito: "+e.getMessage(),e);
  444.                     }
  445.                 }
  446.                 if(requestInfo.getRequestConfig().getSoggettoErogatoreConfig()==null) {
  447.                     try{
  448.                         org.openspcoop2.core.config.Soggetto soggettoConfig = configurazionePdDManager.getSoggetto(idServizio.getSoggettoErogatore(), null); // passo null volutamente, per accedere alla configurazione
  449.                         requestInfo.getRequestConfig().setSoggettoErogatoreConfig(soggettoConfig);
  450.                     }catch(Exception e){
  451.                         logCore.debug("Recupero soggetto erogatore dal registro fallito: "+e.getMessage(),e);
  452.                     }
  453.                 }
  454.                 if(requestInfo.getRequestConfig().getSoggettoErogatoreIdentificativoPorta()==null) {
  455.                     try{
  456.                         String idPorta = configurazionePdDManager.getIdentificativoPorta(idServizio.getSoggettoErogatore(), pf, null); // passo null volutamente, per accedere alla configurazione
  457.                         requestInfo.getRequestConfig().setSoggettoErogatoreIdentificativoPorta(idPorta);
  458.                     }catch(Exception e){
  459.                         logCore.debug("Recupero dati soggetto erogatore (identificativoPorta) dal registro fallito: "+e.getMessage(),e);
  460.                     }
  461.                 }
  462.                 if(requestInfo.getRequestConfig().getSoggettoErogatoreSoggettoVirtuale()==null) {
  463.                     try{
  464.                         boolean soggettoVirtuale = configurazionePdDManager.isSoggettoVirtuale(idServizio.getSoggettoErogatore(), null); // passo null volutamente, per accedere alla configurazione
  465.                         requestInfo.getRequestConfig().setSoggettoErogatoreSoggettoVirtuale(soggettoVirtuale);
  466.                     }catch(Exception e){
  467.                         logCore.debug("Recupero dati soggetto erogatore (soggettoVirtuale) dal registro fallito: "+e.getMessage(),e);
  468.                     }
  469.                 }
  470.                 if(requestInfo.getRequestConfig().getSoggettoErogatorePddReaded()==null) {
  471.                     try{
  472.                         if(requestInfo.getRequestConfig().getSoggettoErogatoreRegistry()!=null) {
  473.                             if(requestInfo.getRequestConfig().getSoggettoErogatoreRegistry().getPortaDominio()!=null &&
  474.                                     StringUtils.isNotEmpty(requestInfo.getRequestConfig().getSoggettoErogatoreRegistry().getPortaDominio())) {
  475.                                 PortaDominio pdd = registroServiziManager.getPortaDominio(requestInfo.getRequestConfig().getSoggettoErogatoreRegistry().getPortaDominio(), null, null); // passo null volutamente, per accedere alla configurazione
  476.                                 requestInfo.getRequestConfig().setSoggettoErogatorePddReaded(true);
  477.                                 requestInfo.getRequestConfig().setSoggettoErogatorePdd(pdd);
  478.                             }
  479.                             else {
  480.                                 requestInfo.getRequestConfig().setSoggettoErogatorePddReaded(true);
  481.                             }
  482.                         }
  483.                     }catch(Exception e){
  484.                         logCore.debug("Recupero dati soggetto erogatore (pdd) dal registro fallito: "+e.getMessage(),e);
  485.                     }
  486.                 }
  487.                 if(requestInfo.getRequestConfig().getSoggettoErogatoreImplementazionePdd()==null) {
  488.                     try{
  489.                         String impl = registroServiziManager.getImplementazionePdD(idServizio.getSoggettoErogatore(), null, null); // passo null volutamente, per accedere alla configurazione
  490.                         requestInfo.getRequestConfig().setSoggettoErogatoreImplementazionePdd(impl);
  491.                     }catch(Exception e){
  492.                         logCore.debug("Recupero dati soggetto erogatore (implementazione pdd) dal registro fallito: "+e.getMessage(),e);
  493.                     }
  494.                 }
  495.             }
  496.             
  497.             // updateInformazioniCooperazione
  498.             generatoreErrore.updateInformazioniCooperazione(null, idServizio);
  499.             requestInfo.setIdServizio(idServizio);
  500.                         
  501.             // Aggiorno service binding configuration rispetto al servizio localizzato
  502.             try{
  503.                 bindingConfig = pf.createProtocolConfiguration().getServiceBindingConfiguration(protocolContext, integrationServiceBinding, idServizio, registryReader);
  504.                 requestInfo.setBindingConfig(bindingConfig);
  505.             }catch(RegistryNotFound notFound){
  506.                 if(res!=null) {
  507.                     logCore.debug("Lettura Configurazione Servizio fallita (notFound): "+notFound.getMessage(),notFound);
  508.                     msgDiag.addKeywordErroreProcessamento(notFound);
  509.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  510.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  511.                             ErroriIntegrazione.ERRORE_405_SERVIZIO_NON_TROVATO.getErroreIntegrazione(),
  512.                             IntegrationFunctionError.API_IN_UNKNOWN, notFound, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  513.                 }
  514.                 return null;
  515.             }catch(Exception error){
  516.                 if(res!=null) {
  517.                     logCore.error("Lettura Configurazione Servizio fallita: "+error.getMessage(),error);
  518.                     msgDiag.addKeywordErroreProcessamento(error);
  519.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  520.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  521.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Lettura Configurazione Servizio fallita"),
  522.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, error, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  523.                 }
  524.                 return null;
  525.             }
  526.             
  527.             // Verifico correttezza Content-Type
  528.             String ct = null;
  529.             try {
  530.                 ct = protocolContext.getContentType();
  531.                 if(ct!=null && !"".equals(ct)) {
  532.                     //new ContentType(ct).getBaseType();
  533.                     ContentTypeUtilities.validateContentType(ct);
  534.                 }
  535.             }catch(Exception error){
  536.                 if(res!=null) {
  537.                     logCore.error("Lettura ContentType fallita: "+error.getMessage(),error);
  538.                     msgDiag.addKeywordErroreProcessamento(error);
  539.                     msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, " Content-Type '"+ct+"' presente nella richiesta non valido;");
  540.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE,"richiestaNonValida");
  541.                     ConnectorDispatcherInfo cdiError = ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  542.                             ErroriIntegrazione.ERRORE_432_PARSING_EXCEPTION_RICHIESTA.getErrore432_MessaggioRichiestaMalformato(error),
  543.                             IntegrationFunctionError.BAD_REQUEST, error, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  544.                     try {
  545.                         cdiError.setEsitoTransazione(pf.createEsitoBuilder().getEsito(requestInfo.getProtocolContext(),EsitoTransazioneName.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO));
  546.                         if(pddContextNullable!=null) {
  547.                             pddContextNullable.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  548.                         }
  549.                     }catch(Throwable t) {
  550.                         // ignore
  551.                     }
  552.                     return cdiError;
  553.                 }
  554.                 return null;
  555.             }
  556.             
  557.             // Aggiorno message type
  558.             try{
  559.                 MessageType requestMessageTypeIntegration = bindingConfig.getRequestMessageType(integrationServiceBinding, 
  560.                         protocolContext, protocolContext.getContentType());
  561.                 requestInfo.setIntegrationRequestMessageType(requestMessageTypeIntegration);
  562.                 
  563.                 MessageType requestMessageTypeProtocol = bindingConfig.getRequestMessageType(protocolServiceBinding, 
  564.                         protocolContext, protocolContext.getContentType());
  565.                 requestInfo.setProtocolRequestMessageType(requestMessageTypeProtocol);
  566.                 
  567.                 generatoreErrore.updateRequestMessageType(requestMessageTypeProtocol);
  568.             }catch(Exception error){
  569.                 if(res!=null) {
  570.                     logCore.error("Identificazione MessageType fallita: "+error.getMessage(),error);
  571.                     msgDiag.addKeywordErroreProcessamento(error);
  572.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  573.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  574.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Identificazione MessageType fallita"),
  575.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, error, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  576.                 }
  577.                 return null;
  578.             }
  579.             
  580.             // Controllo Service Binding rispetto alla url e al tipo di servizio
  581.             if(requestInfo.getProtocolContext()!=null && bindingConfig.isServiceBindingContextEnabled(protocolServiceBinding, requestInfo.getProtocolContext().getProtocolWebContext())==false) {
  582.                 if(res!=null) {
  583.                     String url = requestInfo.getProtocolContext().getRequestURI();
  584.                     logCore.error("L'API invocata possiede un service binding '"+protocolServiceBinding+"' non abilitato sul contesto utilizzato: "+url);
  585.                     msgDiag.logErroreGenerico("L'API invocata possiede un service binding '"+protocolServiceBinding+"' non abilitato sul contesto utilizzato", "CheckServiceBinding");
  586.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore, 
  587.                             ErroriIntegrazione.ERRORE_447_API_NON_INVOCABILE_CONTESTO_UTILIZZATO.getErroreIntegrazione(),
  588.                             IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, null, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  589.                 }
  590.                 return null;
  591.             }
  592.             if(bindingConfig.isServiceBindingServiceTypeEnabled(protocolServiceBinding, idServizio.getTipo())==false) {
  593.                 if(res!=null) {
  594.                     logCore.error("L'API invocata possiede un service binding '"+protocolServiceBinding+"' non abilitato per il tipo di servizio '"+idServizio.getTipo()+"'");
  595.                     msgDiag.logErroreGenerico("L'API invocata possiede un service binding '"+protocolServiceBinding+"' non abilitato per il tipo di servizio '"+idServizio.getTipo(), "CheckServiceBinding");
  596.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore, 
  597.                             ErroriIntegrazione.ERRORE_448_API_NON_INVOCABILE_TIPO_SERVIZIO_UTILIZZATO.getErroreIntegrazione(),
  598.                             IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, null, null, res, logCore, ConnectorDispatcherUtils.CLIENT_ERROR);
  599.                 }
  600.                 return null;
  601.             }
  602.         }
  603.     
  604.         if(requestInfo!=null && requestInfo.getProtocolServiceBinding()!=null && 
  605.                 ServiceBinding.SOAP.equals(requestInfo.getProtocolServiceBinding()) && 
  606.                 requestInfo.getProtocolContext()!=null &&
  607.                 HttpRequestMethod.OPTIONS.name().equalsIgnoreCase(requestInfo.getProtocolContext().getRequestType())) {
  608.                         
  609.             // Gestione CORS
  610.             try{
  611.                 CorsConfigurazione cors = null;
  612.                 HttpServletRequest httpServletRequest = null;
  613.                 if(requestInfo!=null && requestInfo.getProtocolContext()!=null) {
  614.                     httpServletRequest = requestInfo.getProtocolContext().getHttpServletRequest();  
  615.                 }
  616.                 
  617.                 if(httpServletRequest!=null) {
  618.                     if(paDefault!=null) {
  619.                         cors = configurazionePdDManager.getConfigurazioneCORS(paDefault);
  620.                     }
  621.                     else {
  622.                         cors = configurazionePdDManager.getConfigurazioneCORS();
  623.                     }
  624.                 }
  625.                 else {
  626.                     cors = new CorsConfigurazione();
  627.                     cors.setStato(StatoFunzionalita.DISABILITATO);
  628.                 }
  629.                 
  630.                 if(StatoFunzionalita.ABILITATO.equals(cors.getStato())) {
  631.                     if(TipoGestioneCORS.GATEWAY.equals(cors.getTipo())) {
  632.                         
  633.                         /*
  634.                         
  635.                         org.openspcoop2.pdd.core.CORSFilter corsFilter = new org.openspcoop2.pdd.core.CORSFilter(logCore, cors);
  636.                         org.openspcoop2.pdd.core.CORSWrappedHttpServletResponse resCORS = new org.openspcoop2.pdd.core.CORSWrappedHttpServletResponse(true);
  637.                         corsFilter.doCORS(httpServletRequest, resCORS, org.openspcoop2.utils.transport.http.CORSRequestType.PRE_FLIGHT, true);
  638.                         org.openspcoop2.message.OpenSPCoop2Message msgCORSResponse = resCORS.buildMessage();
  639.                         org.openspcoop2.protocol.sdk.builder.EsitoTransazione esito = 
  640.                                 requestInfo.getProtocolFactory().createEsitoBuilder().getEsito(requestInfo.getProtocolContext(),
  641.                                         org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY);
  642.                         ConnectorDispatcherInfo c = ConnectorDispatcherInfo.getGeneric(msgCORSResponse, 
  643.                                 resCORS.getStatus(), null, resCORS.getHeader(), esito);
  644.                         if(pddContextNullable!=null) {
  645.                             pddContextNullable.addObject(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY, "true");
  646.                         }
  647.                         ConnectorDispatcherUtils.doInfo(c, requestInfo, res, logCore, false);
  648.                         return c;
  649.                         
  650.                         */
  651.                         
  652.                         // Fix per avere il dump anche nelle comunicazioni soap, converto in REST
  653.                         requestInfo.setIntegrationServiceBinding(ServiceBinding.REST);
  654.                         requestInfo.setProtocolServiceBinding(ServiceBinding.REST);
  655.                         generatoreErrore.updateServiceBinding(ServiceBinding.REST);
  656.                         
  657.                         requestInfo.setIntegrationRequestMessageType(MessageType.BINARY);
  658.                         requestInfo.setProtocolRequestMessageType(MessageType.BINARY);
  659.                         generatoreErrore.updateRequestMessageType(MessageType.BINARY);
  660.                         
  661.                         if(pddContextNullable!=null) {
  662.                             pddContextNullable.addObject(CostantiPdD.CORS_PREFLIGHT_REQUEST_SOAP, "true");
  663.                         }
  664.                         
  665.                     }
  666.                     else {
  667.                         
  668.                         if(pddContextNullable!=null) {
  669.                             pddContextNullable.addObject(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_TRASPARENTE, "true");
  670.                         }
  671.                         
  672.                         requestInfo.setIntegrationServiceBinding(ServiceBinding.REST);
  673.                         requestInfo.setProtocolServiceBinding(ServiceBinding.REST);
  674.                         generatoreErrore.updateServiceBinding(ServiceBinding.REST);
  675.                         
  676.                         requestInfo.setIntegrationRequestMessageType(MessageType.BINARY);
  677.                         requestInfo.setProtocolRequestMessageType(MessageType.BINARY);
  678.                         generatoreErrore.updateRequestMessageType(MessageType.BINARY);
  679.                     }
  680.                 }
  681.                 
  682.             }catch(Exception error){
  683.                 
  684.                 if(res!=null) {
  685.                     logCore.error("Gestione CORS fallita: "+error.getMessage(),error);
  686.                     msgDiag.addKeywordErroreProcessamento(error);
  687.                     msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO,"portaApplicativaNonEsistente");
  688.                     return ConnectorDispatcherUtils.doError(requestInfo, generatoreErrore,
  689.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento("Gestione CORS fallita"),
  690.                             IntegrationFunctionError.INTERNAL_REQUEST_ERROR, error, null, res, logCore, ConnectorDispatcherUtils.GENERAL_ERROR);
  691.                 }
  692.                 return null;
  693.                 
  694.             }

  696.         }
  697.         
  698.         return null;
  699.     }
  700.     
  701.     
  702.     
  703.     
  704.     public static void emitTransaction(Logger logCore, ConnectorInMessage req, PdDContext pddContext, Date dataAccettazioneRichiesta,
  705.             ConnectorDispatcherInfo info) {
  706.         emitTransaction(null, logCore, req, pddContext, dataAccettazioneRichiesta, info);
  707.     }
  708.     public static void emitTransaction(RicezioneBusteContext context,Logger logCore, ConnectorInMessage req, PdDContext pddContext, Date dataAccettazioneRichiesta,
  709.             ConnectorDispatcherInfo info) {
  710.         try {
  711.             if (!OpenSPCoop2Startup.initialize || OpenSPCoop2Properties.getInstance() == null) {
  712.                 logCore.error("emitTransaction, registrazione non effettuata: inizializzazione govway non rilevata");
  713.                 return;
  714.             }
  715.             
  716.             String idModulo = req.getIdModulo();
  717.             IDService idModuloAsService = req.getIdModuloAsIDService();
  718.             IProtocolFactory<?> protocolFactory = req.getProtocolFactory();
  719.             RequestInfo requestInfo = req.getRequestInfo();
  720.             
  721.             if(context!=null && context.getPddContext()!=null) {
  722.                 PreInRequestHandler.readClientAddress(logCore, req, context.getPddContext());
  723.                 if(OpenSPCoop2Properties.getInstance().isTransazioniEnabled()) {
  724.                     try {
  725.                         String idTransazione = (String) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  726.                         if(idTransazione!=null) {
  727.                             Transaction tr = TransactionContext.getTransaction(idTransazione);
  728.                             PreInRequestHandler.setInfoInvocation(tr, requestInfo, req);
  729.                         }
  730.                     }catch(Throwable e){
  731.                         logCore.error("postOutResponse, lettura parametri fallita: "+e.getMessage(),e);
  732.                     }
  733.                 }
  734.             }
  735.             
  736.             emitTransaction(context,logCore, idModulo, idModuloAsService, protocolFactory, requestInfo, pddContext, dataAccettazioneRichiesta, info);
  737.         }catch(Throwable e){
  738.             logCore.error("postOutResponse, registrazione fallita: "+e.getMessage(),e);
  739.         }
  740.     }
  741.     
  742.     public static void emitTransaction(RicezioneBusteContext context,Logger logCore,String idModulo,IDService idModuloAsService, IProtocolFactory<?> protocolFactory, RequestInfo requestInfo,
  743.             PdDContext pddContext, Date dataAccettazioneRichiesta,
  744.             ConnectorDispatcherInfo info) {
  745.         
  746.         try {
  747.             if (!OpenSPCoop2Startup.initialize || OpenSPCoop2Properties.getInstance() == null) {
  748.                 logCore.error("postOutResponse, registrazione non effettuata: inizializzazione govway non rilevata");
  749.                 return;
  750.             }
  751.             
  752.             if(context==null) {
  753.                 context = new RicezioneBusteContext(idModuloAsService,dataAccettazioneRichiesta,requestInfo);
  754.             }
  755.             
  756.             PostOutResponseContext postOutResponseContext = new PostOutResponseContext(logCore,protocolFactory);
  757.             postOutResponseContext.setTipoPorta(TipoPdD.APPLICATIVA);
  758.             postOutResponseContext.setIdModulo(idModulo);
  759.             
  760.             postOutResponseContext.setPddContext(pddContext);
  761.             if(pddContext==null) {
  762.                 postOutResponseContext.setPddContext(context.getPddContext());
  763.             }
  764.             else {
  765.                 pddContext.addAll(context.getPddContext(), true);
  766.             }
  767.             postOutResponseContext.getPddContext().addObject(CostantiPdD.DATA_ACCETTAZIONE_RICHIESTA, dataAccettazioneRichiesta);

  769.             if(OpenSPCoop2Properties.getInstance().isTransazioniEnabled()) {
  770.                 // NOTA: se gia' esiste con l'id di transazione, non viene ricreata
  771.                 TransactionContext.createTransaction((String)postOutResponseContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE), "RicezioneBuste.3");
  772.             }
  773.             
  774.             postOutResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  775.             postOutResponseContext.setEsito(info.getEsitoTransazione());
  776.             postOutResponseContext.setReturnCode(info.getStatus());
  777.             postOutResponseContext.setResponseHeaders(info.getTrasporto());
  778.             if(info.getContentType()!=null) {
  779.                 if(postOutResponseContext.getResponseHeaders()==null) {
  780.                     postOutResponseContext.setResponseHeaders(new HashMap<>());
  781.                 }
  782.                 TransportUtils.setHeader(postOutResponseContext.getResponseHeaders(),HttpConstants.CONTENT_TYPE, info.getContentType());
  783.             }
  784.                     
  785.             if(info.getMessage()!=null){
  786.                 
  787.                 postOutResponseContext.setOutputResponseMessageSize(info.getMessage().getOutgoingMessageContentLength());
  788.                 
  789.                 postOutResponseContext.setMessaggio(info.getMessage());
  790.             }
  791.     
  792.             MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.APPLICATIVA,idModulo);
  793.             msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  794.             
  795.             GestoreHandlers.postOutResponse(postOutResponseContext, msgDiag, logCore);
  796.             
  797.         }catch(Throwable e){
  798.             logCore.error("postOutResponse, registrazione fallita: "+e.getMessage(),e);
  799.         }
  800.     
  801.     }
  802. }
Created with JaCoCo 0.8.8.202204050719