InoltroRisposte.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.mdb;

  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;

  27. import javax.xml.soap.SOAPFault;

  29. import org.openspcoop2.core.config.Connettore;
  30. import org.openspcoop2.core.config.DumpConfigurazione;
  31. import org.openspcoop2.core.config.GestioneErrore;
  32. import org.openspcoop2.core.config.PortaApplicativa;
  33. import org.openspcoop2.core.config.PortaDelegata;
  34. import org.openspcoop2.core.config.Property;
  35. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  36. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  37. import org.openspcoop2.core.constants.CostantiConnettori;
  38. import org.openspcoop2.core.constants.TipiConnettore;
  39. import org.openspcoop2.core.constants.TipoPdD;
  40. import org.openspcoop2.core.id.IDPortaDelegata;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  44. import org.openspcoop2.message.OpenSPCoop2Message;
  45. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  46. import org.openspcoop2.message.constants.ServiceBinding;
  47. import org.openspcoop2.message.soap.SoapUtils;
  48. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  49. import org.openspcoop2.pdd.config.MessageSecurityConfig;
  50. import org.openspcoop2.pdd.core.AbstractCore;
  51. import org.openspcoop2.pdd.core.CostantiPdD;
  52. import org.openspcoop2.pdd.core.EJBUtils;
  53. import org.openspcoop2.pdd.core.GestoreMessaggi;
  54. import org.openspcoop2.pdd.core.IntegrationContext;
  55. import org.openspcoop2.pdd.core.MTOMProcessor;
  56. import org.openspcoop2.pdd.core.PdDContext;
  57. import org.openspcoop2.pdd.core.ProtocolContext;
  58. import org.openspcoop2.pdd.core.connettori.ConnettoreBase;
  59. import org.openspcoop2.pdd.core.connettori.ConnettoreBaseHTTP;
  60. import org.openspcoop2.pdd.core.connettori.ConnettoreMsg;
  61. import org.openspcoop2.pdd.core.connettori.ConnettoreUtils;
  62. import org.openspcoop2.pdd.core.connettori.GestoreErroreConnettore;
  63. import org.openspcoop2.pdd.core.connettori.IConnettore;
  64. import org.openspcoop2.pdd.core.connettori.InfoConnettoreUscita;
  65. import org.openspcoop2.pdd.core.controllo_traffico.ConnettoreUtilities;
  66. import org.openspcoop2.pdd.core.controllo_traffico.DatiTempiRisposta;
  67. import org.openspcoop2.pdd.core.dynamic.DynamicMapBuilderUtils;
  68. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  69. import org.openspcoop2.pdd.core.handlers.HandlerException;
  70. import org.openspcoop2.pdd.core.handlers.OutResponseContext;
  71. import org.openspcoop2.pdd.core.handlers.PostOutResponseContext;
  72. import org.openspcoop2.pdd.core.integrazione.UtilitiesIntegrazione;
  73. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  74. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  75. import org.openspcoop2.pdd.core.transazioni.Transaction;
  76. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  77. import org.openspcoop2.pdd.logger.Dump;
  78. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  79. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  80. import org.openspcoop2.pdd.logger.Tracciamento;
  81. import org.openspcoop2.pdd.services.core.FlowProperties;
  82. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  83. import org.openspcoop2.protocol.engine.constants.Costanti;
  84. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  85. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  86. import org.openspcoop2.protocol.engine.validator.Validatore;
  87. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  88. import org.openspcoop2.protocol.sdk.Busta;
  89. import org.openspcoop2.protocol.sdk.BustaRawContent;
  90. import org.openspcoop2.protocol.sdk.Eccezione;
  91. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  92. import org.openspcoop2.protocol.sdk.Integrazione;
  93. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  94. import org.openspcoop2.protocol.sdk.SecurityInfo;
  95. import org.openspcoop2.protocol.sdk.Trasmissione;
  96. import org.openspcoop2.protocol.sdk.builder.EsitoTransazione;
  97. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  98. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  99. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  100. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  101. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  102. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  103. import org.openspcoop2.protocol.sdk.state.IState;
  104. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  105. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  106. import org.openspcoop2.protocol.sdk.tracciamento.EsitoElaborazioneMessaggioTracciato;
  107. import org.openspcoop2.protocol.sdk.validator.IValidatoreErrori;
  108. import org.openspcoop2.protocol.sdk.validator.IValidazioneSemantica;
  109. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  110. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  111. import org.openspcoop2.security.message.MessageSecurityContext;
  112. import org.openspcoop2.security.message.MessageSecurityContextParameters;
  113. import org.openspcoop2.security.message.constants.SecurityConstants;
  114. import org.openspcoop2.security.message.engine.MessageSecurityFactory;
  115. import org.openspcoop2.utils.date.DateManager;
  116. import org.openspcoop2.utils.digest.IDigestReader;
  117. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  118. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  119. import org.slf4j.Logger;



  123. /**
  124.  * Contiene la libreria InoltroRisposte
  125.  *
  126.  * @author Poli Andrea (apoli@link.it)
  127.  * @author Tronci Fabio (tronci@link.it)
  128.  * @author $Author$
  129.  * @version $Rev$, $Date$
  130.  */
  131. public class InoltroRisposte extends GenericLib{

  133.     public static final String ID_MODULO = "InoltroRisposte";

  135.     public InoltroRisposte(Logger log) throws GenericLibException {
  136.         super(InoltroRisposte.ID_MODULO, log);
  137.         inizializza();
  138.     }

  140.     @Override
  141.     public EsitoLib _onMessage(IOpenSPCoopState openspcoopstate,
  142.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  143.             MsgDiagnostico msgDiag) throws OpenSPCoopStateException {
  144.         
  145.         EsitoLib esito = new EsitoLib();
  146.                 
  147.         if(openspcoopstate==null) {
  148.             if(msgDiag!=null) {
  149.                 msgDiag.logErroreGenerico("openspcoopstate is null", "openspcoopstate.checkNull");
  150.             }
  151.             else {
  152.                 this.log.error("openspcoopstate is null");
  153.             }
  154.             esito.setEsitoInvocazione(false); 
  155.             return esito;
  156.         }
  157.         
  158.         InoltroRisposteMessage inoltroRisposteMsg = (InoltroRisposteMessage) openspcoopstate.getMessageLib();       
  159.         
  160.         if(msgDiag==null) {
  161.             if(this.log!=null) {
  162.                 this.log.error("MsgDiagnostico is null");
  163.             }
  164.             openspcoopstate.releaseResource();
  165.             esito.setEsitoInvocazione(false); 
  166.             return esito;
  167.         }
  168.         
  169.         /* PddContext */
  170.         PdDContext pddContext = inoltroRisposteMsg.getPddContext();
  171.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  172.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  173.         
  174.         /* Busta e tipo di implementazione PdD con cui interoperare */
  175.         // Busta da inviare (tracciamento e Message-Security)
  176.         Busta busta = inoltroRisposteMsg.getBustaRisposta();
  177.         if(busta==null) {
  178.             msgDiag.logErroreGenerico("Busta is null", "Busta.checkNull"); 
  179.             openspcoopstate.releaseResource();
  180.             esito.setEsitoInvocazione(false); 
  181.             return esito;
  182.         }
  183.         String implementazionePdDDestinatario = inoltroRisposteMsg.getImplementazionePdDSoggettoDestinatario();
  184.         
  185.         IDSoggetto identitaPdD = inoltroRisposteMsg.getDominio();
  186.         msgDiag.setDominio(identitaPdD);  // imposto anche il dominio nel msgDiag
  187.         
  188.         // Tipo di busta da inoltrare
  189.         boolean inoltroSegnalazioneErrore = 
  190.             inoltroRisposteMsg.getInoltroSegnalazioneErrore();
  191.         
  192.         //  Aggiornamento Informazioni
  193.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_INOLTRO_BUSTE);
  194.         
  195.         // Gestisco i log come fossero una richiesta, come se fossi nel modulo InoltroBuste
  196.         msgDiag.addKeywords(busta, true);

  198.         // Dati consegna
  199.         IDSoggetto soggettoMittente = new IDSoggetto(busta.getTipoMittente(),busta.getMittente());
  200.         IDSoggetto soggettoDestinatario = new IDSoggetto(busta.getTipoDestinatario(),busta.getDestinatario());
  201.         IDServizio idServizio = null;
  202.         try{
  203.             idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(),busta.getServizio(), 
  204.                     soggettoDestinatario, busta.getVersioneServizio()); 
  205.         }catch(Exception e){
  206.             msgDiag.logErroreGenerico(e, "IDServizioFactory.getIDServizioFromValues");  
  207.             openspcoopstate.releaseResource();
  208.             esito.setStatoInvocazioneErroreNonGestito(e);
  209.             esito.setEsitoInvocazione(false); 
  210.             return esito;
  211.         }
  212.         idServizio.setAzione(busta.getAzione());

  214.         String idMessageResponse = busta.getID();
  215.         
  216.         msgDiag.setIdMessaggioRichiesta(busta.getRiferimentoMessaggio());
  217.         msgDiag.setIdMessaggioRisposta(busta.getID());
  218.         msgDiag.setFruitore(soggettoMittente);
  219.         msgDiag.setServizio(idServizio);
  220.         msgDiag.setIdCorrelazioneApplicativa(inoltroRisposteMsg.getIdCorrelazioneApplicativa());
  221.         msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, inoltroRisposteMsg.getIdCorrelazioneApplicativa());


  224.         /* ------------------ Inizializzo stato OpenSPCoop  --------------- */
  225.         msgDiag.mediumDebug("Inizializzo stato per la gestione della richiesta...");
  226.         openspcoopstate.initResource(identitaPdD, InoltroRisposte.ID_MODULO,idTransazione);
  227.         registroServiziManager = registroServiziManager.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  228.         configurazionePdDManager = configurazionePdDManager.refreshState(registroServiziManager);
  229.         msgDiag.updateState(configurazionePdDManager);
  230.         
  231.         /* Protocol Factory */
  232.         IProtocolFactory<?> protocolFactory = null;
  233.         IValidazioneSemantica validazioneSemantica = null;
  234.         org.openspcoop2.protocol.sdk.config.ITraduttore traduttore = null;
  235.         try{
  236.             protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  237.             traduttore = protocolFactory.createTraduttore();
  238.             validazioneSemantica = protocolFactory.createValidazioneSemantica(openspcoopstate.getStatoRichiesta());
  239.         }catch(Exception e){
  240.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  241.             openspcoopstate.releaseResource();
  242.             esito.setEsitoInvocazione(false); 
  243.             esito.setStatoInvocazioneErroreNonGestito(e);
  244.             return esito;
  245.         }
  246.         
  247.         
  248.         // Transaction
  249.         Transaction transactionNullable = null;
  250.         try{
  251.             transactionNullable = TransactionContext.getTransaction(idTransazione);
  252.         }catch(Exception e){
  253.             // La transazione potrebbe essere stata eliminata nelle comunicazioni stateful
  254. //          msgDiag.logErroreGenerico(e, "getTransaction"); 
  255. //          openspcoopstate.releaseResource();
  256. //          esito.setEsitoInvocazione(false); 
  257. //          esito.setStatoInvocazioneErroreNonGestito(e);
  258. //          return esito;
  259.         }
  260.         
  261.         msgDiag.setPddContext(pddContext, protocolFactory); 


  264.         /* ------------- STATO RICHIESTA E STATO RISPOSTA ------------------------------- */
  265.         //IState statoRichiesta = openSPCoopState.getStatoRichiesta();
  266.         //IState statoRisposta = openSPCoopState.getStatoRisposta();

  268.         /* ----------------- ID RICHIESTA ---------------------------------------------- */
  269.         String idMessageRequest = openspcoopstate.getIDMessaggioSessione();

  271.         /* ------------------ Inizializzazione Contesto di gestione della Richiesta --------------- */
  272.         msgDiag.mediumDebug("Inizializzo contesto per la gestione...");

  274.         boolean oneWayVersione11 = inoltroRisposteMsg.isOneWayVersione11(); 
  275.         
  276.         // Check FunctionRouting  
  277.         boolean functionAsRouter = false;
  278.         msgDiag.mediumDebug("Esamina modalita' di ricezione (PdD/Router)...");
  279.         boolean existsSoggetto = false;
  280.         try{
  281.             existsSoggetto = configurazionePdDManager.existsSoggetto(soggettoMittente, requestInfo);
  282.         }catch(Exception e){
  283.             msgDiag.logErroreGenerico(e, "existsSoggetto("+soggettoMittente.toString()+")");  
  284.             openspcoopstate.releaseResource();
  285.             esito.setStatoInvocazioneErroreNonGestito(e);
  286.             esito.setEsitoInvocazione(false); 
  287.             return esito;
  288.         }
  289.         if(existsSoggetto==false){
  290.             // La PdD non gestisce il soggetto mittente della busta.
  291.             // Controllo adesso che sia abilitata la funzione di Router per la PdD, poiche'
  292.             // mi dovrebbe essere arrivata per forza dal modulo di ricezione buste in modalita' Router.
  293.             boolean routerFunctionActive = false;
  294.             try{
  295.                 routerFunctionActive = configurazionePdDManager.routerFunctionActive();
  296.             }catch(Exception e){
  297.                 msgDiag.logErroreGenerico(e,"routerFunctionActive()");
  298.                 openspcoopstate.releaseResource();
  299.                 esito.setStatoInvocazioneErroreNonGestito(e);
  300.                 esito.setEsitoInvocazione(false); 
  301.                 return esito;
  302.             }
  303.             if(routerFunctionActive){
  304.                 functionAsRouter = true;
  305.             }else{
  306.                 msgDiag.logPersonalizzato("routingTable.soggettoFruitoreNonGestito");
  307.                 
  308.                 try{
  309.                     GestoreMessaggi msgResponse = new GestoreMessaggi(openspcoopstate, false,idMessageResponse,Costanti.OUTBOX,msgDiag,pddContext);
  310.                     msgResponse.setOneWayVersione11(oneWayVersione11);
  311.                     msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  312.                     
  313.                     RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRisposta(), false,protocolFactory);
  314.                     repositoryBuste.eliminaBustaStatelessFromOutBox(busta.getID());
  315.                     
  316.                     openspcoopstate.commit();
  317.                 }catch(Exception e){
  318.                     msgDiag.logErroreGenerico(e,"EliminazioneMessaggioSoggettoFruitoreNonGestito");
  319.                     openspcoopstate.releaseResource();
  320.                     esito.setStatoInvocazioneErroreNonGestito(e);
  321.                     esito.setEsitoInvocazione(false); 
  322.                     return esito;
  323.                 }
  324.                 
  325.                 openspcoopstate.releaseResource();
  326.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,
  327.                         "routingTable.soggettoFruitoreNonGestito");
  328.                 esito.setEsitoInvocazione(true); 
  329.                 return esito;
  330.             }
  331.         }


  334.         // Funzione
  335.         TipoPdD tipoPorta = TipoPdD.APPLICATIVA;
  336.         if(functionAsRouter)
  337.             tipoPorta = TipoPdD.ROUTER;


  340.         // Profilo di gestione
  341.         String versioneProtocollo = inoltroRisposteMsg.getProfiloGestione();
  342.         msgDiag.mediumDebug("Profilo di gestione ["+InoltroRisposte.ID_MODULO+"] della busta: "+versioneProtocollo);


  345.         // EJBUtils (per eventuali errori)
  346.         EJBUtils ejbUtils = null;
  347.         try{
  348.             ejbUtils = new EJBUtils(identitaPdD,tipoPorta,InoltroRisposte.ID_MODULO,idMessageRequest,
  349.                     idMessageResponse,Costanti.OUTBOX,openspcoopstate,msgDiag,functionAsRouter,
  350.                     inoltroRisposteMsg.getImplementazionePdDSoggettoMittente(),
  351.                     inoltroRisposteMsg.getImplementazionePdDSoggettoDestinatario(),
  352.                     versioneProtocollo,pddContext);
  353.         }catch(Exception e){
  354.             msgDiag.logErroreGenerico(e, "EJBUtils.new");  
  355.             openspcoopstate.releaseResource(); 
  356.             esito.setStatoInvocazioneErroreNonGestito(e);
  357.             esito.setEsitoInvocazione(false); 
  358.             return esito;
  359.         }
  360.         // Oneway versione 11
  361.         ejbUtils.setOneWayVersione11(oneWayVersione11);


  364.         // GestoriMessaggio
  365.         GestoreMessaggi msgResponse = new GestoreMessaggi(openspcoopstate, false,idMessageResponse,Costanti.OUTBOX,msgDiag,pddContext);
  366.         msgResponse.setOneWayVersione11(oneWayVersione11);
  367.         GestoreMessaggi msgConnectionReply = null; 
  368.         try{
  369.             if(msgResponse.isRiconsegnaMessaggio(null) == false){
  370.                 msgDiag.logPersonalizzato("riconsegnaMessaggioPrematura");
  371.                 openspcoopstate.releaseResource(); 
  372.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,
  373.                         msgDiag.getMessaggio_replaceKeywords("riconsegnaMessaggioPrematura"));
  374.                 esito.setEsitoInvocazione(false); 
  375.                 return esito;
  376.             }
  377.         }catch(Exception e){
  378.             msgDiag.logErroreGenerico(e, "msgRequest.isRiconsegnaMessaggio()");
  379.             ejbUtils.rollbackMessage("Errore verifica riconsegna messaggio", esito);
  380.             openspcoopstate.releaseResource(); 
  381.             esito.setStatoInvocazioneErroreNonGestito(e);
  382.             esito.setEsitoInvocazione(true); 
  383.             return esito;
  384.         }
  385.         

  387.         // Repository
  388.         RepositoryBuste repositoryBuste = null;
  389.         RepositoryBuste repositoryConnectionReply = null;

  391.         // Tracciamento
  392.         org.openspcoop2.pdd.logger.Tracciamento tracciamento;
  393.         try {
  394.             tracciamento = new org.openspcoop2.pdd.logger.Tracciamento(identitaPdD,InoltroBuste.ID_MODULO,pddContext,tipoPorta,msgDiag.getPorta(),
  395.                     configurazionePdDManager);
  396.         } catch (Exception e) {
  397.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  398.             openspcoopstate.releaseResource();
  399.             esito.setEsitoInvocazione(false); 
  400.             esito.setStatoInvocazioneErroreNonGestito(e);
  401.             return esito;
  402.         }
  403.         // Proprieta Manifest Attachments
  404.         ProprietaManifestAttachments proprietaManifestAttachments = 
  405.             this.propertiesReader.getProprietaManifestAttachments(implementazionePdDDestinatario);

  407.         // Read QualifiedAttribute
  408.         boolean readQualifiedAttribute = this.propertiesReader.isReadQualifiedAttribute(implementazionePdDDestinatario);









  418.         // Punto di inizio per la transazione.
  419.         Validatore validatoreProtocolConnectionReply = null;
  420.         IConnettore connectorSender = null;
  421.         String location = "";
  422.         try{

  424.             IProtocolVersionManager protocolManager = protocolFactory.createProtocolVersionManager(versioneProtocollo);



  428.             /* ------------------ Routing --------------- */

  430.             Connettore connettore = null;
  431.             String erroreRicercaConnettore = null;
  432.             if(functionAsRouter){
  433.                 // Un router puo' inoltrare solo verso il connettore del soggetto destinatario
  434.                 msgDiag.logPersonalizzato_prefix("(Router) ","routingTable.esaminaInCorso");
  435.                 try{
  436.                     connettore = configurazionePdDManager.getForwardRoute(soggettoDestinatario,functionAsRouter, requestInfo);
  437.                 }catch(Exception e){
  438.                     erroreRicercaConnettore = e.getMessage();
  439.                 }
  440.                 msgDiag.logPersonalizzato_prefix("(Router) ","routingTable.esaminaEffettuata");         
  441.             }else{
  442.                 if(configurazionePdDManager.isUtilizzoIndirizzoTelematico() && busta.getIndirizzoDestinatario()!=null){
  443.                     msgDiag.logPersonalizzato("routingTable.utilizzoIndirizzoTelematico");
  444.                     Property locationIndTel = new Property();
  445.                     locationIndTel.setNome(CostantiConnettori.CONNETTORE_LOCATION);
  446.                     locationIndTel.setValore(busta.getIndirizzoDestinatario());
  447.                     connettore = new Connettore();
  448.                     connettore.setTipo(TipiConnettore.HTTP.getNome());
  449.                     connettore.addProperty(locationIndTel);
  450.                 }else{
  451.                     msgDiag.logPersonalizzato("routingTable.esaminaInCorso");
  452.                     if(inoltroSegnalazioneErrore){
  453.                         try{
  454.                             // provo a cercare un connettore specializzato
  455.                             //log.info("Cerco busta per Mittente["+soggettoMittente.toString()+"] Destinatario["+soggettoDestinatario.toString()+"] Servizio["+busta.getTipoServizio()+busta.getServizio()+"] Azione["+busta.getAzione()+"]");
  456.                             connettore = configurazionePdDManager.getForwardRoute(soggettoMittente,idServizio,functionAsRouter, requestInfo);
  457.                         }catch(Exception e){
  458.                             erroreRicercaConnettore = "RicercaConnettoreSpecializzato, "+e.getMessage();
  459.                         }
  460.                         // provo ad inviarlo solo al soggetto
  461.                         if(connettore==null){
  462.                             try{
  463.                                 connettore = configurazionePdDManager.getForwardRoute(soggettoDestinatario,functionAsRouter, requestInfo);
  464.                             }catch(Exception e){
  465.                                 erroreRicercaConnettore = "\nRicercaConnettore, "+e.getMessage();
  466.                             }
  467.                         }
  468.                     }else{
  469.                         try{
  470.                             connettore = configurazionePdDManager.getForwardRoute(soggettoDestinatario,functionAsRouter, requestInfo);
  471.                         }catch(Exception e){
  472.                             erroreRicercaConnettore = e.getMessage();
  473.                         }
  474.                     }
  475.                     msgDiag.logPersonalizzato("routingTable.esaminaEffettuata");
  476.                 }
  477.             }           
  478.             if (connettore == null) {
  479.                 if(erroreRicercaConnettore!=null){
  480.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, erroreRicercaConnettore);
  481.                     erroreRicercaConnettore = "Riscontrato errore durante la ricerca del connettore a cui inoltrare la busta: "+erroreRicercaConnettore;
  482.                 }else{
  483.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "non definito");
  484.                     erroreRicercaConnettore = "Riscontrato errore durante la ricerca del connettore a cui inoltrare la busta: non definito";
  485.                 }
  486.                 msgDiag.logPersonalizzato("routingTable.esaminaInCorsoFallita");
  487.                 ejbUtils.rollbackMessage(erroreRicercaConnettore, esito);
  488.                 openspcoopstate.releaseResource();
  489.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,erroreRicercaConnettore);
  490.                 esito.setEsitoInvocazione(false); 
  491.                 return esito;
  492.             }









  502.             /* ----------- Trasmissione ------------------ */
  503.             String soggettoDestinatarioTrasmissione = "";
  504.             Trasmissione tras = null;
  505.             if(this.propertiesReader.isGenerazioneListaTrasmissioni(implementazionePdDDestinatario)){
  506.                 msgDiag.mediumDebug("Aggiunta trasmissione della busta ...");
  507.                 // Tracciamento in busta
  508.                 tras = new Trasmissione();
  509.                 tras.setOrigine(identitaPdD.getNome());
  510.                 tras.setTipoOrigine(identitaPdD.getTipo());
  511.                 IDSoggetto destTrasm = null;
  512.                 if(connettore.getNomeDestinatarioTrasmissioneBusta()!=null && connettore.getTipoDestinatarioTrasmissioneBusta()!=null)
  513.                     destTrasm = new IDSoggetto(connettore.getTipoDestinatarioTrasmissioneBusta(),connettore.getNomeDestinatarioTrasmissioneBusta());
  514.                 else
  515.                     destTrasm = new IDSoggetto(busta.getTipoDestinatario(),
  516.                             busta.getDestinatario());    
  517.                 tras.setDestinazione(destTrasm.getNome());
  518.                 tras.setTipoDestinazione(destTrasm.getTipo());
  519.                 tras.setOraRegistrazione(busta.getOraRegistrazione());
  520.                 tras.setTempo(this.propertiesReader.getTipoTempoBusta(implementazionePdDDestinatario));
  521.                 busta.addTrasmissione(tras);
  522.                 // net hop is Router?   
  523.                 if( (soggettoDestinatario.getNome().equals(destTrasm.getNome())==false) ||
  524.                         (soggettoDestinatario.getTipo().equals(destTrasm.getTipo())==false) )
  525.                     soggettoDestinatarioTrasmissione = " (tramite router "+destTrasm.getTipo()+"/"+destTrasm.getNome()+")";
  526.             }
  527.             msgDiag.addKeyword(CostantiPdD.KEY_DESTINATARIO_TRASMISSIONE, soggettoDestinatarioTrasmissione);







  535.             /* ------------  Ricostruzione Messaggio Soap da spedire ------------- */
  536.             msgDiag.mediumDebug("Lettura messaggio da spedire...");
  537.             OpenSPCoop2Message responseMessage = null;
  538.             //TempiAttraversamentoPDD tempiAttraversamentoGestioneMessaggi = null;
  539.             //DimensioneMessaggiAttraversamentoPdD dimensioneMessaggiAttraversamentoGestioneMessaggi = null;
  540.             try{
  541.                 responseMessage = msgResponse.getMessage();
  542.                 //tempiAttraversamentoGestioneMessaggi = msgResponse.getTempiAttraversamentoPdD();
  543.                 //dimensioneMessaggiAttraversamentoGestioneMessaggi = msgResponse.getDimensioneMessaggiAttraversamentoPdD();
  544.             }catch(Exception e){
  545.                 msgDiag.logErroreGenerico(e, "msgResponse.getMessage()");
  546.                 ejbUtils.rollbackMessage("Ricostruzione del messaggio Soap da Spedire non riuscita.", esito);
  547.                 openspcoopstate.releaseResource();
  548.                 esito.setStatoInvocazioneErroreNonGestito(e);
  549.                 esito.setEsitoInvocazione(false); 
  550.                 return esito;
  551.             }   



  555.             
  556.             
  557.             
  558.             
  559.             /* ------------ Porta Applicativa ------------ */
  560.             PortaApplicativa pa = null;
  561.             if(functionAsRouter==false){
  562.                 try{
  563.                     IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(),busta.getServizio(), 
  564.                             busta.getTipoMittente(),busta.getMittente(), 
  565.                             busta.getVersioneServizio());
  566.                     idServizioPA.setAzione(busta.getAzione());
  567.                     pa = getPortaApplicativa(configurazionePdDManager, idServizioPA);
  568.                 }catch(Exception e){
  569.                     if( !(e instanceof DriverConfigurazioneNotFound)  ){
  570.                         msgDiag.logErroreGenerico(e, "getPortaApplicativaSafeMethod");
  571.                         ejbUtils.rollbackMessage("Ricostruzione errore durante la lettura della porta applicativa.", esito);
  572.                         openspcoopstate.releaseResource();
  573.                         esito.setStatoInvocazioneErroreNonGestito(e);
  574.                         esito.setEsitoInvocazione(false); 
  575.                         return esito;
  576.                     }
  577.                 }   
  578.             }
  579.             
  580.             
  581.             
  582.             
  583.             
  584.             



  588.             /* ------------  Gestione Funzionalita' speciali per Attachments (Manifest) ------------- */    
  589.             boolean scartaBody = false;
  590.             // viene controllato servizio is not null, poiche' i riscontri non hanno un servizio
  591.             if(functionAsRouter==false && inoltroSegnalazioneErrore==false && busta.getTipoServizio()!=null && busta.getServizio()!=null){
  592.                 boolean allegaBody = configurazionePdDManager.isAllegaBody(pa);
  593.                 if(allegaBody){
  594.                     // E' stato effettuato prima l'inserimento del body come allegato.
  595.                     // Forzo lo scartamento.
  596.                     scartaBody = true;
  597.                 }else{
  598.                     scartaBody = configurazionePdDManager.isScartaBody(pa);
  599.                 }
  600.             }




  605.             

  607.             /* ------------  Aggiunta eccezioni di livello info riscontrate dalla validazione, se profilo e' lineeGuida1.1 ------------- */ 
  608.             if(functionAsRouter==false){
  609.                 if(  (inoltroSegnalazioneErrore==false) && (busta.sizeListaEccezioni()==0) && protocolManager.isEccezioniLivelloInfoAbilitato() ){
  610.                     RepositoryBuste repositoryBustaRichiesta = new RepositoryBuste(openspcoopstate.getStatoRisposta(), false, protocolFactory);
  611.                     List<Eccezione> erroriValidazione = repositoryBustaRichiesta.getErrorsFromInBox(busta.getRiferimentoMessaggio());
  612.                     for(int i=0; i<erroriValidazione.size();i++){
  613.                         Eccezione ec = erroriValidazione.get(i);
  614.                         if(LivelloRilevanza.INFO.equals(ec.getRilevanza())){
  615.                             busta.addEccezione(ec);
  616.                         }
  617.                     }
  618.                 }
  619.             }






  626.             /* ------------  Imbustamento ------------- */  
  627.             msgDiag.mediumDebug("Imbustamento ...");
  628.             BustaRawContent<?> headerBusta = null;
  629.             org.openspcoop2.protocol.engine.builder.Imbustamento imbustatore = null;
  630.             boolean gestioneManifest = false;
  631.             RuoloMessaggio ruoloMessaggio = null;
  632.             if(inoltroRisposteMsg.isImbustamento()){
  633.                 try{
  634.                     ruoloMessaggio = RuoloMessaggio.RISPOSTA;
  635.                     if(inoltroSegnalazioneErrore)
  636.                         ruoloMessaggio = RuoloMessaggio.RICHIESTA;
  637.                     imbustatore = 
  638.                             new org.openspcoop2.protocol.engine.builder.Imbustamento(this.log,protocolFactory, openspcoopstate.getStatoRichiesta());
  639.     
  640.                     gestioneManifest = configurazionePdDManager.isGestioneManifestAttachments();
  641.                     // viene controllato servizio is not null, poiche' i riscontri non hanno un servizio
  642.                     if(functionAsRouter==false && inoltroSegnalazioneErrore==false  && busta.getTipoServizio()!=null && busta.getServizio()!=null){
  643.                         gestioneManifest = configurazionePdDManager.isGestioneManifestAttachments(pa,protocolFactory);
  644.                     }
  645.                     if(functionAsRouter && 
  646.                             !( identitaPdD.getTipo().equals(busta.getTipoMittente()) && identitaPdD.getNome().equals(busta.getMittente()) ) 
  647.                     ){
  648.                         // Aggiungo trasmissione solo se la busta e' stata generata dalla porta di dominio destinataria della richiesta.
  649.                         // Se il mittente e' il router, logicamente la busta sara' un errore generato dal router
  650.                         msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento ["+responseMessage.getClass().getName()+"]");
  651.                         ProtocolMessage protocolMessage = imbustatore.addTrasmissione(responseMessage, tras, readQualifiedAttribute,
  652.                                 FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  653.                         if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  654.                             headerBusta = protocolMessage.getBustaRawContent();
  655.                             responseMessage = protocolMessage.getMessage(); // updated
  656.                         }
  657.                         msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento ["+responseMessage.getClass().getName()+"]");
  658.                     }
  659.                     else{
  660.                         Integrazione integrazione = new Integrazione();
  661.                         integrazione.setStateless(false);
  662.                         msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento ["+responseMessage.getClass().getName()+"]");
  663.                         ProtocolMessage protocolMessage = null;
  664.                         if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)) {
  665.                             protocolMessage = imbustatore.imbustamentoRichiesta(responseMessage,pddContext,
  666.                                     busta,
  667.                                     integrazione,gestioneManifest,scartaBody,proprietaManifestAttachments,
  668.                                     FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  669.                         }
  670.                         else {
  671.                             protocolMessage = imbustatore.imbustamentoRisposta(responseMessage,pddContext,
  672.                                     busta,null,
  673.                                     integrazione,gestioneManifest,scartaBody,proprietaManifestAttachments,
  674.                                     FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  675.                         }
  676.                         if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  677.                             headerBusta = protocolMessage.getBustaRawContent();
  678.                             responseMessage = protocolMessage.getMessage(); // updated
  679.                         }
  680.                         msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento ["+responseMessage.getClass().getName()+"]");
  681.                     }
  682.                 }catch(Exception e){
  683.                     if(functionAsRouter)
  684.                         msgDiag.logErroreGenerico(e, "imbustatore.before-security.addTrasmissione");
  685.                     else
  686.                         msgDiag.logErroreGenerico(e, "imbustatore.before-security.imbustamento");
  687.                     ejbUtils.rollbackMessage("Imbustamento non riuscito.", esito);
  688.                     openspcoopstate.releaseResource();  
  689.                     esito.setStatoInvocazioneErroreNonGestito(e);
  690.                     esito.setEsitoInvocazione(false); 
  691.                     return esito;
  692.                 }
  693.             }






  700.             /* ----------- Raccolta FlowParameter MTOM / Security ------------ */
  701.             msgDiag.mediumDebug("Raccolta FlowParameter MTOM / Security proprieta...");
  702.             MTOMProcessor mtomProcessor = null;
  703.             MessageSecurityConfig securityConfig = null;
  704.             FlowProperties flowProperties = null;
  705.             if(functionAsRouter==false){
  706.                 
  707.                 try{
  708.                     flowProperties = this.getFlowProperties(busta,configurazionePdDManager,openspcoopstate.getStatoRisposta(),
  709.                             msgDiag,protocolFactory,pa, requestInfo);
  710.                 }catch(Exception e){
  711.                     msgDiag.logErroreGenerico(e, "RaccoltaFlowParameter_MTOM_Security");
  712.                     ejbUtils.rollbackMessage("RaccoltaFlowParameter_MTOM_Security non riuscita:"+e.getMessage(), esito);
  713.                     openspcoopstate.releaseResource();
  714.                     esito.setStatoInvocazioneErroreNonGestito(e);
  715.                     esito.setEsitoInvocazione(false); 
  716.                     return esito;
  717.                 }
  718.                 
  719.                 if(flowProperties!=null){
  720.                     msgDiag.mediumDebug("init MTOM Processor ...");
  721.                     mtomProcessor = new MTOMProcessor(flowProperties.mtom, flowProperties.messageSecurity, 
  722.                             tipoPorta, msgDiag, this.log, pddContext);
  723.                     securityConfig = flowProperties.messageSecurity;
  724.                 }
  725.             }
  726.             
  727.             


  730.             
  731.             
  732.             
  733.             
  734.             
  735.             /* ----------- MTOM Processor BeforeSecurity ------------ */
  736.             msgDiag.mediumDebug("MTOM Processor [BeforeSecurity]...");
  737.             try{
  738.                 if(mtomProcessor!=null && flowProperties!=null) {
  739.                     mtomProcessor.mtomBeforeSecurity(responseMessage, flowProperties.tipoMessaggio);
  740.                 }
  741.             }catch(Exception e){
  742.                 // L'errore viene registrato dentro il metodo mtomProcessor.mtomBeforeSecurity
  743.                 //msgDiag.logErroreGenerico(e,"MTOMProcessor(BeforeSec-"+mtomProcessor.getMTOMProcessorType()+")");
  744.             
  745.                 ejbUtils.rollbackMessage("Riscontrato errore durante la gestione MTOM(BeforeSec-"+mtomProcessor.getMTOMProcessorType()+"): "+e.getMessage(), esito);
  746.                 openspcoopstate.releaseResource();
  747.                 esito.setStatoInvocazioneErroreNonGestito(e);
  748.                 esito.setEsitoInvocazione(false); 
  749.                 return esito;
  750.             }
  751.             
  752.             
  753.             
  754.             
  755.             
  756.             
  757.             


  760.             /* ------------  Gestione MessageSecurity ------------- */
  761.             SecurityInfo securityInfo = null;
  762.             if(inoltroSegnalazioneErrore == false && functionAsRouter==false){
  763.                 msgDiag.mediumDebug("Gestione MessageSecurity del messaggio da inoltrare...");
  764.                                 
  765.                 // Imposto un context di Base 
  766.                 MessageSecurityContext messageSecurityContext = null;
  767.                 // MessageSecuritySender    
  768.                 if(securityConfig!=null && securityConfig.getFlowParameters()!=null && securityConfig.getFlowParameters().size()>0){
  769.                     try{
  770.                         MessageSecurityContextParameters contextParameters = new MessageSecurityContextParameters();
  771.                         contextParameters.setUseActorDefaultIfNotDefined(this.propertiesReader.isGenerazioneActorDefault(implementazionePdDDestinatario));
  772.                         contextParameters.setActorDefault(this.propertiesReader.getActorDefault(implementazionePdDDestinatario));
  773.                         contextParameters.setLog(this.log);
  774.                         contextParameters.setFunctionAsClient(SecurityConstants.SECURITY_SERVER);
  775.                         contextParameters.setPrefixWsuId(this.propertiesReader.getPrefixWsuId());
  776.                         contextParameters.setRemoveAllWsuIdRef(this.propertiesReader.isRemoveAllWsuIdRef());
  777.                         contextParameters.setIdFruitore(soggettoMittente);
  778.                         contextParameters.setIdServizio(idServizio);
  779.                         contextParameters.setPddFruitore(registroServiziManager.getIdPortaDominio(soggettoMittente, null, requestInfo));
  780.                         contextParameters.setPddErogatore(registroServiziManager.getIdPortaDominio(idServizio.getSoggettoErogatore(), null, requestInfo));
  781.                         messageSecurityContext = new MessageSecurityFactory().getMessageSecurityContext(contextParameters);
  782.                         messageSecurityContext.setOutgoingProperties(securityConfig.getFlowParameters());
  783.                         DynamicMapBuilderUtils.injectDynamicMap(busta, requestInfo, pddContext, this.log);
  784.                         if(messageSecurityContext.processOutgoing(responseMessage,pddContext,
  785.                                 transactionNullable!=null ? transactionNullable.getTempiElaborazione() : null) == false){
  786.                             msgDiag.logErroreGenerico(messageSecurityContext.getMsgErrore(), "Costruzione header MessageSecurity");
  787.                             String motivazioneErrore = "Applicazione MessageSecurity non riuscita:"+messageSecurityContext.getMsgErrore();
  788.                             ejbUtils.rollbackMessage(motivazioneErrore, esito);
  789.                             openspcoopstate.releaseResource();
  790.                             esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, motivazioneErrore);
  791.                             esito.setEsitoInvocazione(false); 
  792.                             return esito;
  793.                         }
  794.                     }catch(Exception e){
  795.                         msgDiag.logErroreGenerico(e, "set MessageSecurityContext");
  796.                         ejbUtils.rollbackMessage("Applicazione MessageSecurity non riuscita:"+e.getMessage(), esito);
  797.                         openspcoopstate.releaseResource();
  798.                         esito.setStatoInvocazioneErroreNonGestito(e);
  799.                         esito.setEsitoInvocazione(false); 
  800.                         return esito;
  801.                     }
  802.                 }

  804.                 
  805.                 try{
  806.                     IDigestReader digestReader = null;
  807.                     if(messageSecurityContext != null) {
  808.                         digestReader = messageSecurityContext.getDigestReader(responseMessage!=null ? responseMessage.getFactory() : OpenSPCoop2MessageFactory.getDefaultMessageFactory());
  809.                     }
  810.                     if(digestReader!=null){
  811.                         securityInfo = validazioneSemantica.readSecurityInformation(digestReader, responseMessage);
  812.                     }
  813.                 }catch(Exception e){
  814.                     msgDiag.logErroreGenerico(e,"ErroreLetturaInformazioniSicurezza");
  815.                     ejbUtils.rollbackMessage("Lettura informazioni di sicurezza:"+e.getMessage(), esito);
  816.                     openspcoopstate.releaseResource();
  817.                     esito.setStatoInvocazioneErroreNonGestito(e);
  818.                     esito.setEsitoInvocazione(false); 
  819.                     return esito;
  820.                 }
  821.                 
  822.             }




  827.             
  828.             
  829.             
  830.             
  831.             /* ----------- MTOM Processor AfterSecurity ------------ */
  832.             msgDiag.mediumDebug("MTOM Processor [AfterSecurity]...");
  833.             try{
  834.                 if(mtomProcessor!=null) {
  835.                     mtomProcessor.mtomAfterSecurity(responseMessage, flowProperties!=null ? flowProperties.tipoMessaggio : RuoloMessaggio.RISPOSTA);
  836.                 }
  837.             }catch(Exception e){
  838.                 // L'errore viene registrato dentro il metodo mtomProcessor.mtomAfterSecurity
  839.                 //msgDiag.logErroreGenerico(e,"MTOMProcessor(AfterSec-"+mtomProcessor.getMTOMProcessorType()+")");
  840.             
  841.                 ejbUtils.rollbackMessage("Riscontrato errore durante la gestione MTOM(AfterSec-"+mtomProcessor.getMTOMProcessorType()+"): "+e.getMessage(), esito);
  842.                 openspcoopstate.releaseResource();
  843.                 esito.setStatoInvocazioneErroreNonGestito(e);
  844.                 esito.setEsitoInvocazione(false); 
  845.                 return esito;
  846.             }
  847.             
  848.             
  849.             
  850.             
  851.             
  852.             

  854.             /* ------------  Imbustamento ------------- */  
  855.             msgDiag.mediumDebug("Imbustamento (after-security) ...");
  856.             if(inoltroRisposteMsg.isImbustamento()){
  857.                 try{
  858.                     if(functionAsRouter && 
  859.                             !( identitaPdD.getTipo().equals(busta.getTipoMittente()) && identitaPdD.getNome().equals(busta.getMittente()) ) 
  860.                     ){
  861.                         // Aggiungo trasmissione solo se la busta e' stata generata dalla porta di dominio destinataria della richiesta.
  862.                         // Se il mittente e' il router, logicamente la busta sara' un errore generato dal router
  863.                         msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  864.                         ProtocolMessage protocolMessage = imbustatore.addTrasmissione(responseMessage, tras, readQualifiedAttribute,
  865.                                 FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  866.                         if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  867.                             headerBusta = protocolMessage.getBustaRawContent();
  868.                             responseMessage = protocolMessage.getMessage(); // updated
  869.                         }
  870.                         msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  871.                     }
  872.                     else{
  873.                         Integrazione integrazione = new Integrazione();
  874.                         integrazione.setStateless(false);
  875.                         msgDiag.highDebug("Tipo Messaggio Risposta prima dell'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  876.                         ProtocolMessage protocolMessage = null;
  877.                         if(RuoloMessaggio.RICHIESTA.equals(ruoloMessaggio)) {
  878.                             protocolMessage = imbustatore.imbustamentoRichiesta(responseMessage,pddContext,
  879.                                     busta,
  880.                                     integrazione,gestioneManifest,scartaBody,proprietaManifestAttachments,
  881.                                     FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  882.                         }
  883.                         else {
  884.                             protocolMessage = imbustatore.imbustamentoRisposta(responseMessage,pddContext,
  885.                                     busta,null,
  886.                                     integrazione,gestioneManifest,scartaBody,proprietaManifestAttachments,
  887.                                     FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  888.                         }
  889.                         if(protocolMessage!=null && !protocolMessage.isPhaseUnsupported()) {
  890.                             headerBusta = protocolMessage.getBustaRawContent();
  891.                             responseMessage = protocolMessage.getMessage(); // updated
  892.                         }
  893.                         msgDiag.highDebug("Tipo Messaggio Risposta dopo l'imbustamento (after-security) ["+responseMessage.getClass().getName()+"]");
  894.                     }
  895.                 }catch(Exception e){
  896.                     if(functionAsRouter)
  897.                         msgDiag.logErroreGenerico(e, "imbustatore.after-security.addTrasmissione");
  898.                     else
  899.                         msgDiag.logErroreGenerico(e, "imbustatore.after-security.imbustamento");
  900.                     ejbUtils.rollbackMessage("Imbustamento non riuscito (after-security).", esito);
  901.                     openspcoopstate.releaseResource();  
  902.                     esito.setStatoInvocazioneErroreNonGestito(e);
  903.                     esito.setEsitoInvocazione(false); 
  904.                     return esito;
  905.                 }
  906.             }
  907.             
  908.             
  909.             
  910.             
  911.             
  912.             
  913.             /* ---------------- OutResponseHandler ----------------------*/
  914.             
  915.             
  916.             OutResponseContext outResponseContext = new OutResponseContext(this.log,protocolFactory,openspcoopstate.getStatoRichiesta());
  917.         
  918.             EsitoTransazione esitoHandler = null;
  919.             if(inoltroSegnalazioneErrore==false){
  920.                 
  921.                 // Informazioni sul messaggio
  922.                 outResponseContext.setMessaggio(responseMessage);
  923.                 
  924.                 // Contesto
  925.                 ProtocolContext protocolContext = new ProtocolContext();
  926.                 protocolContext.setIdRichiesta(idMessageRequest);
  927.                 protocolContext.setFruitore(soggettoMittente);
  928.                 if(busta!=null){
  929.                     protocolContext.setIndirizzoFruitore(busta.getIndirizzoMittente());
  930.                 }
  931.                 protocolContext.setErogatore(soggettoDestinatario);
  932.                 if(busta!=null){
  933.                     protocolContext.setIndirizzoErogatore(busta.getIndirizzoDestinatario()); 
  934.                 }
  935.                 if(busta!=null){
  936.                     protocolContext.setTipoServizio(busta.getTipoServizio());
  937.                     protocolContext.setServizio(busta.getServizio());
  938.                     protocolContext.setVersioneServizio(busta.getVersioneServizio());
  939.                     protocolContext.setAzione(busta.getAzione());
  940.                     protocolContext.setProfiloCollaborazione(busta.getProfiloDiCollaborazione(),busta.getProfiloDiCollaborazioneValue());
  941.                     protocolContext.setCollaborazione(busta.getCollaborazione());
  942.                     protocolContext.setIdRisposta(busta.getID());
  943.                 }
  944.                 protocolContext.setDominio(msgDiag.getDominio());
  945.                 outResponseContext.setProtocollo(protocolContext);
  946.                 
  947.                 // Integrazione
  948.                 IntegrationContext integrationContext = new IntegrationContext();
  949.                 integrationContext.setIdCorrelazioneApplicativa(inoltroRisposteMsg.getIdCorrelazioneApplicativa());
  950.                 integrationContext.setServizioApplicativoFruitore(inoltroRisposteMsg.getServizioApplicativoFruitore());
  951.                 integrationContext.setGestioneStateless(false);
  952.                 outResponseContext.setIntegrazione(integrationContext);
  953.                 
  954.                 // Altre informazioni
  955.                 outResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  956.                 outResponseContext.setPddContext(pddContext);
  957.                 outResponseContext.setTipoPorta(tipoPorta);
  958.                 outResponseContext.setIdModulo(this.idModulo);
  959.                 
  960.                 // Invocazione Handler
  961.                 try{
  962.                     GestoreHandlers.outResponse(outResponseContext, msgDiag, this.log);
  963.                 }catch(Exception e){
  964.                     if(e instanceof HandlerException){
  965.                         HandlerException he = (HandlerException) e;
  966.                         if(he.isEmettiDiagnostico()){
  967.                             msgDiag.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  968.                         }
  969.                         ejbUtils.rollbackMessage(((HandlerException)e).getIdentitaHandler()+" error: "+e.getMessage(), esito);
  970.                     }else{
  971.                         msgDiag.logErroreGenerico(e, "OutResponseHandler");
  972.                         ejbUtils.rollbackMessage("OutResponseHandler error: "+e.getMessage(), esito);
  973.                     }
  974.                     openspcoopstate.releaseResource();
  975.                     esito.setStatoInvocazioneErroreNonGestito(e);
  976.                     esito.setEsitoInvocazione(false); 
  977.                     return esito;
  978.                 }
  979.             
  980.                 // Prendo messaggio rielaborato
  981.                 responseMessage = outResponseContext.getMessaggio();
  982.                 if(responseMessage!=null){
  983.                     esitoHandler = protocolFactory.createEsitoBuilder().getEsito(null,
  984.                             200, requestInfo.getProtocolServiceBinding(),
  985.                             responseMessage, null, 
  986.                             pddContext);            
  987.                     
  988.                 }
  989.             }
  990.             
  991.             
  992.             
  993.             
  994.             
  995.             
  996.             
  997.             





  1003.             /* ------------------- 
  1004.        Rilascio Risorse (Le riprendero' dopo aver ottenuto la risposta, se necessario) 
  1005.        Le informazioni nel DB sono state utilizzate fino a questo punto solo in lettura.
  1006.        Eventuali spedizioni JMS sono state effettuate e le risorse gia' rilasciate (non arrivero a questo punto)
  1007.        -----------------------*/
  1008.             msgDiag.mediumDebug("Rilascio connessione al database..."); 
  1009.             openspcoopstate.releaseResource();


  1012.             
  1013.             
  1014.             
  1015.             
  1016.             
  1017.             


  1020.             /* ------------------- Spedizione Messaggio Soap -----------------------*/
  1021.             msgDiag.mediumDebug("Impostazione messaggio del connettore...");

  1023.             //  Connettore per consegna
  1024.             String tipoConnector = connettore.getTipo();
  1025.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_CONNETTORE, tipoConnector);
  1026.             org.openspcoop2.core.config.Property [] cps = null;
  1027.             if(connettore.getPropertyList().size()>0){
  1028.                 cps = connettore.getPropertyList().toArray(new org.openspcoop2.core.config.Property[connettore.getPropertyList().size()]);
  1029.             }
  1030.             ConnettoreMsg connettoreMsg = new ConnettoreMsg(tipoConnector,responseMessage,cps);
  1031.             connettoreMsg.setBusta(busta);
  1032.             connettoreMsg.setIdModulo(InoltroRisposte.ID_MODULO);
  1033.             connettoreMsg.setProtocolFactory(protocolFactory);
  1034.             connettoreMsg.setMsgDiagnostico(msgDiag);
  1035.             connettoreMsg.setState(openspcoopstate.getStatoRichiesta());
  1036.             connettoreMsg.initPolicyGestioneToken(configurazionePdDManager, requestInfo);
  1037.             
  1038.             // Risposte del connettore
  1039.             int codiceRitornato = -1;
  1040.             OpenSPCoop2Message responseHttpReply = null;

  1042.             // Stato consegna tramite connettore
  1043.             boolean errorConsegna = false;
  1044.             boolean riconsegna = false;
  1045.             java.sql.Timestamp dataRiconsegna = null;
  1046.             String motivoErroreConsegna = null;
  1047.             boolean invokerNonSupportato = false;
  1048.             SOAPFault soapFaultConnectionReply = null;
  1049.             ProblemRFC7807 restProblemConnectionReply = null;
  1050.             OpenSPCoop2MessageFactory faultConnectionReplyMessageFactory = null;
  1051.             Exception eccezioneProcessamentoConnettore = null;

  1053.             // Carico connettore richiesto
  1054.             String connectorClass = null;
  1055.             @SuppressWarnings("unused")
  1056.             Exception eInvokerNonSupportato = null;
  1057.             if(invokerNonSupportato==false){
  1058.                 try{
  1059.                     connectorSender = (IConnettore) this.pluginLoader.newConnettore(tipoConnector);
  1060.                 }
  1061.                 catch(Exception e){
  1062.                     msgDiag.logErroreGenerico(e,"Inizializzazione Connettore"); // l'errore contiene gia tutte le informazioni
  1063.                     invokerNonSupportato = true;
  1064.                     eInvokerNonSupportato = e;
  1065.                 }
  1066.                 if(connectorSender!=null) {
  1067.                     try {
  1068.                         connectorClass = connectorSender.getClass().getName();
  1069.                         AbstractCore.init(connectorSender, pddContext, protocolFactory);
  1070.                     }catch(Exception e){
  1071.                         msgDiag.logErroreGenerico(e,"IConnettore.newInstance(tipo:"+tipoConnector+" class:"+connectorClass+")");
  1072.                         invokerNonSupportato = true;
  1073.                         eInvokerNonSupportato = e;
  1074.                     }
  1075.                 }
  1076.                 if( (invokerNonSupportato == false) && (connectorSender == null)){
  1077.                     msgDiag.logErroreGenerico("ConnectorSender is null","IConnettore.newInstance(tipo:"+tipoConnector+" class:"+connectorClass+")");
  1078.                     invokerNonSupportato = true;
  1079.                 }
  1080.             }

  1082.             // Imposto tipo di richiesta
  1083.             HttpRequestMethod httpRequestMethod = null;
  1084.             if(connectorSender!=null){
  1085.                 try{
  1086.                     if(connectorSender instanceof ConnettoreBaseHTTP){
  1087.                         ConnettoreBaseHTTP baseHttp = (ConnettoreBaseHTTP) connectorSender;
  1088.                         baseHttp.setHttpMethod(responseMessage);
  1089.                         
  1090.                         if(ServiceBinding.REST.equals(responseMessage.getServiceBinding())){
  1091.                             httpRequestMethod = baseHttp.getHttpMethod();
  1092.                         }
  1093.                     }
  1094.                 }catch(Exception e){
  1095.                     msgDiag.logErroreGenerico(e,"ConnettoreBaseHTTP.setHttpMethod(tipo:"+tipoConnector+" class:"+connectorClass+")");
  1096.                     invokerNonSupportato = true;
  1097.                     eInvokerNonSupportato = e;
  1098.                 }
  1099.             }
  1100.             
  1101.             // Location
  1102.             location = ConnettoreUtils.getAndReplaceLocationWithBustaValues(connectorSender, connettoreMsg, busta, pddContext, protocolFactory, this.log);
  1103.             if(location!=null){
  1104.                 String locationWithUrl = ConnettoreUtils.buildLocationWithURLBasedParameter(this.log, responseMessage, connettoreMsg.getTipoConnettore(), connettoreMsg.getPropertiesUrlBased(), location,
  1105.                         protocolFactory, this.idModulo);
  1106.                 locationWithUrl = ConnettoreUtils.addProxyInfoToLocationForHTTPConnector(connettoreMsg.getTipoConnettore(), connettoreMsg.getConnectorProperties(), locationWithUrl);
  1107.                 msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, ConnettoreUtils.formatLocation(httpRequestMethod, locationWithUrl));
  1108.                 
  1109.                 pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_METHOD, httpRequestMethod);
  1110.                 pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_URL, locationWithUrl);
  1111.             }
  1112.             else{
  1113.                 msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, "N.D.");
  1114.             }

  1116.             // timeout di default
  1117.             if(connettoreMsg.getConnectorProperties()==null){
  1118.                 java.util.Map<String,String> propCon = new java.util.HashMap<>();
  1119.                 connettoreMsg.setConnectorProperties(propCon);
  1120.             }
  1121.             if(connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)==null ||
  1122.                     connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)==null){
  1123.                 DatiTempiRisposta datiTempiRisposta = ConnettoreUtilities.readDatiGlobaliTimeout(configurazionePdDManager, TipoPdD.DELEGATA, requestInfo, this.propertiesReader);
  1124.                 if(connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)==null){
  1125.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT,
  1126.                             "" + ((datiTempiRisposta!=null && datiTempiRisposta.getConnectionTimeout()!=null) ? datiTempiRisposta.getConnectionTimeout().intValue() : this.propertiesReader.getConnectionTimeout_inoltroBuste()));
  1127.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT_GLOBALE, "true" );
  1128.                 }
  1129.                 if(connettoreMsg.getConnectorProperties().get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)==null){
  1130.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT,
  1131.                             "" + ((datiTempiRisposta!=null && datiTempiRisposta.getReadConnectionTimeout()!=null) ? datiTempiRisposta.getReadConnectionTimeout().intValue() : this.propertiesReader.getReadConnectionTimeout_inoltroBuste()));
  1132.                     connettoreMsg.getConnectorProperties().put(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE, "true" );
  1133.                 }
  1134.             }
  1135.             
  1136.             // User-Agent e X-* header
  1137.             UtilitiesIntegrazione httpUtilities = UtilitiesIntegrazione.getInstancePAResponse(this.log);
  1138.             if(connettoreMsg.getPropertiesTrasporto()==null){
  1139.                 Map<String, List<String>>  trasporto = new HashMap<> ();
  1140.                 connettoreMsg.setPropertiesTrasporto(trasporto);
  1141.             }
  1142.             httpUtilities.setInfoProductTransportProperties(connettoreMsg.getPropertiesTrasporto());


  1145.             // Informazioni connettore in uscita
  1146.             InfoConnettoreUscita infoConnettoreUscita = new InfoConnettoreUscita();
  1147.             infoConnettoreUscita.setLocation(location);
  1148.             infoConnettoreUscita.setProperties(connettoreMsg.getConnectorProperties());
  1149.             infoConnettoreUscita.setHeaders(connettoreMsg.getPropertiesTrasporto());
  1150.             infoConnettoreUscita.setParameters(connettoreMsg.getPropertiesUrlBased());
  1151.             infoConnettoreUscita.setSbustamentoSoap(connettoreMsg.isSbustamentoSOAP());
  1152.             infoConnettoreUscita.setSbustamentoInformazioniProtocollo(connettoreMsg.isSbustamentoInformazioniProtocollo());
  1153.             infoConnettoreUscita.setTipoAutenticazione(connettoreMsg.getAutenticazione());
  1154.             infoConnettoreUscita.setCredenziali(connettoreMsg.getCredenziali());
  1155.             infoConnettoreUscita.setTipoConnettore(connettoreMsg.getTipoConnettore());
  1156.             
  1157.             //  Utilizzo Connettore
  1158.             if(invokerNonSupportato==false){
  1159.                 msgDiag.logPersonalizzato("inoltroInCorso");
  1160.                 // utilizzo connettore
  1161.                 errorConsegna = !connectorSender.send(null, connettoreMsg);
  1162.                 motivoErroreConsegna = connectorSender.getErrore();
  1163.                 eccezioneProcessamentoConnettore = connectorSender.getEccezioneProcessamento();
  1164.                 if(errorConsegna && motivoErroreConsegna==null){
  1165.                     motivoErroreConsegna = "Errore durante la consegna";
  1166.                 }
  1167.                 //  interpretazione esito consegna
  1168.                 GestioneErrore gestioneConsegnaConnettore = configurazionePdDManager.getGestioneErroreConnettoreComponenteCooperazione(protocolFactory, responseMessage.getServiceBinding());
  1169.                 GestoreErroreConnettore  gestoreErrore = new GestoreErroreConnettore();
  1170.                 errorConsegna = !gestoreErrore.verificaConsegna(gestioneConsegnaConnettore,motivoErroreConsegna,eccezioneProcessamentoConnettore,connectorSender);
  1171.                 if(errorConsegna){
  1172.                     motivoErroreConsegna = gestoreErrore.getErrore();
  1173.                     riconsegna = gestoreErrore.isRiconsegna();
  1174.                     dataRiconsegna = gestoreErrore.getDataRispedizione();
  1175.                 }
  1176.                 // raccolta risultati del connettore
  1177.                 soapFaultConnectionReply = gestoreErrore.getFault();
  1178.                 restProblemConnectionReply = gestoreErrore.getProblem();
  1179.                 faultConnectionReplyMessageFactory = connectorSender.getResponse()!=null ? connectorSender.getResponse().getFactory() : OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  1180.                 codiceRitornato = connectorSender.getCodiceTrasporto();
  1181.                 responseHttpReply = connectorSender.getResponse();
  1182.                 Map<String, List<String>>  headerTrasportoReply = connectorSender.getHeaderTrasporto();
  1183.                 // gestione connessione connettore
  1184.                 // Sono nella casistica di messaggio preso in carico.
  1185.                 // Non si deve chiudere immediatamente la connessione, poiche' nel resto del modulo, il messaggio puo' ancora essere utilizzato (es. dump)
  1186.                 /*
  1187.                 try{
  1188.                     connectorSender.disconnect();
  1189.                 }catch(Exception e){
  1190.                     msgDiag.logDisconnectError(e, location);
  1191.                 }
  1192.                 */

  1194.                 msgDiag.addKeyword(CostantiPdD.KEY_CODICE_CONSEGNA, codiceRitornato+"");
  1195.                 if(motivoErroreConsegna!=null)
  1196.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_CONSEGNA, motivoErroreConsegna);
  1197.                 
  1198.                 // Il Connettore potrebbe aggiungere informazioni alla location.
  1199.                 String tmpLocation = connectorSender.getLocation();
  1200.                 if(tmpLocation!=null){
  1201.                     
  1202.                     // salvo la request url originale, se la risposta non è letta dalla cache
  1203.                     boolean responseCached = false;
  1204.                     if(pddContext.containsKey(ConnettoreBase.RESPONSE_FROM_CACHE)) {
  1205.                         responseCached = (Boolean) pddContext.getObject(ConnettoreBase.RESPONSE_FROM_CACHE);
  1206.                     }
  1207.                     if(!responseCached) {
  1208.                         pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_METHOD, httpRequestMethod);
  1209.                         pddContext.addObject(CostantiPdD.CONNETTORE_REQUEST_URL, tmpLocation);
  1210.                     }
  1211.                     
  1212.                     // aggiorno
  1213.                     location = tmpLocation;
  1214.                     if(responseCached) {
  1215.                         msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, location);
  1216.                     }
  1217.                     else {
  1218.                         msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, ConnettoreUtils.formatLocation(httpRequestMethod, location));
  1219.                     }
  1220.                 }
  1221.                 
  1222.                 //  dump applicativo
  1223.                 if(responseHttpReply!=null ){
  1224.                     DumpConfigurazione dumpConfig = configurazionePdDManager.getDumpConfigurazione(pa);
  1225.                     Dump dumpApplicativo = new Dump(identitaPdD,InoltroRisposte.ID_MODULO,idMessageRequest,
  1226.                             soggettoMittente,idServizio,tipoPorta,msgDiag.getPorta(),pddContext,
  1227.                             openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta(),
  1228.                             dumpConfig);
  1229.                     dumpApplicativo.dumpRispostaIngresso(responseHttpReply, infoConnettoreUscita, headerTrasportoReply);
  1230.                 }
  1231.             }

  1233.             
  1234.             
  1235.             
  1236.             
  1237.             
  1238.             
  1239.             
  1240.             
  1241.             /* ------------  Re-ottengo Connessione al DB -------------- */
  1242.             msgDiag.mediumDebug("Richiesta connessione al database per la gestione della risposta...");
  1243.             openspcoopstate.updateResource(idTransazione);







  1251.             /* ------------  Tracciamento Richiesta e Messaggio Diagnostico ------------- */
  1252.             IValidatoreErrori validatoreErrori = protocolFactory.createValidatoreErrori(openspcoopstate.getStatoRichiesta());
  1253.             if(invokerNonSupportato==false){ //&& errorConsegna==false){

  1255.                 // Tracciamento effettuato sempre
  1256.                 msgDiag.mediumDebug("Tracciamento della busta...");
  1257.                 EsitoElaborazioneMessaggioTracciato esitoTraccia = EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioInviato();
  1258.                 if(inoltroSegnalazioneErrore){
  1259.                     tracciamento.registraRichiesta(responseMessage,securityInfo,headerBusta,busta,esitoTraccia,
  1260.                             Tracciamento.createLocationString(false, location),
  1261.                             inoltroRisposteMsg.getIdCorrelazioneApplicativa());
  1262.                 }
  1263.                 else{
  1264.                     tracciamento.registraRisposta(responseMessage,securityInfo,headerBusta,busta,esitoTraccia,
  1265.                             Tracciamento.createLocationString(false, location),
  1266.                             inoltroRisposteMsg.getIdCorrelazioneApplicativa(),inoltroRisposteMsg.getIdCorrelazioneApplicativaRisposta());
  1267.                 }

  1269.                 if(errorConsegna){
  1270.                     msgDiag.logPersonalizzato("inoltroConErrore");
  1271.                 }else{
  1272.                     String tipoMsg = "Messaggio Protocollo";
  1273.                     ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  1274.                     pValidazioneErrori.setIgnoraEccezioniNonGravi(protocolManager.isIgnoraEccezioniNonGravi());
  1275.                     pValidazioneErrori.setVersioneProtocollo(versioneProtocollo);
  1276.                     if(validatoreErrori.isBustaErrore(busta,responseMessage,pValidazioneErrori))
  1277.                         tipoMsg = tipoMsg + " Errore";

  1279.                     if(configurazionePdDManager.isUtilizzoIndirizzoTelematico() && busta.getIndirizzoDestinatario()!=null){
  1280.                         msgDiag.addKeyword(CostantiPdD.KEY_LOCATION, ("indirizzoTelematico["+busta.getIndirizzoDestinatario()+"]"));
  1281.                         msgDiag.logPersonalizzato("inoltroEffettuato");
  1282.                     }else{
  1283.                         msgDiag.logPersonalizzato("inoltroEffettuato");
  1284.                     }
  1285.                 }
  1286.             }









  1296.         




  1301.             /* ------------- Analisi di una risposta ritornata ------------*/
  1302.             boolean presenzaRispostaProtocolConnectionReply = false;
  1303.             
  1304.             if(responseHttpReply != null ){
  1305.                 msgDiag.mediumDebug("Analisi della risposta (validazione sintattica)...");
  1306.                 // ValidazioneSintattica: serve a leggere il messaggio
  1307.                 ProprietaValidazione property = new ProprietaValidazione();
  1308.                 property.setValidazioneConSchema(configurazionePdDManager.isLivelloValidazioneRigido(implementazionePdDDestinatario));
  1309.                 property.setValidazioneProfiloCollaborazione(configurazionePdDManager.isValidazioneProfiloCollaborazione(implementazionePdDDestinatario));
  1310.                 property.setValidazioneManifestAttachments(configurazionePdDManager.isValidazioneManifestAttachments(implementazionePdDDestinatario));
  1311.                 validatoreProtocolConnectionReply = new Validatore(responseHttpReply,pddContext,property, 
  1312.                         openspcoopstate.getStatoRisposta(),readQualifiedAttribute, protocolFactory);
  1313.                 presenzaRispostaProtocolConnectionReply  = validatoreProtocolConnectionReply.validazioneSintattica();
  1314.                 if(presenzaRispostaProtocolConnectionReply){
  1315.                     // Gestisco i log come fossero una risposta, come se fossi nel modulo InoltroBuste
  1316.                     msgDiag.addKeywords(validatoreProtocolConnectionReply.getBusta(), false);
  1317.                 }
  1318.                 else{
  1319.                     if(validatoreProtocolConnectionReply.getErrore()!=null){
  1320.                         this.log.debug("Messaggio non riconosciuto come busta ("+traduttore.toString(validatoreProtocolConnectionReply.getErrore().getCodiceErrore())
  1321.                                 +"): "+validatoreProtocolConnectionReply.getErrore().getDescrizione(protocolFactory));
  1322.                     }
  1323.                 }
  1324.             }













  1338.             /* ------------------------- Gestione Errori Consegna ---------------------------- */       
  1339.             msgDiag.mediumDebug("Gestione errore consegna della risposta...");
  1340.             if(invokerNonSupportato){
  1341.                 String motivazioneErrore = "Connettore non supportato [tipo:"+tipoConnector+" class:"+connectorClass+"]";
  1342.                 ejbUtils.rollbackMessage(motivazioneErrore, esito);
  1343.                 openspcoopstate.releaseResource();
  1344.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, motivazioneErrore);
  1345.                 esito.setEsitoInvocazione(false); 
  1346.                 return esito;
  1347.             }
  1348.             else if(errorConsegna && presenzaRispostaProtocolConnectionReply==false){
  1349.                 //  Effettuo log dell'eventuale fault
  1350.                 if(soapFaultConnectionReply!=null){
  1351.                     msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, SoapUtils.safe_toString(faultConnectionReplyMessageFactory, soapFaultConnectionReply, this.log));
  1352.                     msgDiag.logPersonalizzato("ricezioneSoapFault");
  1353.                 }
  1354.                 else if(restProblemConnectionReply!=null){
  1355.                     msgDiag.addKeyword(CostantiPdD.KEY_REST_PROBLEM, restProblemConnectionReply.getRaw());
  1356.                     msgDiag.logPersonalizzato("ricezioneRestProblem");
  1357.                 }
  1358.                 String motivazioneErrore = "Errore duranta la spedizione della busta: "+motivoErroreConsegna;
  1359.                 if(riconsegna){
  1360.                     ejbUtils.rollbackMessage(motivazioneErrore,dataRiconsegna, esito);
  1361.                     esito.setEsitoInvocazione(false);
  1362.                 }else{
  1363.                     if(inoltroSegnalazioneErrore)
  1364.                         ejbUtils.releaseOutboxMessage(false);
  1365.                     else
  1366.                         ejbUtils.releaseInboxMessage(false);
  1367.                     esito.setEsitoInvocazione(true);
  1368.                 }
  1369.                 openspcoopstate.releaseResource();
  1370.                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO, motivazioneErrore);
  1371.                 return esito;
  1372.             }




  1377.             /* ---------------- Gestione Risposta  (operazioni comuni per tutti i profili) ------------------- */ 
  1378.             boolean isMessaggioErroreProtocolloConnectionReply = false;
  1379.             Busta bustaConnectionReply = null;

  1381.             if(presenzaRispostaProtocolConnectionReply){
  1382.                 // Gestione Specifica per Buste
  1383.                 bustaConnectionReply = validatoreProtocolConnectionReply.getBusta();
  1384.                 isMessaggioErroreProtocolloConnectionReply = validatoreProtocolConnectionReply.isErroreProtocollo();

  1386.                 // Registrazione Msg
  1387.                 if(isMessaggioErroreProtocolloConnectionReply){
  1388.                     msgDiag.logPersonalizzato("ricezioneMessaggioErrore");
  1389.                 }else{
  1390.                     msgDiag.logPersonalizzato("ricezioneMessaggio");
  1391.                 }

  1393.                 // Estrazione header busta
  1394.                 msgDiag.mediumDebug("Sbustamento della risposta...");
  1395.                 BustaRawContent<?> headerProtocolloRispostaConnectionReply = null;
  1396.                 try{
  1397.                     boolean gestioneManifestRispostaHttp = false;
  1398.                     if(functionAsRouter==false)
  1399.                         gestioneManifestRispostaHttp = configurazionePdDManager.isGestioneManifestAttachments();
  1400.                     org.openspcoop2.protocol.engine.builder.Sbustamento sbustatore = 
  1401.                             new org.openspcoop2.protocol.engine.builder.Sbustamento(protocolFactory,openspcoopstate.getStatoRichiesta());
  1402.                     ProtocolMessage protocolMessage = sbustatore.sbustamento(responseHttpReply,pddContext,
  1403.                             busta,
  1404.                             RuoloMessaggio.RISPOSTA,gestioneManifestRispostaHttp,proprietaManifestAttachments,
  1405.                             FaseSbustamento.POST_CONSEGNA_RISPOSTA_NEW_CONNECTION, requestInfo);
  1406.                     if(protocolMessage!=null) {
  1407.                         headerProtocolloRispostaConnectionReply = protocolMessage.getBustaRawContent();
  1408.                         responseHttpReply = protocolMessage.getMessage(); // updated
  1409.                     }
  1410.                 }catch(Exception e){
  1411.                     EsitoElaborazioneMessaggioTracciato esitoTraccia = EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneConErrore("Sbustamento busta nella connection Reply non riuscita: "+e.getMessage());
  1412.                     tracciamento.registraRisposta(responseHttpReply,null,
  1413.                             validatoreProtocolConnectionReply.getHeaderProtocollo(),bustaConnectionReply,esitoTraccia,
  1414.                             Tracciamento.createLocationString(true, location),
  1415.                             inoltroRisposteMsg.getIdCorrelazioneApplicativa(),inoltroRisposteMsg.getIdCorrelazioneApplicativaRisposta()); // non ancora registrata
  1416.                     msgDiag.logErroreGenerico(e,"sbustatore.sbustamento("+bustaConnectionReply.getID()+")");
  1417.                     ejbUtils.rollbackMessage("Sbustamento busta nella connection Reply non riuscita.", esito);
  1418.                     openspcoopstate.releaseResource();
  1419.                     esito.setStatoInvocazioneErroreNonGestito(e);
  1420.                     esito.setEsitoInvocazione(false); 
  1421.                     return esito;
  1422.                 }

  1424.                 // Tracciamento Risposta
  1425.                 msgDiag.mediumDebug("Tracciamento della risposta...");
  1426.                 EsitoElaborazioneMessaggioTracciato esitoTraccia = EsitoElaborazioneMessaggioTracciato.getEsitoElaborazioneMessaggioRicevuto();
  1427.                 tracciamento.registraRisposta(responseHttpReply,null,
  1428.                         headerProtocolloRispostaConnectionReply,bustaConnectionReply,esitoTraccia,
  1429.                         Tracciamento.createLocationString(true, location),
  1430.                         inoltroRisposteMsg.getIdCorrelazioneApplicativa(),inoltroRisposteMsg.getIdCorrelazioneApplicativaRisposta());

  1432.                 // Salvo il messaggio di risposta e re-inoltro l'errore
  1433.                 if(functionAsRouter){   
  1434.                     msgDiag.mediumDebug("Registrazione messaggio nel Repository Messaggi/Buste...");
  1435.                     msgConnectionReply = new GestoreMessaggi(openspcoopstate, false, bustaConnectionReply.getID(),Costanti.OUTBOX,msgDiag, pddContext);
  1436.                     msgConnectionReply.setOneWayVersione11(oneWayVersione11);
  1437.                     try{
  1438.                         repositoryConnectionReply = new RepositoryBuste(openspcoopstate.getStatoRisposta(), false,protocolFactory);
  1439.                         
  1440.                         if( msgConnectionReply.existsMessage_noCache() ){
  1441.                             // Se il proprietario attuale e' GestoreMessaggi, forzo l'eliminazione e continuo a processare il messaggio.
  1442.                             String proprietarioMessaggio = msgConnectionReply.getProprietario(InoltroRisposte.ID_MODULO);
  1443.                             if(TimerGestoreMessaggi.ID_MODULO.equals(proprietarioMessaggio)){
  1444.                                 msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, bustaConnectionReply.getID());
  1445.                                 msgDiag.logPersonalizzato_prefix("(http reply) ","ricezioneSoapMessage.msgGiaPresente");
  1446.                                 String msg = "(http reply)" + msgDiag.getMessaggio_replaceKeywords("ricezioneSoapMessage.msgGiaPresente");
  1447.                                 if(this.propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  1448.                                     msgConnectionReply._deleteMessageWithLock(msg,this.propertiesReader.getMsgGiaInProcessamentoAttesaAttiva(),
  1449.                                             this.propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  1450.                                 }
  1451.                                 else {
  1452.                                     msgConnectionReply.deleteMessageByNow();
  1453.                                 }
  1454.                             }else{
  1455.                                 throw new Exception("Altra copia della Busta ricevuta come risposta nella http reply con id["+bustaConnectionReply.getID()+"] in elaborazione dal modulo "+proprietarioMessaggio);
  1456.                             }
  1457.                         }

  1459.                         msgConnectionReply.registraMessaggio(responseHttpReply,inoltroRisposteMsg.getIdCorrelazioneApplicativa(),
  1460.                                 inoltroRisposteMsg.getIdCorrelazioneApplicativaRisposta());
  1461.                         msgConnectionReply.aggiornaProprietarioMessaggio(InoltroRisposte.ID_MODULO);
  1462.                         msgConnectionReply.aggiornaRiferimentoMessaggio(busta.getID()); 

  1464.                         repositoryConnectionReply.registraBustaIntoOutBox(busta, this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  1465.                         Integrazione infoIntegrazione = new Integrazione();
  1466.                         repositoryConnectionReply.aggiornaInfoIntegrazioneIntoOutBox(bustaConnectionReply.getID(),infoIntegrazione);

  1468.                     }catch(Exception e){
  1469.                         msgDiag.logErroreGenerico(e,"RegistrazioneRisposta("+bustaConnectionReply.getID()+")");
  1470.                         ejbUtils.rollbackMessage("Salvataggio messaggio nella connection Reply non riuscita.", esito);
  1471.                         openspcoopstate.releaseResource();
  1472.                         esito.setStatoInvocazioneErroreNonGestito(e);
  1473.                         esito.setEsitoInvocazione(false); 
  1474.                         return esito;
  1475.                     }
  1476.                     msgDiag.mediumDebug("Ridirezione messaggio a InoltroRisposte...");
  1477.                     try{
  1478.                         ejbUtils.sendToInoltroRisposte(bustaConnectionReply,true,null,msgConnectionReply,null,null,null,true);
  1479.                     }catch(Exception e){
  1480.                         msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send(InoltroRisposte ID:"+bustaConnectionReply.getID()+")");
  1481.                         ejbUtils.rollbackMessage("Inoltro messaggio ricevuto nella connection Reply non riuscito.", esito);
  1482.                         openspcoopstate.releaseResource();
  1483.                         esito.setStatoInvocazioneErroreNonGestito(e);
  1484.                         esito.setEsitoInvocazione(false); 
  1485.                         return esito;
  1486.                     }

  1488.                 }               
  1489.             }
  1490.             else if(responseHttpReply != null ){
  1491.                 // potenziale Fault (inserito dopo il codice soprastante, per fare decriptare il body al MessageSecurity se presente)
  1492.                 if(soapFaultConnectionReply!=null){
  1493.                     msgDiag.addKeyword(CostantiPdD.KEY_SOAP_FAULT, SoapUtils.safe_toString(faultConnectionReplyMessageFactory, soapFaultConnectionReply, this.log));
  1494.                     msgDiag.logPersonalizzato("ricezioneSoapFault");
  1495.                 }
  1496.                 else if(restProblemConnectionReply!=null){
  1497.                     msgDiag.addKeyword(CostantiPdD.KEY_REST_PROBLEM, restProblemConnectionReply.getRaw());
  1498.                     msgDiag.logPersonalizzato("ricezioneRestProblem");
  1499.                 }
  1500.             }


























  1527.             /* ---------- Gestione Transazione Modulo ---------------- */

  1529.             // Aggiorno proprietario
  1530.             msgDiag.mediumDebug("Aggiorno proprietario messaggio ...");
  1531.             msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);

  1533.             /* -------- Elimino accesso daPdD --------- */
  1534.             msgDiag.mediumDebug("Elimino utilizzo busta dalla PdD ...");
  1535.             repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRisposta(), false, protocolFactory);
  1536.             if(oneWayVersione11)
  1537.                 repositoryBuste.eliminaBustaStatelessFromOutBox(busta.getID());
  1538.             else
  1539.                 repositoryBuste.eliminaUtilizzoPdDFromOutBox(busta.getID());

  1541.             // messaggio finale
  1542.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_CONNETTORE, tipoConnector);
  1543.             msgDiag.logPersonalizzato("gestioneConsegnaTerminata");
  1544.             
  1545.             // Commit JDBC
  1546.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della busta...");
  1547.             openspcoopstate.commit();

  1549.             // Aggiornamento cache Messaggio
  1550.             if(msgResponse!=null)
  1551.                 msgResponse.addMessaggiIntoCache_readFromTable(InoltroRisposte.ID_MODULO, "busta da inoltrare");
  1552.             if(msgConnectionReply!=null)
  1553.                 msgConnectionReply.addMessaggiIntoCache_readFromTable(InoltroRisposte.ID_MODULO, "connection http reply");

  1555.             //  Aggiornamento cache proprietario messaggio
  1556.             if(msgResponse!=null)
  1557.                 msgResponse.addProprietariIntoCache_readFromTable(InoltroRisposte.ID_MODULO, "busta da inoltrare",idMessageRequest,functionAsRouter);
  1558.             if(msgConnectionReply!=null)
  1559.                 msgConnectionReply.addProprietariIntoCache_readFromTable(InoltroRisposte.ID_MODULO, "connection http reply",idMessageResponse,functionAsRouter);

  1561.             // Rilascio connessione al DB
  1562.             msgDiag.mediumDebug("Rilascio connessione al database...");
  1563.             openspcoopstate.releaseResource(); // Rilascio Connessione DB

  1565.             
  1566.             
  1567.             
  1568.             
  1569.             
  1570.             
  1571.             
  1572.             /* --------- PostOutResponse --------------- */
  1573.             // Viene fatta qua poiche' ci interessa segnalare la fine della spedizione
  1574.             PostOutResponseContext postOutResponseContext = new PostOutResponseContext(this.log,protocolFactory);
  1575.             postOutResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  1576.             if(responseMessage!=null){
  1577.                 postOutResponseContext.setInputResponseMessageSize(responseMessage.getIncomingMessageContentLength());
  1578.                 postOutResponseContext.setOutputResponseMessageSize(responseMessage.getOutgoingMessageContentLength());
  1579.             }
  1580.             postOutResponseContext.setProtocollo(outResponseContext.getProtocollo());
  1581.             postOutResponseContext.setEsito(esitoHandler);
  1582.             postOutResponseContext.setPddContext(pddContext);
  1583.             postOutResponseContext.setIntegrazione(outResponseContext.getIntegrazione());
  1584.             postOutResponseContext.setMessaggio(responseMessage);
  1585.             postOutResponseContext.setTipoPorta(outResponseContext.getTipoPorta());
  1586.             // Invoco handler
  1587.             GestoreHandlers.postOutResponse(postOutResponseContext, msgDiag, this.log);
  1588.             
  1589.             
  1590.             
  1591.             

  1593.             msgDiag.mediumDebug("Lavoro Terminato.");
  1594.             esito.setEsitoInvocazione(true);    
  1595.             esito.setStatoInvocazione(EsitoLib.OK, null);
  1596.             return esito; 

  1598.         }catch(Throwable e){
  1599.             this.log.error("ErroreGenerale",e);
  1600.             msgDiag.logErroreGenerico(e, "Generale");

  1602.             ejbUtils.rollbackMessage("ErroreGenerale:"+e.getMessage(), esito);
  1603.             esito.setStatoInvocazioneErroreNonGestito(e);
  1604.             esito.setEsitoInvocazione(false); 
  1605.             
  1606.             openspcoopstate.releaseResource();
  1607.             
  1608.             return esito;
  1609.         }
  1610.         finally{
  1611.             try{
  1612.                 if(connectorSender!=null)
  1613.                     connectorSender.disconnect();
  1614.             }catch(Exception e){
  1615.                 try{
  1616.                     if(msgDiag!=null)
  1617.                         msgDiag.logDisconnectError(e, location);
  1618.                 }catch(Exception eDisconnect){
  1619.                     this.log.error("Errore durante la chiusura delle connessione: "+eDisconnect.getMessage(),e);
  1620.                 }
  1621.             }
  1622.             // *** GB ***
  1623.             if(validatoreProtocolConnectionReply!=null){
  1624.                 if(validatoreProtocolConnectionReply.getValidatoreSintattico()!=null){
  1625.                     validatoreProtocolConnectionReply.getValidatoreSintattico().setHeaderSOAP(null);
  1626.                 }
  1627.                 validatoreProtocolConnectionReply.setValidatoreSintattico(null);
  1628.             }
  1629.             validatoreProtocolConnectionReply = null;
  1630.             // *** GB ***
  1631.         }

  1633.     }



  1637.     /**
  1638.      * Ritorna le Proprieta' Message-Security relative alla spedizione della busta
  1639.      * 
  1640.      * @return Proprieta' Message-Security relative alla spedizione della busta
  1641.      */
  1642.     private FlowProperties  getFlowProperties(Busta bustaRisposta,
  1643.             ConfigurazionePdDManager configurazionePdDManager, IState state,
  1644.             MsgDiagnostico msgDiag, 
  1645.             org.openspcoop2.protocol.sdk.IProtocolFactory<?> protocolFactory,
  1646.             PortaApplicativa paFind,
  1647.             RequestInfo requestInfo)throws DriverConfigurazioneException{

  1649.         //  Proprieta' Message-Security relative alla spedizione della busta

  1651.         // Messaggi AD HOC senza profilo (riscontro) responseFlow della porta applicativa

  1653.         // RispostaOneWay responseFlow della porta applicativa

  1655.         // RispostaSincrona responseFlow della porta applicativa

  1657.         // RicevutaRichiestaAsincronaSimmetrica responseFlow della porta applicativa
  1658.         // RicevutaRispostaAsincronaSimmetrica (integrazione) requestFlow della porta delegata che ha effettuato la richiesta

  1660.         // RicevutaRichiestaAsincronaAsimmetrica responseFlow della porta applicativa
  1661.         // RicevutaRispostaAsincronaAsimmetrica (conversioneServizio) responseFlow della porta applicativa

  1663.         FlowProperties flowProperties = new FlowProperties();
  1664.         flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;
  1665.         ProfiloDiCollaborazione profiloCollaborazione = null;

  1667.         try{

  1669.             // Messaggi AD HOC senza profilo: RISCONTRO
  1670.             if(bustaRisposta.getProfiloDiCollaborazione()==null&& bustaRisposta.sizeListaRiscontri()>0){
  1671.                 if(bustaRisposta.getTipoServizioRichiedenteBustaDiServizio()!=null &&
  1672.                         bustaRisposta.getServizioRichiedenteBustaDiServizio()!=null){
  1673.                     PortaApplicativa pa = paFind;
  1674.                     if(pa==null){
  1675.                         IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRisposta.getTipoServizioRichiedenteBustaDiServizio(),bustaRisposta.getServizioRichiedenteBustaDiServizio(), 
  1676.                                 bustaRisposta.getTipoMittente(),bustaRisposta.getMittente(), 
  1677.                                 bustaRisposta.getVersioneServizioRichiedenteBustaDiServizio());
  1678.                         idServizioPA.setAzione(bustaRisposta.getAzioneRichiedenteBustaDiServizio());
  1679.                         pa = getPortaApplicativa(configurazionePdDManager, 
  1680.                                 idServizioPA);
  1681.                     }
  1682.                     flowProperties.messageSecurity = configurazionePdDManager.getMessageSecurityForSender(pa);
  1683.                     flowProperties.mtom = configurazionePdDManager.getMTOMProcessorForSender(pa);
  1684.                 }
  1685.             }
  1686.             // Messaggi con profilo OneWay e Sincrono
  1687.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRisposta.getProfiloDiCollaborazione()) || 
  1688.                     org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRisposta.getProfiloDiCollaborazione())
  1689.             ) { 
  1690.                 PortaApplicativa pa = paFind;
  1691.                 if(pa==null){
  1692.                     IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRisposta.getTipoServizio(),bustaRisposta.getServizio(), 
  1693.                             bustaRisposta.getTipoMittente(),bustaRisposta.getMittente(), 
  1694.                             bustaRisposta.getVersioneServizio());
  1695.                     idServizioPA.setAzione(bustaRisposta.getAzione());
  1696.                     pa = getPortaApplicativa(configurazionePdDManager, idServizioPA);
  1697.                 }
  1698.                 flowProperties.messageSecurity = configurazionePdDManager.getMessageSecurityForSender(pa);
  1699.                 flowProperties.mtom = configurazionePdDManager.getMTOMProcessorForSender(pa);
  1700.             }

  1702.             // Profilo Asincrono Simmetrico
  1703.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRisposta.getProfiloDiCollaborazione())) {   

  1705.                 profiloCollaborazione = new ProfiloDiCollaborazione(state,protocolFactory);

  1707.                 //  Ricevuta alla richiesta.
  1708.                 if(profiloCollaborazione.asincrono_isRicevutaRichiesta(bustaRisposta.getRiferimentoMessaggio())){

  1710.                     PortaApplicativa pa = paFind;
  1711.                     if(pa==null){
  1712.                         IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRisposta.getTipoServizio(),bustaRisposta.getServizio(), 
  1713.                                 bustaRisposta.getTipoMittente(),bustaRisposta.getMittente(), 
  1714.                                 bustaRisposta.getVersioneServizio());
  1715.                         idServizioPA.setAzione(bustaRisposta.getAzione());
  1716.                         pa = getPortaApplicativa(configurazionePdDManager, idServizioPA);
  1717.                     }
  1718.                     flowProperties.messageSecurity = configurazionePdDManager.getMessageSecurityForSender(pa);
  1719.                     flowProperties.mtom = configurazionePdDManager.getMTOMProcessorForSender(pa);

  1721.                 }

  1723.                 //  Ricevuta alla risposta.
  1724.                 else if(profiloCollaborazione.asincrono_isRicevutaRisposta(bustaRisposta.getRiferimentoMessaggio())){

  1726.                     RepositoryBuste repository = new RepositoryBuste(state, false,protocolFactory);
  1727.                     Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRisposta.getRiferimentoMsgBustaRichiedenteServizio());
  1728.                     IDPortaDelegata idPD = new IDPortaDelegata();
  1729.                     idPD.setNome(integrazione.getNomePorta());
  1730.                     PortaDelegata pd = configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  1731.                     flowProperties.messageSecurity = configurazionePdDManager.getMessageSecurityForSender(pd);
  1732.                     flowProperties.mtom = configurazionePdDManager.getMTOMProcessorForSender(pd);

  1734.                 }

  1736.             }

  1738.             //  Profilo Asincrono Asimmetrico
  1739.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRisposta.getProfiloDiCollaborazione())) {  

  1741.                 profiloCollaborazione = new ProfiloDiCollaborazione(state,protocolFactory);

  1743.                 //  Ricevuta alla richiesta.
  1744.                 if(profiloCollaborazione.asincrono_isRicevutaRichiesta(bustaRisposta.getRiferimentoMessaggio())){

  1746.                     PortaApplicativa pa = paFind;
  1747.                     if(pa==null){
  1748.                         IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRisposta.getTipoServizio(),bustaRisposta.getServizio(), 
  1749.                                 bustaRisposta.getTipoMittente(),bustaRisposta.getMittente(), 
  1750.                                 bustaRisposta.getVersioneServizio());
  1751.                         idServizioPA.setAzione(bustaRisposta.getAzione());
  1752.                         pa = getPortaApplicativa(configurazionePdDManager, idServizioPA);
  1753.                     }
  1754.                     flowProperties.messageSecurity = configurazionePdDManager.getMessageSecurityForSender(pa);
  1755.                     flowProperties.mtom = configurazionePdDManager.getMTOMProcessorForSender(pa);

  1757.                 }

  1759.                 //  Ricevuta alla risposta.
  1760.                 else if(profiloCollaborazione.asincrono_isRicevutaRisposta(bustaRisposta.getRiferimentoMessaggio())){

  1762.                     PortaApplicativa pa = paFind;
  1763.                     if(pa==null){
  1764.                         // ConversioneServizio.
  1765.                         IDServizio idServizioOriginale = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta(bustaRisposta.getRiferimentoMsgBustaRichiedenteServizio());
  1766.                         IDServizio idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(idServizioOriginale.getTipo(),idServizioOriginale.getNome(), 
  1767.                                 bustaRisposta.getTipoMittente(),bustaRisposta.getMittente(), 
  1768.                                 idServizioOriginale.getVersione());
  1769.                         idServizioPA.setAzione(idServizioOriginale.getAzione());
  1770.                         
  1771.                         pa = getPortaApplicativa(configurazionePdDManager, idServizioPA);
  1772.                     }
  1773.                     flowProperties.messageSecurity = configurazionePdDManager.getMessageSecurityForSender(pa);
  1774.                     flowProperties.mtom = configurazionePdDManager.getMTOMProcessorForSender(pa);

  1776.                 }

  1778.             }

  1780.         }catch(Exception e){
  1781.             msgDiag.logErroreGenerico(e,"LetturaDatiMessageSecurity");
  1782.             this.log.error("Lettura dati MessageSecurity per la spedizione del messaggio di risposta non riuscita",e);
  1783.         }finally{
  1784.             if(profiloCollaborazione!=null)
  1785.                 if (state instanceof StatefulMessage )
  1786.                     ((StatefulMessage)state).closePreparedStatement();
  1787.         }
  1788.         
  1789.         return flowProperties;

  1791.     }
  1792.     
  1793.     private PortaApplicativa getPortaApplicativa(ConfigurazionePdDManager configurazionePdDReader, IDServizio idServizio) throws Exception{
  1794.         List<PortaApplicativa> listPa = configurazionePdDReader.getPorteApplicative(idServizio, false);
  1795.         if(listPa.size()<=0){
  1796.             throw new Exception("Non esiste alcuna porta applicativa indirizzabile tramite il servizio ["+idServizio+"]");
  1797.         }
  1798.         else{
  1799.             if(listPa.size()>1)
  1800.                 throw new Exception("Esiste più di una porta applicativa indirizzabile tramite il servizio ["+idServizio+"]");
  1801.             return listPa.get(0);
  1802.         }
  1803.     }
  1804. }
Created with JaCoCo 0.8.8.202204050719