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


  22. package org.openspcoop2.pdd.mdb;

  24. import org.openspcoop2.core.config.PortaDelegata;
  25. import org.openspcoop2.core.config.ServizioApplicativo;
  26. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  27. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  28. import org.openspcoop2.core.constants.TipoPdD;
  29. import org.openspcoop2.core.eccezione.details.DettaglioEccezione;
  30. import org.openspcoop2.core.eccezione.details.utils.XMLUtils;
  31. import org.openspcoop2.core.id.IDServizioApplicativo;
  32. import org.openspcoop2.core.id.IDSoggetto;
  33. import org.openspcoop2.message.OpenSPCoop2Message;
  34. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  35. import org.openspcoop2.message.constants.MessageRole;
  36. import org.openspcoop2.message.exception.ParseException;
  37. import org.openspcoop2.message.utils.MessageUtilities;
  38. import org.openspcoop2.pdd.config.ClassNameProperties;
  39. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  40. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  41. import org.openspcoop2.pdd.config.RichiestaDelegata;
  42. import org.openspcoop2.pdd.core.CostantiPdD;
  43. import org.openspcoop2.pdd.core.EJBUtils;
  44. import org.openspcoop2.pdd.core.GestoreMessaggi;
  45. import org.openspcoop2.pdd.core.PdDContext;
  46. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  47. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  48. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  49. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  50. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  51. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  52. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  53. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  54. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  55. import org.openspcoop2.protocol.engine.constants.Costanti;
  56. import org.openspcoop2.protocol.engine.driver.FiltroDuplicati;
  57. import org.openspcoop2.protocol.engine.driver.History;
  58. import org.openspcoop2.protocol.engine.driver.IFiltroDuplicati;
  59. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  60. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  61. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  62. import org.openspcoop2.protocol.sdk.Busta;
  63. import org.openspcoop2.protocol.sdk.Eccezione;
  64. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  65. import org.openspcoop2.protocol.sdk.Riscontro;
  66. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  67. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  68. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  69. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  70. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  71. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  72. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  73. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  74. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  75. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  76. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  77. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  78. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  79. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  80. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  81. import org.slf4j.Logger;

  83. /**
  84.  * Contiene la libreria Sbustamento
  85.  *
  86.  * @author Poli Andrea (apoli@link.it)
  87.  * @author Tronci Fabio (tronci@link.it)
  88.  * @author $Author$
  89.  * @version $Rev$, $Date$
  90.  */
  91. public class SbustamentoRisposte extends GenericLib {

  93.     public static final String ID_MODULO = "SbustamentoRisposte";

  95.     /** XMLBuilder */
  96.     private RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore;


  99.     public SbustamentoRisposte(Logger log) throws GenericLibException {
  100.         super(SbustamentoRisposte.ID_MODULO, log);
  101.         inizializza();
  102.     }

  104.     @Override
  105.     protected synchronized void inizializza() throws GenericLibException {
  106.         super.inizializza();
  107.     }

  109.     @Override
  110.     public EsitoLib _onMessage(IOpenSPCoopState openspcoopstate,
  111.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  112.             MsgDiagnostico msgDiag) throws OpenSPCoopStateException {
  113.         EsitoLib esito = new EsitoLib();

  115.         SbustamentoRisposteMessage sbustamentoRisposteMsg = (SbustamentoRisposteMessage) openspcoopstate.getMessageLib();
  116.         
  117.         /* Regupero eventuali errori di parsing. */
  118.         ParseException parseException = null;
  119.         if(openspcoopstate instanceof OpenSPCoopStateless) {
  120.             OpenSPCoop2Message msgRisposta = ((OpenSPCoopStateless) openspcoopstate).getRispostaMsg();
  121.             if(msgRisposta!=null){
  122.                 parseException = msgRisposta.getParseException();
  123.             }
  124.         }
  125.         
  126.         /* PddContext */
  127.         PdDContext pddContext = sbustamentoRisposteMsg.getPddContext();
  128.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  129.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  130.         
  131.         /* Protocol Factory */
  132.         IProtocolFactory<?> protocolFactory = null;
  133.         IProtocolVersionManager protocolManager = null;
  134.         ITraduttore traduttore = null;
  135.         try{
  136.             protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  137.             protocolManager = protocolFactory.createProtocolVersionManager(sbustamentoRisposteMsg.getRichiestaDelegata().getProfiloGestione());
  138.             traduttore = protocolFactory.createTraduttore();
  139.         }catch(Exception e){
  140.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  141.             openspcoopstate.releaseResource();
  142.             esito.setEsitoInvocazione(false); 
  143.             esito.setStatoInvocazioneErroreNonGestito(e);
  144.             return esito;
  145.         }
  146.         
  147.         msgDiag.setPddContext(pddContext, protocolFactory);
  148.         
  149.         /* Busta e ID e tipo di implementazione PdD con cui interoperare */
  150.         Busta bustaRisposta = sbustamentoRisposteMsg.getBusta();
  151.         String idResponse = bustaRisposta.getID();
  152.         String implementazionePdDDestinatario = sbustamentoRisposteMsg.getImplementazionePdDSoggettoDestinatario();
  153.         
  154.         /* Processamento informazioni */
  155.         RichiestaDelegata richiestaDelegata = sbustamentoRisposteMsg.getRichiestaDelegata();
  156.         if(richiestaDelegata==null) {
  157.             msgDiag.logErroreGenerico("RichiestaDelegata is null", "RichiestaDelegata.checkNull"); 
  158.             openspcoopstate.releaseResource();
  159.             esito.setEsitoInvocazione(false); 
  160.             return esito;
  161.         }
  162.         
  163.         TipoPdD tipoPdD = TipoPdD.DELEGATA;
  164.         if(msgDiag.getPorta()==null) {
  165.             if(richiestaDelegata!=null && richiestaDelegata.getIdPortaDelegata()!=null) {
  166.                 msgDiag.updatePorta(tipoPdD, richiestaDelegata.getIdPortaDelegata().getNome(), requestInfo);
  167.             }
  168.         }
  169.         
  170.         richiestaDelegata.setProfiloCollaborazione(bustaRisposta.getProfiloDiCollaborazione(),bustaRisposta.getProfiloDiCollaborazioneValue()); // update value
  171.         java.util.List<Eccezione> errors = sbustamentoRisposteMsg.getErrors();
  172.         IntegrationFunctionError validazione_integrationFunctionError = sbustamentoRisposteMsg.getIntegrationFunctionErrorValidazione();
  173.         boolean isMessaggioErroreProtocollo = sbustamentoRisposteMsg.isMessaggioErroreProtocollo();
  174.         boolean bustaDiServizio = sbustamentoRisposteMsg.getIsBustaDiServizio();
  175.         IDSoggetto identitaPdD = sbustamentoRisposteMsg.getRichiestaDelegata().getDominio();
  176.         
  177.         msgDiag.setDominio(identitaPdD);  // imposto anche il dominio nel msgDiag
  178.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO_RISPOSTE);
  179.         msgDiag.addKeywords(richiestaDelegata.getIdSoggettoFruitore(),richiestaDelegata.getIdServizio(),null);
  180.         msgDiag.addKeywords(bustaRisposta, false);
  181.         msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, richiestaDelegata.getServizioApplicativo());
  182.         msgDiag.setIdCorrelazioneApplicativa(richiestaDelegata.getIdCorrelazioneApplicativa());
  183.         msgDiag.setIdCorrelazioneRisposta(richiestaDelegata.getIdCorrelazioneApplicativaRisposta());
  184.         msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, richiestaDelegata.getIdCorrelazioneApplicativa());
  185.         
  186.         String profiloGestione = richiestaDelegata.getProfiloGestione();
  187.         msgDiag.mediumDebug("Profilo di gestione ["+SbustamentoRisposte.ID_MODULO+"] della busta: "+profiloGestione);
  188.         
  189.         //  ProprietaErroreApplicativo
  190.         ProprietaErroreApplicativo proprietaErroreAppl = richiestaDelegata.getFault();
  191.         if(proprietaErroreAppl==null) {
  192.             msgDiag.logErroreGenerico("ProprietaErroreApplicativo is null", "ProprietaErroreApplicativo.checkNull"); 
  193.             openspcoopstate.releaseResource();
  194.             esito.setEsitoInvocazione(false); 
  195.             return esito;
  196.         }
  197.         proprietaErroreAppl.setIdModulo(SbustamentoRisposte.ID_MODULO);
  198.         
  199.         try{
  200.             this.generatoreErrore = new RicezioneContenutiApplicativiInternalErrorGenerator(this.log, this.idModulo, requestInfo);
  201.             this.generatoreErrore.updateInformazioniCooperazione(richiestaDelegata.getIdSoggettoFruitore(), richiestaDelegata.getIdServizio());
  202.             this.generatoreErrore.updateInformazioniCooperazione(richiestaDelegata.getServizioApplicativo());
  203.             if(proprietaErroreAppl!=null){
  204.                 this.generatoreErrore.updateProprietaErroreApplicativo(proprietaErroreAppl);
  205.             }
  206.         }catch(Exception e){
  207.             msgDiag.logErroreGenerico(e, "RicezioneContenutiApplicativiGeneratoreErrore.instanziazione"); 
  208.             openspcoopstate.releaseResource();
  209.             esito.setEsitoInvocazione(false); 
  210.             esito.setStatoInvocazioneErroreNonGestito(e);
  211.             return esito;
  212.         }
  213.         

  215.         /* ------------------ Inizializzo stato OpenSPCoop  --------------- */
  216.         msgDiag.mediumDebug("Inizializzo stato per la gestione della richiesta...");
  217.         openspcoopstate.initResource(identitaPdD, SbustamentoRisposte.ID_MODULO,idTransazione);
  218.         registroServiziManager = registroServiziManager.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  219.         configurazionePdDManager = configurazionePdDManager.refreshState(registroServiziManager);
  220.         msgDiag.updateState(configurazionePdDManager);

  222.         /* ----------------- ID RICHIESTA ---------------------------------------------- */
  223.         String idMessageRequest = openspcoopstate.getIDMessaggioSessione();
  224.         
  225.         String jtiIdModIRequest = null;
  226.         if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID)) {
  227.             jtiIdModIRequest = (String) pddContext.get(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID);
  228.         }

  230.         // Aggiornamento Informazioni messaggio diagnostico
  231.         msgDiag.setIdMessaggioRichiesta(idMessageRequest);
  232.         msgDiag.setIdMessaggioRisposta(idResponse);
  233.         msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessageRequest);
  234.         msgDiag.setFruitore(richiestaDelegata.getIdSoggettoFruitore());
  235.         msgDiag.setServizio(richiestaDelegata.getIdServizio());
  236.         msgDiag.setServizioApplicativo(richiestaDelegata.getServizioApplicativo());
  237.         msgDiag.setIdCorrelazioneApplicativa(richiestaDelegata.getIdCorrelazioneApplicativa());
  238.         msgDiag.setIdCorrelazioneRisposta(richiestaDelegata.getIdCorrelazioneApplicativaRisposta());


  241.         /* ------------------ Inizializzazione Contesto di gestione  --------------- */
  242.         msgDiag.mediumDebug("Inizializzo contesto per la gestione...");

  244.         //  Gestore della risposta
  245.         GestoreMessaggi msgResponse = null;

  247.         // Gestore funzionalita
  248.         ProfiloDiCollaborazione profiloCollaborazione = null;
  249.         try{
  250.             profiloCollaborazione = new ProfiloDiCollaborazione(openspcoopstate.getStatoRisposta(),protocolFactory);
  251.         }catch(Exception e){
  252.             msgDiag.logErroreGenerico(e, "ProfiloDiCollaborazione.new");
  253.             openspcoopstate.releaseResource();
  254.             esito.setEsitoInvocazione(false); 
  255.             esito.setStatoInvocazioneErroreNonGestito(e);
  256.             return esito;
  257.         }
  258.         History historyBuste = new History(openspcoopstate.getStatoRisposta());
  259.         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRisposta(), false, protocolFactory);
  260.         String ricevutaAsincrona = null;

  262.         // EJBUtils (per eventuali errori)
  263.         EJBUtils ejbUtils = null;
  264.         try{
  265.             ejbUtils = new EJBUtils(identitaPdD,tipoPdD,SbustamentoRisposte.ID_MODULO,idMessageRequest,
  266.                     idResponse,Costanti.INBOX, openspcoopstate, msgDiag,false,
  267.                     sbustamentoRisposteMsg.getImplementazionePdDSoggettoMittente(),
  268.                     sbustamentoRisposteMsg.getImplementazionePdDSoggettoDestinatario(),
  269.                     profiloGestione,pddContext);
  270.             ejbUtils.setSpedizioneMsgIngresso(sbustamentoRisposteMsg.getSpedizioneMsgIngresso());
  271.             ejbUtils.setRicezioneMsgRisposta(sbustamentoRisposteMsg.getRicezioneMsgRisposta());
  272.             ejbUtils.setScenarioCooperazione(richiestaDelegata.getScenario());
  273.         }catch(Exception e){
  274.             msgDiag.logErroreGenerico(e, "EJBUtils.new");
  275.             openspcoopstate.releaseResource();
  276.             esito.setEsitoInvocazione(false); 
  277.             esito.setStatoInvocazioneErroreNonGestito(e);
  278.             return esito;
  279.         }
  280.         
  281.         try{
  282.             // Per inviare segnalazioni di buste malformate
  283.             RicezioneBusteExternalErrorGenerator generatoreErrorePA = new RicezioneBusteExternalErrorGenerator(this.log, this.idModulo, requestInfo, openspcoopstate.getStatoRichiesta());
  284.             generatoreErrorePA.updateInformazioniCooperazione(richiestaDelegata.getIdSoggettoFruitore(), richiestaDelegata.getIdServizio());
  285.             generatoreErrorePA.updateInformazioniCooperazione(richiestaDelegata.getServizioApplicativo());
  286.             generatoreErrorePA.updateTipoPdD(TipoPdD.DELEGATA);
  287.             ejbUtils.setGeneratoreErrorePortaApplicativa(generatoreErrorePA);
  288.         }catch(Exception e){
  289.             msgDiag.logErroreGenerico(e, "RicezioneBusteExternalErrorGenerator.instanziazione"); 
  290.             openspcoopstate.releaseResource();
  291.             esito.setEsitoInvocazione(false); 
  292.             esito.setStatoInvocazioneErroreNonGestito(e);
  293.             return esito;
  294.         }
  295.         
  296.         // Oneway versione 11
  297.         boolean oneWayVersione11 = sbustamentoRisposteMsg.isOneWayVersione11();
  298.         ejbUtils.setOneWayVersione11(oneWayVersione11);

  300.         
  301.         /* ----------- Lettura PortaDelegata e Servizio Applicativo ------------- */
  302.         PortaDelegata pd = null;
  303.         ServizioApplicativo sa = null;
  304.         try{
  305.             pd = configurazionePdDManager.getPortaDelegata(richiestaDelegata.getIdPortaDelegata(), requestInfo);
  306.         }catch(Exception e){
  307.             msgDiag.logErroreGenerico(e,"getPortaDelegata()");
  308.             openspcoopstate.releaseResource();
  309.             esito.setEsitoInvocazione(false);   
  310.             esito.setStatoInvocazioneErroreNonGestito(e);
  311.             return esito;
  312.         }
  313.         try{
  314.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  315.             idSA.setNome(richiestaDelegata.getServizioApplicativo());
  316.             idSA.setIdSoggettoProprietario(richiestaDelegata.getIdSoggettoFruitore());
  317.             sa = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo);
  318.         }catch(Exception e){
  319.             if( !(e instanceof DriverConfigurazioneNotFound) || 
  320.                     !(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(richiestaDelegata.getServizioApplicativo())) ){
  321.                 msgDiag.logErroreGenerico(e,"getServizioApplicativo()");
  322.                 openspcoopstate.releaseResource();
  323.                 esito.setEsitoInvocazione(false);   
  324.                 esito.setStatoInvocazioneErroreNonGestito(e);
  325.                 return esito;
  326.             }
  327.         }

  329.         
  330.         
  331.         //  Modalita' gestione risposta Applicativa (No function Router active)
  332.         // -a se il profilo e' sincrono
  333.         // -b se il profilo e' asincrono e ricevutaAsincrona e' abilitata.
  334.         // -c se il profilo e' asincrono asimmetrico di richiesta stato e ricevuta disabilitata
  335.         // -d se il profilo e' oneway e la modalita di trasmissione e' sincrona.
  336.         boolean sendRispostaApplicativa = false;
  337.         boolean statelessAsincrono = false;
  338.         // a)
  339.         if(Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ){
  340.             sendRispostaApplicativa = true;
  341.         }
  342.         // c) [e b) per la richiestaStato AsincronaAsimmetrica]
  343.         else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(richiestaDelegata.getScenario())){
  344.             try{
  345.                 statelessAsincrono = configurazionePdDManager.isModalitaStateless(pd, bustaRisposta.getProfiloDiCollaborazione());
  346.             }catch(Exception e){
  347.                 msgDiag.logErroreGenerico(e,"AsincronoAsimmetricoPolling.isModalitaStateless(pd)");
  348.                 openspcoopstate.releaseResource();
  349.                 esito.setEsitoInvocazione(false);   
  350.                 esito.setStatoInvocazioneErroreNonGestito(e);
  351.                 return esito;
  352.             }
  353.             sendRispostaApplicativa = true;
  354.         }
  355.         // b)
  356.         else if (Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ||
  357.                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ||
  358.                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(richiestaDelegata.getScenario()) ){
  359.             try{
  360.                 statelessAsincrono = configurazionePdDManager.isModalitaStateless(pd, bustaRisposta.getProfiloDiCollaborazione());
  361.                 sendRispostaApplicativa =  statelessAsincrono || richiestaDelegata.isRicevutaAsincrona();
  362.             }catch(Exception e){
  363.                 msgDiag.logErroreGenerico(e,"Asincrono.isModalitaStateless(pd)");
  364.                 openspcoopstate.releaseResource();
  365.                 esito.setEsitoInvocazione(false);   
  366.                 esito.setStatoInvocazioneErroreNonGestito(e);
  367.                 return esito;
  368.             }
  369.         }
  370.         // d)
  371.         else if(Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario())){
  372.             try{
  373.                 sendRispostaApplicativa = (configurazionePdDManager.isModalitaStateless(pd, org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY));
  374.             }catch(Exception e){
  375.                 msgDiag.logErroreGenerico(e,"OnewayInvocazioneServizio.isModalitaStateless(pd)");
  376.                 openspcoopstate.releaseResource();
  377.                 esito.setEsitoInvocazione(false);   
  378.                 esito.setStatoInvocazioneErroreNonGestito(e);
  379.                 return esito;
  380.             }
  381.         }

  383.         //  rollback RiferimentoMessaggio
  384.         boolean rollbackRiferimentoMessaggio = false;
  385.         if(sendRispostaApplicativa){
  386.             if(Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ){
  387.                 rollbackRiferimentoMessaggio = true;
  388.             }
  389.             // Profilo Asincrono con gestione ricevuta applicativa (siamo in sendRispostaApplicativa)
  390.             else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ||
  391.                     Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ){
  392.                 rollbackRiferimentoMessaggio = true;
  393.             }
  394.         }

  396.         // Ruolo Busta ricevuta
  397.         RuoloBusta ruoloBustaRicevuta = sbustamentoRisposteMsg.getRuoloBustaRicevuta();









  407.         // Punto di inizio per la transazione.
  408.         try{

  410.             boolean ricezioneRiscontri = false;
  411.             switch (protocolManager.getConsegnaAffidabile(bustaRisposta)) {
  412.             case ABILITATA:
  413.                 ricezioneRiscontri = true;
  414.                 break;
  415.             case DISABILITATA:
  416.                 ricezioneRiscontri = false;
  417.                 break;
  418.             default:
  419.                 ricezioneRiscontri = this.propertiesReader.isGestioneRiscontri(implementazionePdDDestinatario);
  420.                 break;
  421.             }
  422.             
  423.             boolean imbustamentoFiltroDuplicatiAbilitato = false;
  424.             switch (protocolManager.getFiltroDuplicati(bustaRisposta)) {
  425.             case ABILITATA:
  426.                 imbustamentoFiltroDuplicatiAbilitato = true;
  427.                 break;
  428.             case DISABILITATA:
  429.                 imbustamentoFiltroDuplicatiAbilitato = false;
  430.                 break;
  431.             default:
  432.                 imbustamentoFiltroDuplicatiAbilitato = (Inoltro.SENZA_DUPLICATI.equals(bustaRisposta.getInoltro())) ||
  433.                 (this.propertiesReader.isCheckFromRegistroFiltroDuplicatiAbilitato(implementazionePdDDestinatario) && sbustamentoRisposteMsg.isFiltroDuplicati());
  434.                 break;
  435.             }
  436.             
  437.             // ------------- Controllo funzionalita di protocollo richieste siano compatibili con il protocollo -----------------------------
  438.             try{
  439.                 // NOTA: Usare getIntegrationServiceBinding poichè le funzionalità si riferiscono al tipo di integrazione scelta
  440.                 
  441.                 IProtocolConfiguration protocolConfiguration = protocolFactory.createProtocolConfiguration();
  442.                 if(imbustamentoFiltroDuplicatiAbilitato){
  443.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.FILTRO_DUPLICATI)==false){
  444.                         throw new Exception(FunzionalitaProtocollo.FILTRO_DUPLICATI.getEngineValue());
  445.                     }
  446.                 }               
  447.             }catch(Exception e){    
  448.                 msgDiag.addKeywordErroreProcessamento(e);
  449.                 msgDiag.logPersonalizzato("protocolli.funzionalita.unsupported");
  450.                 if(sendRispostaApplicativa){
  451.                     OpenSPCoop2Message responseMessageError =
  452.                             this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  453.                                     ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.
  454.                                         getErrore439_FunzionalitaNotSupportedByProtocol(e.getMessage(), protocolFactory),e,
  455.                                             parseException);
  456.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  457.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  458.                             msgDiag.getMessaggio_replaceKeywords("protocolli.funzionalita.unsupported"));
  459.                 }else{
  460.                     ejbUtils.releaseInboxMessage(false); 
  461.                     esito.setStatoInvocazioneErroreNonGestito(e);
  462.                 }
  463.                 openspcoopstate.releaseResource();
  464.                 esito.setEsitoInvocazione(true);
  465.                 return esito;
  466.             }
  467.             
  468.             
  469.             
  470.             
  471.             
  472.             
  473.             
  474.             
  475.             /*   -------------- Validazione: Gestione messaggio Errore Protocollo -----------------  */
  476.             if(isMessaggioErroreProtocollo){

  478.                 msgDiag.mediumDebug("Gestione messaggio errore protocollo...");
  479.                 boolean msgErroreProtocolloValido = true;

  481.                 if(configurazionePdDManager.getTipoValidazione(implementazionePdDDestinatario).equals(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO) == false){

  483.                     if(errors.size() != 0){

  485.                         // BUSTA ERRORE MALFORMATA :
  486.                         // Il seguente codice viene eseguito solo se la modalita' di validazione
  487.                         // della busta e' "Warning Only" o "active"

  489.                         // Registrazione eccezioni riscontrate dalla validazione della busta
  490.                         StringBuilder eccBuffer = new StringBuilder();
  491.                         for(int k = 0; k < errors.size() ; k++){
  492.                             Eccezione er = errors.get(k);
  493.                             if(k>0)
  494.                                 eccBuffer.append("\n");
  495.                             eccBuffer.append(er.toString(protocolFactory));
  496.                         }
  497.                         msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, errors.size()+"");
  498.                         msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, eccBuffer.toString());
  499.                         msgDiag.logPersonalizzato("validazioneBustaErrore.listaEccezioniMalformata");

  501.                         // Il lavoro deve essere terminato solo in caso di Modalita Active
  502.                         if(configurazionePdDManager.getTipoValidazione(implementazionePdDDestinatario).equals(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO) == true){
  503.                             msgErroreProtocolloValido=false;
  504.                         }
  505.                     }
  506.                 } // -- end if not active

  508.                 if(msgErroreProtocolloValido){
  509.                     //   Registrazione eccezioni portate nella busta
  510.                     if(bustaRisposta.sizeListaEccezioni()>0){
  511.                         msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, bustaRisposta.toStringListaEccezioni(protocolFactory));
  512.                         msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, bustaRisposta.sizeListaEccezioni()+"");
  513.                         msgDiag.logPersonalizzato("ricezioneBustaErrore");
  514.                     }
  515.                 }

  517.                 DettaglioEccezione dettaglioEccezione = sbustamentoRisposteMsg.getDettaglioEccezione();
  518.                 if(dettaglioEccezione!=null){
  519.                     msgDiag.addKeyword(CostantiPdD.KEY_OPENSPCOOP2_DETAILS, XMLUtils.toString(dettaglioEccezione));
  520.                     msgDiag.logPersonalizzato("ricezioneBustaErroreDetails");
  521.                 }
  522.                 
  523.                 // Gestione ERRORE
  524.                 boolean inoltraClientBustaRispostaErroreRicevuta = OpenSPCoop2Properties.getInstance().isErroreApplicativoInoltraClientBustaRispostaErroreRicevuta(protocolFactory.getProtocol());
  525.                 boolean sbustamentoInformazioniProtocolloRisposta = true; 
  526.                 try{        
  527.                     sbustamentoInformazioniProtocolloRisposta = configurazionePdDManager.invocazionePortaDelegataSbustamentoInformazioniProtocollo(sa);
  528.                 }catch(Exception e){
  529.                     msgDiag.logErroreGenerico(e, "acquisizione informazione sbustamentoInformazioniProtocolloRisposta");
  530.                 }
  531.                 if(sendRispostaApplicativa && msgErroreProtocolloValido &&
  532.                         !sbustamentoInformazioniProtocolloRisposta && // sbustamento protocollo (es. spcoop) disabilitato
  533.                         inoltraClientBustaRispostaErroreRicevuta // disabilitata la gestione dell'errore applicativo specifico
  534.                         ) {
  535.                     // proseguio con una gestione classica ritornando esattamente la busta errore ricevuta al client
  536.                 }
  537.                 else {
  538.                     msgDiag.mediumDebug("Invio eventuale messaggio di errore al servizio applicativo (gestione errore)...");
  539.                     if(sendRispostaApplicativa){
  540.                         Eccezione eccezioneDaInviareServizioApplicativo = 
  541.                                 Eccezione.getEccezioneValidazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), protocolFactory);
  542.                         ErroreIntegrazione erroreIntegrazioneDaInviareServizioApplicativo = null;
  543.                         if(msgErroreProtocolloValido){
  544.                             if(bustaRisposta.sizeListaEccezioni()>1){
  545.                                 StringBuilder bfDescrizione = new StringBuilder();
  546.                                 for(int k=0; k<bustaRisposta.sizeListaEccezioni();k++){
  547.                                     Eccezione eccListaEccezioni = bustaRisposta.getEccezione(k);
  548.                                     if(eccListaEccezioni.getDescrizione(protocolFactory)!=null)
  549.                                         bfDescrizione.append("["+traduttore.toString(eccListaEccezioni.getCodiceEccezione(),eccListaEccezioni.getSubCodiceEccezione())+"] "+eccListaEccezioni.getDescrizione(protocolFactory)+"\n");
  550.                                 }
  551.                                 if(bfDescrizione.length()>0)
  552.                                     eccezioneDaInviareServizioApplicativo.setDescrizione(bfDescrizione.toString());
  553.                             }else{
  554.                                 if(bustaRisposta.sizeListaEccezioni()==1){
  555.                                     eccezioneDaInviareServizioApplicativo = bustaRisposta.getEccezione(0);
  556.                                 }
  557.                                 else{
  558.                                     if(dettaglioEccezione!=null && dettaglioEccezione.getExceptions()!=null && dettaglioEccezione.getExceptions().sizeExceptionList()>0){
  559.                                         org.openspcoop2.core.eccezione.details.Eccezione e = dettaglioEccezione.getExceptions().getException(0);
  560.                                         if(org.openspcoop2.core.eccezione.details.constants.TipoEccezione.PROTOCOL.equals(e.getType())){
  561.                                             ErroreCooperazione msgErroreCooperazione =
  562.                                                     new ErroreCooperazione(e.getDescription(), traduttore.toCodiceErroreCooperazione(e.getCode()));
  563.                                             eccezioneDaInviareServizioApplicativo = new Eccezione(msgErroreCooperazione, false, SbustamentoRisposte.ID_MODULO ,protocolFactory);
  564.                                         }else{
  565.     //                                      erroreIntegrazioneDaInviareServizioApplicativo = 
  566.     //                                              new ErroreIntegrazione(e.getDescrizione(), traduttore.toCodiceErroreIntegrazione(e.getCodiceAAA(), propertiesReader.getProprietaGestioneErrorePD(protocolManager).getFaultPrefixCode()));
  567.                                             // Se e' arrivato un details di errore di integrazione, comunque genero una busta di errore di processamento, visto che di fatto ho ricevuto questa.
  568.                                             eccezioneDaInviareServizioApplicativo = Eccezione.
  569.                                                     getEccezioneProcessamento(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento(e.getDescription()), protocolFactory);
  570.                                         }
  571.                                     }else{
  572.                                         eccezioneDaInviareServizioApplicativo = new Eccezione(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione(), false, SbustamentoRisposte.ID_MODULO, protocolFactory);
  573.                                     }
  574.                                 }
  575.                             }
  576.                         }
  577.                         else{
  578.                             if(errors.size()>1){
  579.                                 StringBuilder bfDescrizione = new StringBuilder();
  580.                                 for(int k=0; k<errors.size();k++){
  581.                                     Eccezione error = errors.get(k);
  582.                                     if(error.getDescrizione(protocolFactory)!=null)
  583.                                         bfDescrizione.append("["+traduttore.toString(error.getCodiceEccezione(),error.getSubCodiceEccezione())+"] "+error.getDescrizione(protocolFactory)+"\n");
  584.                                 }
  585.                                 if(bfDescrizione.length()>0)
  586.                                     eccezioneDaInviareServizioApplicativo.setDescrizione(bfDescrizione.toString());
  587.                             }else{
  588.                                 eccezioneDaInviareServizioApplicativo = errors.get(0);
  589.                             }
  590.                         }
  591.                         OpenSPCoop2Message responseMessageError = null;
  592.                         if(eccezioneDaInviareServizioApplicativo!=null){
  593.                             responseMessageError = this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTEROPERABILITY_PROFILE_RESPONSE_ERROR,
  594.                                     eccezioneDaInviareServizioApplicativo,
  595.                                     richiestaDelegata.getIdServizio().getSoggettoErogatore(),dettaglioEccezione,
  596.                                     parseException);
  597.                         }else{
  598.                             responseMessageError = this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTEROPERABILITY_PROFILE_RESPONSE_ERROR,
  599.                                     erroreIntegrazioneDaInviareServizioApplicativo,null,
  600.                                     parseException);
  601.                         }
  602.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  603.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"BustaErrore");
  604.                     }else{
  605.                         ejbUtils.releaseInboxMessage(false); 
  606.                         esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,"BustaErrore");
  607.                     }
  608.                     msgDiag.mediumDebug("Rilascio connessione...");
  609.                     openspcoopstate.releaseResource();
  610.                     esito.setEsitoInvocazione(true); 
  611.                     return esito; // Non devo utilizzare una busta malformata
  612.                 }
  613.             }








  622.             /*   -------------- Validazione: Gestione messaggio di protocollo -----------------  */
  623.             if(isMessaggioErroreProtocollo == false){
  624.                 if(configurazionePdDManager.getTipoValidazione(implementazionePdDDestinatario).equals(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO) == false){

  626.                     // Redirigo Errori presenti nella Busta
  627.                     boolean validazioneConErrori = (errors.size() > 0);
  628.                     if( protocolManager.isIgnoraEccezioniLivelloNonGrave() || (this.propertiesReader.ignoraEccezioniNonGraviValidazione())){
  629.                         validazioneConErrori = Busta.containsEccezioniGravi(errors);
  630.                     }

  632.                     if(validazioneConErrori){

  634.                         msgDiag.mediumDebug("Gestione messaggio di protocollo che non ha superato la validazione...");

  636.                         // Registrazione eccezioni riscontrate dalla validazione della busta
  637.                         boolean mittenteRegistrato = true;
  638.                         StringBuilder eccBuffer = new StringBuilder();
  639.                         java.util.List<Eccezione> errorsClone =  new java.util.ArrayList<Eccezione>();
  640.                         for(int k = 0; k < errors.size() ; k++){
  641.                             Eccezione er = errors.get(k);
  642.                             errorsClone.add(er);
  643.                             if(k>0)
  644.                                 eccBuffer.append("\n");
  645.                             eccBuffer.append(er.toString(protocolFactory));
  646.                             if(CodiceErroreCooperazione.isEccezioneMittente(er.getCodiceEccezione())){
  647.                                 mittenteRegistrato = false;
  648.                             }
  649.                         }

  651.                         // Registrazione degli errori effettuata solo in caso la modalita di Validazione
  652.                         // della busta sia "Warning Only" o "active"
  653.                         msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, eccBuffer.toString());
  654.                         msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, errors.size()+"");
  655.                         msgDiag.logPersonalizzato("validazioneBusta.bustaNonCorretta");

  657.                         // Spedizione BustaErrore contenente gli errori riscontrati, solo se
  658.                         // la modalita di validazione della busta e' "active"
  659.                         // e il Mittente e' comunque conosciuto.
  660.                         if( configurazionePdDManager.getTipoValidazione(implementazionePdDDestinatario).equals(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO) == true) {

  662.                             // Spedisco un Errore ad un mittente conosciuto...
  663.                             boolean segnalazioneErrore = false; // inviare una segnalazione su una nuova connessione non e' piu' supportato neanche da spcoop.
  664.                             if(mittenteRegistrato && segnalazioneErrore){
  665.                                 
  666.                                 if( openspcoopstate.resourceReleased()) {
  667.                                     ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  668.                                     ((OpenSPCoopState)openspcoopstate).initResource(identitaPdD, "EJBUtils.segnalazioneErroreBustaRisposta", idTransazione);
  669.                                 }
  670.                                 
  671.                                 // SPEDIZIONE BUSTA ERRORE AL MITTENTE DELLA BUSTA :
  672.                                 msgDiag.mediumDebug("Invio segnalazione di errore ...");
  673.                                 ejbUtils.sendAsRispostaBustaErrore_inoltroSegnalazioneErrore(bustaRisposta,errorsClone);

  675.                             }

  677.                             // GESTIONE INTERNA DI QUESTA BUSTA ERRORE :
  678.                             // spedisco prima eccezione riscontrata al SIL.
  679.                             msgDiag.mediumDebug("Invio eventuale messaggio di errore al servizio applicativo (gestione errore)...");
  680.                             if(sendRispostaApplicativa){
  681.                                 Eccezione eccezioneDaInviareServizioApplicativo = null;
  682.                                 if(errors.size()>1){
  683.                                     eccezioneDaInviareServizioApplicativo = 
  684.                                             Eccezione.getEccezioneValidazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), protocolFactory);
  685.                                     StringBuilder bfDescrizione = new StringBuilder();
  686.                                     for(int k=0; k<errors.size();k++){
  687.                                         Eccezione error = errors.get(k);
  688.                                         if(error.getDescrizione(protocolFactory)!=null)
  689.                                             bfDescrizione.append("["+traduttore.toString(error.getCodiceEccezione(),error.getSubCodiceEccezione())+"] "+error.getDescrizione(protocolFactory)+"\n");
  690.                                     }
  691.                                     if(bfDescrizione.length()>0)
  692.                                         eccezioneDaInviareServizioApplicativo.setDescrizione(bfDescrizione.toString());
  693.                                 }else{
  694.                                     eccezioneDaInviareServizioApplicativo = errors.get(0);
  695.                                 }

  697.                                 // profilo sincrono asincronoPolling, aspetta una risposta
  698.                                 
  699.                                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_RESPONSE;
  700.                                 if(validazione_integrationFunctionError!=null) {
  701.                                     integrationFunctionError = validazione_integrationFunctionError;
  702.                                 }
  703.                                 OpenSPCoop2Message responseMessageError =
  704.                                         this.generatoreErrore.build(pddContext, integrationFunctionError,
  705.                                                 eccezioneDaInviareServizioApplicativo,
  706.                                             richiestaDelegata.getIdSoggettoFruitore(),
  707.                                             parseException);
  708.                                 ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  709.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  710.                                         msgDiag.getMessaggio_replaceKeywords("validazioneBusta.bustaNonCorretta"));
  711.                             }else{
  712.                                 // profilo OneWay, non aspetta una risposta
  713.                                 ejbUtils.releaseInboxMessage(false);
  714.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,
  715.                                         msgDiag.getMessaggio_replaceKeywords("validazioneBusta.bustaNonCorretta"));
  716.                             }
  717.                             msgDiag.mediumDebug("Rilascio connessione...");
  718.                             openspcoopstate.releaseResource();
  719.                             esito.setEsitoInvocazione(true); 
  720.                             return esito;
  721.                         }
  722.                     }
  723.                 }
  724.             }





  730.             /* -----------
  731.              *
  732.              * Stampa dei messaggi di errore non GRAVI
  733.              * (frammento di codice raggiunto SOLO se profilo=LineeGuida1.1)
  734.              *
  735.              * ------------------ */
  736.             if( (bustaRisposta.containsEccezioniGravi()==false) && (bustaRisposta.sizeListaEccezioni()>0) ){
  737.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, bustaRisposta.toStringListaEccezioni(protocolFactory));
  738.                 msgDiag.logPersonalizzato("ricezioneBusta.eccezioniNonGravi");
  739.             }
  740.             // Stampa di eventuali eccezioni NON GRAVI venute fuori durante la validazione della busta
  741.             if( (Busta.containsEccezioniGravi(errors)==false) && (errors.size()>0) ){
  742.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, Busta.toStringListaEccezioni(errors, protocolFactory));
  743.                 msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, errors.size()+"" );
  744.                 msgDiag.logPersonalizzato("validazioneBusta.eccezioniNonGravi");
  745.             }





  751.             /* ------  Ricezione riscontri per il NAL (deve essere la prima attivita', poiche' effettua commit JDBC) -------- */
  752.             if(ricezioneRiscontri){
  753.                 if(bustaRisposta.sizeListaRiscontri() > 0){
  754.                     
  755.                     if(openspcoopstate.resourceReleased()) {
  756.                         ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  757.                         openspcoopstate.initResource(identitaPdD, this.idModulo, idTransazione);
  758.                     }
  759.                     
  760.                     for(int i=0;i<bustaRisposta.sizeListaRiscontri();i++){
  761.                         Riscontro r = bustaRisposta.getRiscontro(i);
  762.                         
  763.                         msgDiag.addKeyword(CostantiPdD.KEY_ID_BUSTA_RISCONTRATA, r.getID());
  764.                         msgDiag.addKeyword(CostantiPdD.KEY_DATA_RISCONTRO, r.getOraRegistrazione().toString());
  765.                         msgDiag.logPersonalizzato("ricezioneRiscontro");
  766.                         try{
  767.                             GestoreMessaggi msgRiscontrato = new GestoreMessaggi(openspcoopstate, true, r.getID(),Costanti.OUTBOX,msgDiag, pddContext);
  768.                             msgRiscontrato.validateAndDeleteMsgOneWayRiscontrato();
  769.                         }catch(Exception e){
  770.                             msgDiag.logErroreGenerico(e, "msgRiscontrato.validateAndDeleteMsgOneWayRiscontrato("+r.getID()+")"); 
  771.                         }
  772.                     }
  773.                 }
  774.             }



  778.             




  783.             /*   -------------- Controllo esistenza soggetto destinatario  ------------------ */
  784.             msgDiag.mediumDebug("Controllo appartenenza Destinazione Busta (controllo esistenza soggetto)...");
  785.             boolean existsSoggetto = false;
  786.             try{
  787.                 existsSoggetto = configurazionePdDManager.existsSoggetto(new IDSoggetto(bustaRisposta.getTipoDestinatario(),bustaRisposta.getDestinatario()), requestInfo);
  788.             }catch(Exception e){
  789.                 msgDiag.logErroreGenerico(e,"existsSoggetto("+bustaRisposta.getTipoDestinatario()+"/"+bustaRisposta.getDestinatario()+")");
  790.                 if(sendRispostaApplicativa){
  791.                     OpenSPCoop2Message responseMessageError =
  792.                             this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  793.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  794.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,
  795.                                             parseException);
  796.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  797.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  798.                             "existsSoggetto("+bustaRisposta.getTipoDestinatario()+"/"+bustaRisposta.getDestinatario()+")");
  799.                 }else{
  800.                     ejbUtils.releaseInboxMessage(false); 
  801.                     esito.setStatoInvocazioneErroreNonGestito(e);
  802.                 }
  803.                 openspcoopstate.releaseResource();
  804.                 esito.setEsitoInvocazione(true);
  805.                 return esito;
  806.             }
  807.             if(!existsSoggetto){
  808.                 msgDiag.logPersonalizzato("soggettoDestinatarioNonGestito");
  809.                 if(sendRispostaApplicativa){
  810.                     OpenSPCoop2Message responseMessageError =
  811.                             this.generatoreErrore.build(pddContext, IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_RESPONSE,
  812.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  813.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_528_RISPOSTA_RICHIESTA_NON_VALIDA),null,
  814.                                             parseException);
  815.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  816.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  817.                             msgDiag.getMessaggio_replaceKeywords("soggettoDestinatarioNonGestito"));
  818.                 }else{
  819.                     ejbUtils.releaseInboxMessage(false);
  820.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,
  821.                             msgDiag.getMessaggio_replaceKeywords("soggettoDestinatarioNonGestito"));
  822.                 }
  823.                 openspcoopstate.releaseResource();
  824.                 esito.setEsitoInvocazione(true);
  825.                 return esito;
  826.             }










  837.             /* -------------------
  838.                Controllo se la busta porta Dati .
  839.                In caso ad es. di riscontri ... arrivera' una busta senza dati, e senza profilo di collaborazione.
  840.                o comunque non devono essere considerati
  841.                --------------------- */
  842.             if(bustaDiServizio == true) {

  844.                 msgDiag.logPersonalizzato("ricezioneBustaServizio");

  846.                 // Scenario OneWay in modalita sincrona
  847.                 if(Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) &&
  848.                         sendRispostaApplicativa){
  849.                     msgDiag.mediumDebug("Gestione riscontro per oneway in modalita sincrona...");
  850.                 }else{
  851.                     if(sendRispostaApplicativa){
  852.                         OpenSPCoop2Message responseMessageError =
  853.                                 this.generatoreErrore.build(pddContext, IntegrationFunctionError.EXPECTED_RESPONSE_NOT_FOUND,
  854.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  855.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_517_RISPOSTA_RICHIESTA_NON_RITORNATA),null,
  856.                                                 parseException);
  857.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  858.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  859.                                 msgDiag.getMessaggio_replaceKeywords("ricezioneBustaServizio"));
  860.                     }else{
  861.                         ejbUtils.releaseInboxMessage(true);
  862.                         esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,
  863.                                 msgDiag.getMessaggio_replaceKeywords("ricezioneBustaServizio"));
  864.                     }
  865.                     openspcoopstate.releaseResource();
  866.                     esito.setEsitoInvocazione(true); 
  867.                     return esito;
  868.                 }
  869.             }







  877.             /* ------------  Gestione Duplicati  ------------- */
  878.                         
  879.             boolean checkDuplicato = imbustamentoFiltroDuplicatiAbilitato;
  880.             if(checkDuplicato){
  881.                 
  882.                 try{
  883.                     
  884.                     // Istanzio gestore filtro duplicati
  885.                     String gestoreFiltroDuplicatiType = this.propertiesReader.getGestoreFiltroDuplicatiRepositoryBuste();
  886.                     ClassNameProperties prop = ClassNameProperties.getInstance();
  887.                     String gestoreFiltroDuplicatiClass = prop.getFiltroDuplicati(gestoreFiltroDuplicatiType);
  888.                     if(gestoreFiltroDuplicatiClass == null){
  889.                         throw new Exception("GestoreFiltroDuplicati non registrato ("+gestoreFiltroDuplicatiType+")");
  890.                     }
  891.                     IFiltroDuplicati gestoreFiltroDuplicati = (IFiltroDuplicati) this.loader.newInstance(gestoreFiltroDuplicatiClass);
  892.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.OPENSPCOOP_STATE, openspcoopstate );
  893.                     gestoreFiltroDuplicati.init(pddContext);
  894.                     if(gestoreFiltroDuplicati instanceof FiltroDuplicati){
  895.                         ((FiltroDuplicati)gestoreFiltroDuplicati).setHistoryBuste(historyBuste);
  896.                         ((FiltroDuplicati)gestoreFiltroDuplicati).setRepositoryBuste(repositoryBuste);
  897.                         ((FiltroDuplicati)gestoreFiltroDuplicati).setGestioneStateless(openspcoopstate instanceof OpenSPCoopStateless);
  898.                         ((FiltroDuplicati)gestoreFiltroDuplicati).setRepositoryIntervalloScadenzaMessaggi(this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  899.                     }
  900.                     
  901.                     boolean oldGestioneConnessione = false;
  902.                     boolean rinegozia = false;
  903.                     if(gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && !openspcoopstate.resourceReleased()) {
  904.                         rinegozia = true;
  905. //                      System.out.println("[RISPOSTA] rilascio!!");
  906.                         msgDiag.mediumDebug("Rilascio connessione al database prima di verificare se la risposta è duplicata ...");
  907.                         oldGestioneConnessione = ((OpenSPCoopState)openspcoopstate).isUseConnection();
  908.                         ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  909.                         openspcoopstate.commit();
  910.                         openspcoopstate.releaseResource();
  911. //                      System.out.println("[RISPOSTA] rilasciata: "+
  912. //                              (((org.openspcoop2.pdd.core.state.OpenSPCoopState)openspcoopstate).getConnectionDB()==null || ((OpenSPCoopState)openspcoopstate).getConnectionDB().isClosed()));
  913.                     }
  914.                     boolean initConnectionForDuplicate = false;
  915.                     if(!gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && openspcoopstate.resourceReleased()) {
  916.                         // il vecchio engine che verifica il filtro duplicati ha bisogno della connessione
  917.                         // inizializzo
  918.                         ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  919.                         openspcoopstate.initResource(identitaPdD, this.idModulo, idTransazione);
  920.                         historyBuste.updateState(openspcoopstate.getStatoRichiesta());
  921.                         repositoryBuste.updateState(openspcoopstate.getStatoRichiesta());
  922.                         profiloCollaborazione.updateState(openspcoopstate.getStatoRichiesta());
  923.                         ejbUtils.updateOpenSPCoopState(openspcoopstate);
  924.                         initConnectionForDuplicate = true;
  925.                     }
  926.                     
  927.                     boolean bustaDuplicata = gestoreFiltroDuplicati.isDuplicata(protocolFactory, bustaRisposta.getID());
  928.                 
  929.                     // BUSTA GIA' PRECEDENTEMENTE RICEVUTA
  930.                     if (bustaDuplicata){
  931.                         
  932.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.RISPOSTA_DUPLICATA, "true");
  933.                         
  934.                         // Aggiorno duplicati
  935.                         msgDiag.logPersonalizzato("ricezioneBustaDuplicata.count");
  936.                         gestoreFiltroDuplicati.incrementaNumeroDuplicati(protocolFactory, bustaRisposta.getID());
  937.                         msgDiag.logPersonalizzato("ricezioneBustaDuplicata");
  938.                         
  939.                     }else {
  940.         
  941.                         // REGISTRAZIONE BUSTA RICEVUTA NELL'HISTORY
  942.                         gestoreFiltroDuplicati.registraBusta(protocolFactory, bustaRisposta);
  943.                         msgDiag.logPersonalizzato("ricezioneBusta.registrazionePerFiltroDuplicati");
  944.                     }
  945.                     
  946.                     if(gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && rinegozia) {
  947. //                      System.out.println("[RISPOSTA] rinegozio!!");
  948.                         msgDiag.mediumDebug("Rinegozio connessione dopo la verifica di risposta duplicata ...");
  949.                         try{
  950.                             openspcoopstate.updateResource(idTransazione);
  951.                             ((OpenSPCoopState)openspcoopstate).setUseConnection(oldGestioneConnessione);
  952. //                          // Aggiorno risorse
  953. //                          ejbUtils.updateOpenSPCoopState(openspcoopstate);
  954. //                          msgRequest.updateOpenSPCoopState(openspcoopstate);                          
  955. //                          System.out.println("[RISPOSTA] rinegoziata: "+
  956. //                                  (((org.openspcoop2.pdd.core.state.OpenSPCoopState)openspcoopstate).getConnectionDB()!=null && !((OpenSPCoopState)openspcoopstate).getConnectionDB().isClosed()));
  957.                         }catch(Exception e){
  958.                             throw new Exception("Rinegoziazione connessione dopo la verifica di risposta duplicata fallita: "+e.getMessage(),e);
  959.                         } 
  960.                     }
  961.                     if(!gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && initConnectionForDuplicate) {
  962.                         openspcoopstate.commit();
  963.                     }
  964.                     
  965.                     if (bustaDuplicata){
  966.         
  967.                         if(sendRispostaApplicativa){
  968.                             /*this.xmlBuilder.msgErroreApplicativo_Processamento(proprietaErroreAppl,
  969.                                         CostantiPdD.CODICE_528_RISPOSTA_RICHIESTA_NON_VALIDA,
  970.                                         CostantiPdD.MSG_5XX_SISTEMA_NON_DISPONIBILE);*/
  971.                             OpenSPCoop2Message responseMessageError =
  972.                                     this.generatoreErrore.build(pddContext, IntegrationFunctionError.CONFLICT_RESPONSE,
  973.                                             Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),
  974.                                                         protocolFactory), identitaPdD, parseException);
  975.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  976.                                     msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata"));
  977.                             ejbUtils.setRollbackRichiestaInCasoErrore_rollbackHistory(false); // non devo cancellare la busta per la gestione dei duplicati
  978.                             ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  979.                         }else{
  980.                             // Devo rilasciare il messaggio, senza cancellarlo dalla history.
  981.                             ejbUtils.releaseInboxMessage(false,true);
  982.                             esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,
  983.                                     msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata"));
  984.                         }
  985.         
  986.                         openspcoopstate.commit();
  987.                         openspcoopstate.releaseResource();
  988.                         esito.setEsitoInvocazione(true); 
  989.                         return esito;
  990.         
  991.                     }
  992.                     
  993.                 }catch(Exception e) {
  994.                     msgDiag.logErroreGenerico(e, "GestioneHistoryBusteRicevute");
  995.                     if(sendRispostaApplicativa){
  996.                         OpenSPCoop2Message responseMessageError =
  997.                                 this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  998.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  999.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,
  1000.                                                 parseException);
  1001.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  1002.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"GestioneHistoryBusteRicevute");
  1003.                     }else{
  1004.                         ejbUtils.releaseInboxMessage(false); 
  1005.                         esito.setStatoInvocazioneErroreNonGestito(e);
  1006.                     }
  1007.                     openspcoopstate.releaseResource();
  1008.                     esito.setEsitoInvocazione(true); 
  1009.                     return esito;
  1010.                 }
  1011.                 
  1012.                 pddContext.removeObject(org.openspcoop2.core.constants.Costanti.OPENSPCOOP_STATE);
  1013.             }
  1014.             













  1028.             /* ------------  Validazione profilo di collaborazione Atteso  ------------- */
  1029.             Eccezione ecc = null;
  1030.             msgDiag.addKeyword(CostantiPdD.KEY_SCENARIO_COOPERAZIONE_GESTITO, richiestaDelegata.getScenario());
  1031.             if(Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario())){
  1032.                 msgDiag.mediumDebug("Gestione profilo di collaborazione OneWay...");
  1033.                 // Deve arrivare al massimo una busta con profilo null, o oneWay per compatibilita' con altre PdD
  1034.                 if(bustaRisposta.getProfiloDiCollaborazione()!=null &&
  1035.                         org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRisposta.getProfiloDiCollaborazione()) == false){
  1036.                     
  1037.                     msgDiag.logPersonalizzato("profiloCollaborazioneRisposta.diversoScenarioGestito");
  1038.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO.getErroreProfiloCollaborazioneNonValido(
  1039.                             "Profilo di collaborazione diverso dallo scenario di cooperazione (atteso OneWay)."),
  1040.                     protocolFactory);
  1041.                 }
  1042.                 // Se arriva un riferimento msg deve comunque essere quello della richiesta
  1043.                 // La validazione non valida il rifMsg per OneWay poiche' e' solo per compatibilita' con HPPdD
  1044.                 else if(bustaRisposta.getRiferimentoMessaggio()!=null &&
  1045.                         !bustaRisposta.getRiferimentoMessaggio().equals(idMessageRequest) &&
  1046.                         !bustaRisposta.getRiferimentoMessaggio().equals(jtiIdModIRequest)){
  1047.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonValido");
  1048.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(),protocolFactory);
  1049.                 }
  1050.             }
  1051.             if(Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario())){
  1052.                 msgDiag.mediumDebug("Gestione profilo di collaborazione Sincrono...");
  1053.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRisposta.getProfiloDiCollaborazione()) == false){
  1054.                     msgDiag.logPersonalizzato("profiloCollaborazioneRisposta.diversoScenarioGestito");
  1055.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO.getErroreProfiloCollaborazioneNonValido(
  1056.                     "Profilo di collaborazione diverso dallo scenario di cooperazione (atteso Sincrono)."),
  1057.                     protocolFactory);
  1058.                 }else if(bustaRisposta.getRiferimentoMessaggio()==null){
  1059.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonPresente");
  1060.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_PRESENTE.getErroreCooperazione(),protocolFactory);
  1061.                 }else if(bustaRisposta.getRiferimentoMessaggio()!=null &&
  1062.                         !bustaRisposta.getRiferimentoMessaggio().equals(idMessageRequest) &&
  1063.                         !bustaRisposta.getRiferimentoMessaggio().equals(jtiIdModIRequest)){
  1064.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonValido");
  1065.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(),protocolFactory);
  1066.                 }
  1067.             }else if(Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ||
  1068.                     Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(richiestaDelegata.getScenario()) ){
  1069.                 msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico...");
  1070.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRisposta.getProfiloDiCollaborazione()) == false){
  1071.                     msgDiag.logPersonalizzato("profiloCollaborazioneRisposta.diversoScenarioGestito");
  1072.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO.getErroreProfiloCollaborazioneNonValido(
  1073.                     "Profilo di collaborazione diverso dallo scenario di cooperazione (atteso AsincronoSimmetrico)."),
  1074.                     protocolFactory);
  1075.                 }else if(bustaRisposta.getRiferimentoMessaggio()==null){
  1076.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonPresente");
  1077.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_PRESENTE.getErroreCooperazione(),protocolFactory);
  1078.                 }else if(bustaRisposta.getRiferimentoMessaggio()!=null &&
  1079.                         !bustaRisposta.getRiferimentoMessaggio().equals(idMessageRequest) &&
  1080.                         !bustaRisposta.getRiferimentoMessaggio().equals(jtiIdModIRequest)){
  1081.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonValido");
  1082.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(),protocolFactory);
  1083.                 }
  1084.             }
  1085.             else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario()) ||
  1086.                     Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(richiestaDelegata.getScenario()) ){
  1087.                 msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico...");
  1088.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRisposta.getProfiloDiCollaborazione()) == false){
  1089.                     msgDiag.logPersonalizzato("profiloCollaborazioneRisposta.diversoScenarioGestito");
  1090.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO.getErroreProfiloCollaborazioneNonValido(
  1091.                     "Profilo di collaborazione diverso dallo scenario di cooperazione (atteso AsincronoAsimmetrico)."),
  1092.                     protocolFactory);
  1093.                 }else if(bustaRisposta.getRiferimentoMessaggio()==null){
  1094.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonPresente");
  1095.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_PRESENTE.getErroreCooperazione(),protocolFactory);
  1096.                 }else if(bustaRisposta.getRiferimentoMessaggio()!=null &&
  1097.                         !bustaRisposta.getRiferimentoMessaggio().equals(idMessageRequest) &&
  1098.                         !bustaRisposta.getRiferimentoMessaggio().equals(jtiIdModIRequest)){
  1099.                     msgDiag.logPersonalizzato("riferimentoMessaggioNonValido");
  1100.                     ecc = Eccezione.getEccezioneValidazione(ErroriCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO.getErroreCooperazione(),protocolFactory);
  1101.                 }
  1102.             }
  1103.             if(ecc!=null){
  1104.                 if(sendRispostaApplicativa){
  1105.                     OpenSPCoop2Message responseMessageError =
  1106.                             this.generatoreErrore.build(pddContext, IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_RESPONSE,ecc,
  1107.                                 richiestaDelegata.getIdSoggettoFruitore(),parseException);
  1108.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  1109.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,ecc.toString(protocolFactory));
  1110.                 }else{
  1111.                     ejbUtils.releaseInboxMessage(false); 
  1112.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,ecc.toString(protocolFactory));
  1113.                 }
  1114.                 openspcoopstate.releaseResource();
  1115.                 esito.setEsitoInvocazione(true); 
  1116.                 return esito;
  1117.             }














  1132.             /* ------------  Profilo di collaborazione  ------------- */
  1133.             msgDiag.mediumDebug("Gestione profilo...");
  1134.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRisposta.getProfiloDiCollaborazione())){
  1135.                 msgDiag.logPersonalizzato("rispostaOneway");
  1136.             }
  1137.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRisposta.getProfiloDiCollaborazione())){

  1139.                 // Eliminazione informazioni sincrone
  1140.                 msgDiag.mediumDebug("Gestione profilo di collaborazione Sincrono (elimina richiesta in OutBox)...");
  1141.                 try{
  1142.                     profiloCollaborazione.sincrono_eliminaRichiestaInOutBox(bustaRisposta.getRiferimentoMessaggio());
  1143.                 }catch(Exception e){
  1144.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.sincrono_eliminaRichiestaInOutBox");
  1145.                     OpenSPCoop2Message responseMessageError =
  1146.                             this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  1147.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1148.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,
  1149.                                             parseException);
  1150.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  1151.                     openspcoopstate.releaseResource();
  1152.                     esito.setEsitoInvocazione(true);
  1153.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "profiloCollaborazione.sincrono_eliminaRichiestaInOutBox");
  1154.                     return esito;
  1155.                 }
  1156.             }
  1157.             else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRisposta.getProfiloDiCollaborazione())) {

  1159.                 // un riferimento msg vi e' per forza, altrimenti non supera il controllo precedente sullo scenario

  1161.                 //  Ricevuta alla richiesta.
  1162.                 if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())){
  1163.                     ricevutaAsincrona = "ricevuta di una richiesta asincrona simmetrica";
  1164.                 }
  1165.                 //  Ricevuta alla risposta.
  1166.                 else if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  1167.                     ricevutaAsincrona = "ricevuta di una risposta asincrona simmetrica";
  1168.                 }
  1169.                 else{
  1170.                     String motivazioneErrore = "Gestione busta di risposta asincrona simmetrica non permessa (Busta "+bustaRisposta.getID()+"); il modulo attendeva una ricevuta asincrona";
  1171.                     msgDiag.logErroreGenerico(motivazioneErrore,"GestioneProfiloAsincronoSimmetrico");
  1172.                     ejbUtils.releaseInboxMessage(false);
  1173.                     openspcoopstate.releaseResource();
  1174.                     esito.setEsitoInvocazione(true); 
  1175.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,motivazioneErrore);
  1176.                     return esito;
  1177.                 }
  1178.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRisposta.getProfiloDiCollaborazione())) { 

  1180.                 // un riferimento msg vi e' per forza, altrimenti non supera il controllo precedente sullo scenario 
  1181.                 
  1182.                 //  Ricevuta alla richiesta.
  1183.                 if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())){
  1184.                         
  1185.                     ricevutaAsincrona = "ricevuta di una richiesta asincrona asimmetrica";
  1186.                         
  1187.                 }
  1188.                 //  Ricevuta alla risposta.
  1189.                 else if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  1190.                     
  1191.                     ricevutaAsincrona = "ricevuta di una risposta asincrona asimmetrica contenente l'esito della richiesta stato";
  1192.                                                     
  1193.                 }
  1194.                 else{
  1195.                     String motivazioneErrore = "Gestione busta di risposta asincrona asimmetrica non permessa (Busta "+bustaRisposta.getID()+"); il modulo attendeva una ricevuta asincrona";
  1196.                     msgDiag.logErroreGenerico(motivazioneErrore, "GestioneProfiloAsincronoAsimmetrico");
  1197.                     ejbUtils.releaseInboxMessage(false);
  1198.                     openspcoopstate.releaseResource();
  1199.                     esito.setEsitoInvocazione(true); 
  1200.                     esito.setStatoInvocazione(EsitoLib.ERRORE_NON_GESTITO,motivazioneErrore);
  1201.                     return esito;
  1202.                         
  1203.                 }
  1204.             }     











  1216.             /* ----------------- GestioneBustaArrivata ----------------- */
  1217.             if(sendRispostaApplicativa){

  1219.                 // Spedisco risposta applicativa

  1221.                 if(Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaDelegata.getScenario())){


  1224.                     msgResponse = new GestoreMessaggi(openspcoopstate, false, bustaRisposta.getID(), Costanti.INBOX, msgDiag,pddContext);
  1225.                     msgDiag.mediumDebug("Aggiorno proprietario messaggio...");
  1226.                     // Aggiorno proprietario messaggio
  1227.                     msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  1228.                     msgDiag.mediumDebug("Elimino accesso da PdD...");
  1229.                     // Elimino accesso daPdD
  1230.                     repositoryBuste.eliminaUtilizzoPdDFromInBox(idResponse);

  1232.                     msgDiag.mediumDebug("Invio messaggio 'OK' al modulo di RicezioneContenutiApplicativi, oneway con scenario sincrono...");

  1234.                     if(protocolManager.isHttpEmptyResponseOneWay())
  1235.                         msgResponse = ejbUtils.sendRispostaApplicativaOK(MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  1236.                                 requestInfo.getIntegrationRequestMessageType(),MessageRole.RESPONSE),richiestaDelegata,pd,sa);
  1237.                     else
  1238.                         msgResponse = ejbUtils.sendRispostaApplicativaOK(ejbUtils.buildOpenSPCoopOK(requestInfo.getIntegrationRequestMessageType(), idMessageRequest),richiestaDelegata,pd,sa);
  1239.                     
  1240.                 } else {
  1241.                     msgDiag.mediumDebug("Send risposta applicativa...");
  1242.                     msgResponse = ejbUtils.sendRispostaApplicativa(richiestaDelegata,pd,sa);
  1243.                 }

  1245.             } else {

  1247.                 // Elimino la risposta
  1248.                 msgResponse = new GestoreMessaggi(openspcoopstate, false, bustaRisposta.getID(),Costanti.INBOX,msgDiag,pddContext);
  1249.                 msgDiag.mediumDebug("Aggiorno proprietario messaggio...");
  1250.                 // Aggiorno proprietario messaggio
  1251.                 msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  1252.                 msgDiag.mediumDebug("Elimino accesso da PdD...");
  1253.                 // Elimino accesso daPdD
  1254.                 repositoryBuste.eliminaUtilizzoPdDFromInBox(idResponse,statelessAsincrono);
  1255.             }

  1257.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della busta...");
  1258.             openspcoopstate.commit();

  1260.         }catch(Throwable e){
  1261.             this.log.error("ErroreGenerale",e);
  1262.             msgDiag.logErroreGenerico(e, "Generale");
  1263.             
  1264.             if(sendRispostaApplicativa){
  1265.                 OpenSPCoop2Message responseMessageError =
  1266.                         this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  1267.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),e,
  1268.                                     parseException);
  1269.                 try{
  1270.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,rollbackRiferimentoMessaggio,pd,sa);
  1271.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"ErroreGenerale");
  1272.                     esito.setEsitoInvocazione(true);
  1273.                 }catch(Exception er){
  1274.                     msgDiag.logErroreGenerico(er,"ejbUtils.sendErroreGenerale(profiloConRisposta)");
  1275.                     ejbUtils.rollbackMessage("Spedizione Errore al Mittente durante una richiesta sincrona non riuscita", esito);
  1276.                     esito.setStatoInvocazioneErroreNonGestito(er);
  1277.                     esito.setEsitoInvocazione(false);
  1278.                 }
  1279.             }else{
  1280.                 ejbUtils.rollbackMessage("ErroreGenerale:"+e.getMessage(), esito);
  1281.                 esito.setEsitoInvocazione(false);
  1282.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1283.             }
  1284.             openspcoopstate.releaseResource();
  1285.             return esito;
  1286.         }

  1288.         // Aggiornamento cache messaggio
  1289.         if(msgResponse!=null)
  1290.             msgResponse.addMessaggiIntoCache_readFromTable(SbustamentoRisposte.ID_MODULO, "risposte");

  1292.         // Aggiornamento cache proprietario messaggio
  1293.         if(msgResponse!=null)
  1294.             msgResponse.addProprietariIntoCache_readFromTable(SbustamentoRisposte.ID_MODULO, "risposte",idMessageRequest,false);

  1296.         //  Gestione ricevute
  1297.         if(ricevutaAsincrona!=null){
  1298.             msgDiag.mediumDebug("Gestione ricevute asincrone...");
  1299.             try{

  1301.                 boolean forzaEliminazioneMessaggio = false;
  1302.                 if( (openspcoopstate instanceof OpenSPCoopStateless) &&  
  1303.                         ("ricevuta di una richiesta asincrona simmetrica".equals(ricevutaAsincrona)) ){
  1304.                     forzaEliminazioneMessaggio = true;
  1305.                 }
  1306.                 
  1307.                 GestoreMessaggi msgRiscontrato = new GestoreMessaggi(openspcoopstate, false ,bustaRisposta.getRiferimentoMessaggio(),Costanti.OUTBOX,msgDiag,pddContext);
  1308.                 msgRiscontrato.setReadyForDrop(forzaEliminazioneMessaggio);
  1309.                 msgRiscontrato.validateAndDeleteMsgAsincronoRiscontrato(bustaRisposta);
  1310.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_RICEVUTA_ASINCRONA, ricevutaAsincrona);
  1311.                 msgDiag.logPersonalizzato("validazioneRicevutaAsincrona");
  1312.             }catch(Exception e){
  1313.                 msgDiag.logErroreGenerico(e,"Validazione("+ricevutaAsincrona+")");
  1314.             }
  1315.         }

  1317.         //  Rilascio connessione al DB
  1318.         msgDiag.mediumDebug("Rilascio connessione al database...");
  1319.         openspcoopstate.releaseResource();

  1321.         msgDiag.mediumDebug("Lavoro Terminato.");
  1322.         esito.setStatoInvocazione(EsitoLib.OK, null);

  1324.         esito.setEsitoInvocazione(true);
  1325.         return esito;

  1327.     }
  1328. }
Created with JaCoCo 0.8.8.202204050719