RicezioneBusteUtils.java

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

  22. import java.util.List;

  24. import org.openspcoop2.core.config.PortaApplicativa;
  25. import org.openspcoop2.core.config.PortaDelegata;
  26. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  27. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  28. import org.openspcoop2.core.id.IDPortaDelegata;
  29. import org.openspcoop2.core.id.IDServizio;
  30. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  31. import org.openspcoop2.message.OpenSPCoop2Message;
  32. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  33. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  34. import org.openspcoop2.pdd.core.PdDContext;
  35. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  36. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  37. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  38. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  39. import org.openspcoop2.protocol.sdk.Busta;
  40. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  41. import org.openspcoop2.protocol.sdk.Integrazione;
  42. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  43. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  44. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  45. import org.openspcoop2.protocol.sdk.state.StateMessage;
  46. import org.slf4j.Logger;

  48. /**
  49.  * RicezioneBusteUtils
  50.  * 
  51.  * @author Poli Andrea (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class RicezioneBusteUtils {

  57.     /* Utility per la gestione del Message-Security e MTOM */
  58.     /**
  59.      * Ritorna le Proprieta' Message-Security relative alla ricezione della busta
  60.      * 
  61.      * @return Proprieta' Message-Security relative alla ricezione della busta
  62.      */
  63.     public FlowProperties getFlowPropertiesRequest(OpenSPCoop2Message requestMessage, Busta bustaRichiesta,
  64.             ConfigurazionePdDManager configurazionePdDReader,StateMessage state,
  65.             MsgDiagnostico msgDiag,Logger logCore,OpenSPCoop2Properties properties,
  66.             RuoloBusta ruoloBustaRicevuta,String implementazionePdDMittente,
  67.             RequestInfo requestInfo, PdDContext pddContext,
  68.             PortaApplicativa paFind)throws DriverConfigurazioneException{

  70.         // Proprieta' Message-Security relative alla ricezione della busta

  72.         // Messaggi AD HOC (riscontro) responseFlow della porta delegata, utilizzo l'id del riscontro

  74.         // RichiestaOneWay requestFlow della PortaApplicativa
  75.         // RispostaOneWay (integrazione) responseFlow della porta delegata

  77.         // RichiestaSincrona requestFlow della porta applicativa
  78.         // RispostaSincrona su new Connection NON SUPPORTATA, cmq: (integrazione) responseFlow della porta delegata

  80.         // RichiestaAsincronaSimmetrica requestFlow della PortaApplicativa
  81.         // RicevutaRichiestaAsincronaSimmetrica (integrazione) responseFlow della porta delegata che ha effettuato la richiesta
  82.         // RispostaAsincronaSimmetrica (integrazione) responseFlow della porta delegata che ha effettuato la richiesta
  83.         // RicevutaRispostaAsincronaSimmetrica (integrazione) responseFlow della porta delegata che ha effettuato la risposta

  85.         // RichiestaAsincronaAsimmetrica requestFlow della PortaApplicativa
  86.         // RicevutaRichiestaAsincronaAsimmetrica (integrazione) responseFlow della porta delegata che ha effettuato la richiesta
  87.         // RispostaAsincronaAsimmetrica (conversioneServizio) requestFlow della porta applicativa
  88.         // RicevutaRispostaAsincronaAsimmetrica (integrazione) responseFlow della porta delegata che ha effettuato la risposta

  90.         FlowProperties flowProperties = new FlowProperties();
  91.         flowProperties.tipoMessaggio = RuoloMessaggio.RICHIESTA;
  92.         
  93.         ProfiloDiCollaborazione profiloCollaborazione = null;
  94.         try{
  95.             
  96.             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  97.                         
  98.             // Messaggi AD HOC senza profilo: RISCONTRO
  99.             if(bustaRichiesta.getProfiloDiCollaborazione()==null && bustaRichiesta.sizeListaRiscontri()>0 &&
  100.                     properties.isGestioneRiscontri(implementazionePdDMittente)){
  101.                 RepositoryBuste repository = new RepositoryBuste(state, true,protocolFactory);
  102.                 Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiscontro(0).getID());
  103.                 if(integrazione.getNomePorta()!=null){
  104.                     IDPortaDelegata idPD = new IDPortaDelegata();
  105.                     idPD.setNome(integrazione.getNomePorta());
  106.                     PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  107.                     flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pd);
  108.                     flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pd);
  109.                 }

  111.             }

  113.             // Profilo OneWay e Sincrono
  114.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) || 
  115.                     org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())
  116.             ) { 
  117.                 // Richiesta
  118.                 if(bustaRichiesta.getRiferimentoMessaggio()==null){
  119.                     PortaApplicativa pa = paFind;
  120.                     if(pa==null){
  121.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  122.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  123.                         if(idServizioPA!=null) {
  124.                             idServizioPA.setAzione(bustaRichiesta.getAzione());
  125.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  126.                         }
  127.                     }
  128.                     if(pa!=null) {
  129.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext);
  130.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pa);
  131.                     }
  132.                 }
  133.                 // Risposta
  134.                 else{
  135.                     PortaDelegata pd = null;
  136.                     if(state!=null) {
  137.                         RepositoryBuste repository = new RepositoryBuste(state, false,protocolFactory);
  138.                         Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  139.                         IDPortaDelegata idPD = new IDPortaDelegata();
  140.                         idPD.setNome(integrazione.getNomePorta());
  141.                         pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  142.                     }
  143.                     flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pd);
  144.                     flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pd);
  145.                     flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;
  146.                 }
  147.             }

  149.             // Profilo Asincrono Simmetrico
  150.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  

  152.                 //  Richiesta Asincrona
  153.                 if(bustaRichiesta.getRiferimentoMessaggio()==null){

  155.                     PortaApplicativa pa = paFind;
  156.                     if(pa==null){
  157.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  158.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  159.                         if(idServizioPA!=null) {
  160.                             idServizioPA.setAzione(bustaRichiesta.getAzione());
  161.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  162.                         }
  163.                     }
  164.                     if(pa!=null) {
  165.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext);
  166.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pa);
  167.                     }

  169.                 }else{

  171.                     //  Risposta Asincrona
  172.                     if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  174.                         RepositoryBuste repository = new RepositoryBuste(state, false,protocolFactory);
  175.                         Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  176.                         IDPortaDelegata idPD = new IDPortaDelegata();
  177.                         idPD.setNome(integrazione.getNomePorta());
  178.                         PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  179.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pd, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext);
  180.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pd);

  182.                     }
  183.                     //  Ricevuta alla richiesta.
  184.                     else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())){

  186.                         RepositoryBuste repository = new RepositoryBuste(state, true, protocolFactory);
  187.                         Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  188.                         IDPortaDelegata idPD = new IDPortaDelegata();
  189.                         idPD.setNome(integrazione.getNomePorta());
  190.                         PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  191.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pd);
  192.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pd);
  193.                         flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;

  195.                     }
  196.                     //  Ricevuta alla risposta.
  197.                     else if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  199.                         RepositoryBuste repository = new RepositoryBuste(state, false, protocolFactory);
  200.                         Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  201.                         IDPortaDelegata idPD = new IDPortaDelegata();
  202.                         idPD.setNome(integrazione.getNomePorta());
  203.                         PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  204.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pd);
  205.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pd);
  206.                         flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;

  208.                     }

  210.                 }

  212.             }

  214.             // Profilo Asincrono Asimmetrico
  215.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) { 

  217.                 //  Richiesta Asincrona
  218.                 if(bustaRichiesta.getRiferimentoMessaggio()==null){

  220.                     PortaApplicativa pa = paFind;
  221.                     if(pa==null){
  222.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  223.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  224.                         if(idServizioPA!=null) {
  225.                             idServizioPA.setAzione(bustaRichiesta.getAzione());
  226.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  227.                         }
  228.                     }
  229.                     if(pa!=null) {
  230.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext);
  231.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pa);
  232.                     }

  234.                 }else{

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

  238.                     //  Risposta Asincrona
  239.                     if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  241.                         // ConversioneServizio.
  242.                         IDServizio idServizioOriginale = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta(bustaRichiesta.getRiferimentoMessaggio());
  243.                         PortaApplicativa pa = paFind;
  244.                         if(pa==null){
  245.                             IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  246.                             // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  247.                             if(idServizioPA!=null) {
  248.                                 idServizioPA.setAzione(idServizioOriginale.getAzione());
  249.                                 pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader,idServizioPA);
  250.                             }
  251.                         }
  252.                         if(pa!=null) {
  253.                             flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext);
  254.                             flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pa);
  255.                         }

  257.                     }
  258.                     //  Ricevuta alla richiesta.
  259.                     else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())){

  261.                         RepositoryBuste repository = new RepositoryBuste(state, true,protocolFactory);
  262.                         Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  263.                         IDPortaDelegata idPD = new IDPortaDelegata();
  264.                         idPD.setNome(integrazione.getNomePorta());
  265.                         PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  266.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pd);
  267.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pd);
  268.                         flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;

  270.                     }
  271.                     //  Ricevuta alla risposta.
  272.                     else if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  274.                         RepositoryBuste repository = new RepositoryBuste(state, false,protocolFactory);
  275.                         Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  276.                         IDPortaDelegata idPD = new IDPortaDelegata();
  277.                         idPD.setNome(integrazione.getNomePorta());
  278.                         PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  279.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForReceiver(pd);
  280.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForReceiver(pd);
  281.                         flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;

  283.                     }

  285.                 }

  287.             }

  289.         }catch(Exception e){
  290.             msgDiag.logErroreGenerico(e, "lettura_MessageSecurity_MTOM_RequestProperties");
  291.             logCore.error("Lettura dati Message-Security / MTOM per la ricezione del messaggio non riuscita",e);
  292.         }finally{
  293.             if(profiloCollaborazione!=null)
  294.                 state.closePreparedStatement();
  295.         }

  297.         return flowProperties;
  298.     }


  301.     /**
  302.      * Ritorna le Proprieta' Message-Security relative alla spedizione della busta
  303.      * 
  304.      * @return Proprieta' Message-Security relative alla spedizione della busta
  305.      */
  306.     public FlowProperties getFlowPropertiesResponse(OpenSPCoop2Message requestMessage, Busta bustaRichiesta,
  307.             ConfigurazionePdDManager configurazionePdDReader,StateMessage state,
  308.             MsgDiagnostico msgDiag,Logger logCore,OpenSPCoop2Properties properties,
  309.             RuoloBusta ruoloBustaRicevuta,String implementazionePdDMittente,
  310.             RequestInfo requestInfo, PdDContext pddContext,
  311.             PortaApplicativa paFind,
  312.             FlowProperties flowPropertiesRequest)throws DriverConfigurazioneException{

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

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

  318.         // RispostaOneWay responseFlow della porta applicativa

  320.         // RispostaSincrona responseFlow della porta applicativa

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

  325.         // RicevutaRichiestaAsincronaAsimmetrica responseFlow della porta applicativa
  326.         // RicevutaRispostaAsincronaAsimmetrica (conversioneServizio) responseFlow della porta applicativa

  328.         FlowProperties flowProperties = new FlowProperties();
  329.         flowProperties.tipoMessaggio = RuoloMessaggio.RISPOSTA;

  331.         // NOTA: La busta che sto gestendo e' la busta che ho ricevuto, non quella che sto inviando!!

  333.         ProfiloDiCollaborazione profiloCollaborazione = null;
  334.         try{

  336.             IProtocolFactory<?> protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  337.                         
  338.             // Messaggi AD HOC senza profilo: RISCONTRO
  339.             if(bustaRichiesta.getProfiloDiCollaborazione()==null && bustaRichiesta.sizeListaRiscontri()>0 &&
  340.                     properties.isGestioneRiscontri(implementazionePdDMittente)){
  341.                 if(bustaRichiesta.getTipoServizio()!=null &&
  342.                         bustaRichiesta.getServizio()!=null){
  343.                     PortaApplicativa pa = paFind;
  344.                     if(pa==null){
  345.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  346.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  347.                         if(idServizioPA!=null) {
  348.                             idServizioPA.setAzione(bustaRichiesta.getAzione());
  349.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  350.                         }
  351.                     }
  352.                     if(pa!=null) {
  353.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext,
  354.                                 null);
  355.                         flowProperties.messageSecurityRequest = flowPropertiesRequest!=null ? flowPropertiesRequest.messageSecurity : null;
  356.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pa);
  357.                     }
  358.                 }
  359.             }
  360.             // Messaggi con profilo
  361.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) || 
  362.                     org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())
  363.             ) { 
  364.                 PortaApplicativa pa = paFind;
  365.                 if(pa==null){
  366.                     IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  367.                     // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  368.                     if(idServizioPA!=null) {
  369.                         idServizioPA.setAzione(bustaRichiesta.getAzione());
  370.                         pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  371.                     }
  372.                 }
  373.                 if(pa!=null) {
  374.                     flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext,
  375.                             null);
  376.                     flowProperties.messageSecurityRequest = flowPropertiesRequest!=null ? flowPropertiesRequest.messageSecurity : null;
  377.                     flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pa);
  378.                 }
  379.             }

  381.             //   Profilo Asincrono Simmetrico
  382.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {  

  384.                 //  Ricevuta alla richiesta.
  385.                 if(bustaRichiesta.getRiferimentoMessaggio()==null){

  387.                     PortaApplicativa pa = paFind;
  388.                     if(pa==null){
  389.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  390.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  391.                         if(idServizioPA!=null) {
  392.                             idServizioPA.setAzione(bustaRichiesta.getAzione());
  393.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  394.                         }
  395.                     }
  396.                     if(pa!=null) {
  397.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext,
  398.                                 null);
  399.                         flowProperties.messageSecurityRequest = flowPropertiesRequest!=null ? flowPropertiesRequest.messageSecurity : null;
  400.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pa);
  401.                     }

  403.                 }

  405.                 //  Ricevuta alla risposta.
  406.                 else if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  408.                     RepositoryBuste repository = new RepositoryBuste(state, false, protocolFactory);
  409.                     Integrazione integrazione = repository.getInfoIntegrazioneFromOutBox(bustaRichiesta.getRiferimentoMessaggio());
  410.                     IDPortaDelegata idPD = new IDPortaDelegata();
  411.                     idPD.setNome(integrazione.getNomePorta());
  412.                     PortaDelegata pd = configurazionePdDReader.getPortaDelegataSafeMethod(idPD, requestInfo);
  413.                     flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pd, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext);
  414.                     flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pd);

  416.                 }

  418.             }

  420.             //  Profilo Asincrono Asimmetrico
  421.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) { 

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

  425.                 //  Ricevuta alla richiesta.
  426.                 if(bustaRichiesta.getRiferimentoMessaggio()==null){

  428.                     PortaApplicativa pa = paFind;
  429.                     if(pa==null){
  430.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  431.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  432.                         if(idServizioPA!=null) {
  433.                             idServizioPA.setAzione(bustaRichiesta.getAzione());
  434.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  435.                         }
  436.                     }
  437.                     if(pa!=null) {
  438.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext,
  439.                                 null);
  440.                         flowProperties.messageSecurityRequest = flowPropertiesRequest!=null ? flowPropertiesRequest.messageSecurity : null;
  441.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pa);
  442.                     }

  444.                 }

  446.                 //  Ricevuta alla risposta.
  447.                 else if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  449.                     // ConversioneServizio.
  450.                     IDServizio idServizioOriginale = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta(bustaRichiesta.getRiferimentoMessaggio());
  451.                     PortaApplicativa pa = paFind;
  452.                     if(pa==null){
  453.                         IDServizio idServizioPA = buildIdServizio(bustaRichiesta);
  454.                         // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  455.                         if(idServizioPA!=null) {
  456.                             idServizioPA.setAzione(idServizioOriginale.getAzione());
  457.                             pa = this.getPortaApplicativaIgnoreNotFound(configurazionePdDReader, idServizioPA);
  458.                         }
  459.                     }
  460.                     if(pa!=null) {
  461.                         flowProperties.messageSecurity = configurazionePdDReader.getMessageSecurityForSender(pa, logCore, requestMessage, bustaRichiesta, requestInfo, pddContext,
  462.                                 null);
  463.                         flowProperties.messageSecurityRequest = flowPropertiesRequest!=null ? flowPropertiesRequest.messageSecurity : null;
  464.                         flowProperties.mtom = configurazionePdDReader.getMTOMProcessorForSender(pa);
  465.                     }

  467.                 }

  469.             }



  473.         }catch(Exception e){
  474.             msgDiag.logErroreGenerico(e, "lettura_MessageSecurity_MTOM_ResponseProperties");
  475.             logCore.error("Lettura dati Message-Security / MTOM per la spedizione del messaggio di risposta non riuscita",e);
  476.         }finally{
  477.             if(profiloCollaborazione!=null)
  478.                 state.closePreparedStatement();
  479.         }

  481.         return flowProperties;
  482.     }

  484.     public PortaApplicativa getPortaApplicativa(ConfigurazionePdDManager configurazionePdDReader, IDServizio idServizio) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  485.         List<PortaApplicativa> listPa = configurazionePdDReader.getPorteApplicative(idServizio, false);
  486.         if(listPa.isEmpty()){
  487.             throw new DriverConfigurazioneException("Non esiste alcuna porta applicativa indirizzabile tramite il servizio ["+idServizio+"]");
  488.         }
  489.         else{
  490.             if(listPa.size()>1)
  491.                 throw new DriverConfigurazioneException("Esiste più di una porta applicativa indirizzabile tramite il servizio ["+idServizio+"]");
  492.             return listPa.get(0);
  493.         }
  494.     }
  495.     public PortaApplicativa getPortaApplicativaIgnoreNotFound(ConfigurazionePdDManager configurazionePdDReader, IDServizio idServizio) throws Exception{
  496.         try {
  497.             return this.getPortaApplicativa(configurazionePdDReader, idServizio);
  498.         }catch(DriverConfigurazioneNotFound notFound) {
  499.             // ignore
  500.         }
  501.         return null;
  502.     }
  503.     
  504.     private IDServizio buildIdServizio(Busta bustaRichiesta) {
  505.         IDServizio idServizioPA = null;
  506.         try {
  507.             idServizioPA = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRichiesta.getTipoServizio(),bustaRichiesta.getServizio(), 
  508.                     bustaRichiesta.getTipoDestinatario(),bustaRichiesta.getDestinatario(), 
  509.                     bustaRichiesta.getVersioneServizio());
  510.         }catch(Exception e) {
  511.             // se non sono presenti dati identificativi del servizio non potro poi localizzare la PA
  512.         }
  513.         return idServizioPA;
  514.     }
  515. }
Created with JaCoCo 0.8.8.202204050719