ImbustamentoRisposte.java

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

  21. package org.openspcoop2.pdd.mdb;

  23. import org.slf4j.Logger;
  24. import org.openspcoop2.core.constants.TipoPdD;
  25. import org.openspcoop2.core.id.IDServizio;
  26. import org.openspcoop2.core.id.IDSoggetto;
  27. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  28. import org.openspcoop2.message.OpenSPCoop2Message;
  29. import org.openspcoop2.message.exception.ParseException;
  30. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  31. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  32. import org.openspcoop2.pdd.config.RichiestaDelegata;
  33. import org.openspcoop2.pdd.core.CostantiPdD;
  34. import org.openspcoop2.pdd.core.EJBUtils;
  35. import org.openspcoop2.pdd.core.GestoreMessaggi;
  36. import org.openspcoop2.pdd.core.PdDContext;
  37. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  38. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  39. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  40. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  41. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  42. import org.openspcoop2.pdd.services.DirectVMProtocolInfo;
  43. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  44. import org.openspcoop2.protocol.engine.constants.Costanti;
  45. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  46. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  47. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  48. import org.openspcoop2.protocol.sdk.Busta;
  49. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  50. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  51. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  52. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  53. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  54. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  55. import org.openspcoop2.protocol.sdk.state.IState;
  56. import org.openspcoop2.protocol.sdk.state.RequestInfo;

  58. /**
  59.  * Contiene la libreria ImbustamentoRisposte
  60.  * 
  61.  * @author Poli Andrea (apoli@link.it)
  62.  * @author Tronci Fabio (tronci@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */
  66. public class ImbustamentoRisposte extends GenericLib {

  68.     public static final String ID_MODULO = "ImbustamentoRisposte";

  70.     public ImbustamentoRisposte(Logger log) throws GenericLibException {
  71.         super(ImbustamentoRisposte.ID_MODULO, log);
  72.         inizializza();
  73.     }

  75.     @Override
  76.     public EsitoLib _onMessage(IOpenSPCoopState openspcoopstate,
  77.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  78.             MsgDiagnostico msgDiag) throws OpenSPCoopStateException {
  79.         EsitoLib esito = new EsitoLib(); 
  80.         ImbustamentoRisposteMessage imbustamentoRisposteMsg = (ImbustamentoRisposteMessage) openspcoopstate.getMessageLib();
  81.         
  82.         /* Regupero eventuali errori di parsing. */
  83.         ParseException parseException = null;
  84.         if(openspcoopstate instanceof OpenSPCoopStateless) {
  85.             OpenSPCoop2Message msgRisposta = ((OpenSPCoopStateless) openspcoopstate).getRispostaMsg();
  86.             if(msgRisposta!=null){
  87.                 parseException = msgRisposta.getParseException();
  88.             }
  89.         }
  90.         
  91.         /* PddContext */
  92.         PdDContext pddContext = imbustamentoRisposteMsg.getPddContext();
  93.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  94.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  95.                 
  96.         /* Protocol Factory */
  97.         IProtocolFactory<?> protocolFactory = null;
  98.         try{
  99.             protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  100.         }catch(Exception e){
  101.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  102.             openspcoopstate.releaseResource();
  103.             esito.setEsitoInvocazione(false); 
  104.             esito.setStatoInvocazioneErroreNonGestito(e);
  105.             return esito;
  106.         }
  107.         msgDiag.setPddContext(pddContext, protocolFactory);
  108.         
  109.         /* ID e tipo di implementazione PdD con cui interoperare */
  110.         String idMessageRequest = openspcoopstate.getIDMessaggioSessione();
  111.         String implementazionePdDMittente = imbustamentoRisposteMsg.getImplementazionePdDSoggettoMittente();
  112.         
  113.         //  Busta che ha causato l'invocazione di servizio (utile per costruire eventuali messaggi Errore)
  114.         Busta bustaRichiesta = imbustamentoRisposteMsg.getBusta();
  115.         //  Identificatore Porta Applicativa
  116.         RichiestaApplicativa richiestaApplicativa = imbustamentoRisposteMsg.getRichiestaApplicativa();
  117.         //  Identificatore Porta Delegata
  118.         RichiestaDelegata richiestaDelegata = imbustamentoRisposteMsg.getRichiestaDelegata();
  119.         
  120.         TipoPdD tipoPdD = TipoPdD.APPLICATIVA;
  121.         if(msgDiag.getPorta()==null) {
  122.             if(richiestaApplicativa!=null && richiestaApplicativa.getIdPortaApplicativa()!=null) {
  123.                 msgDiag.updatePorta(tipoPdD, richiestaApplicativa.getIdPortaApplicativa().getNome(), requestInfo);
  124.             }
  125.             else if(richiestaDelegata!=null && richiestaDelegata.getIdPortaDelegata()!=null) {
  126.                 msgDiag.updatePorta(TipoPdD.DELEGATA, richiestaDelegata.getIdPortaDelegata().getNome(), requestInfo);
  127.             }
  128.         }
  129.         
  130.         // ID della risposta
  131.         String idMessageResponse = imbustamentoRisposteMsg.getIDMessageResponse(); // ID associato a questa risposta
  132.         // Altri parametri:
  133.         String idModuloInAttesa = null; 
  134.         IDSoggetto identitaPdD = null;
  135.         String scenarioCooperazione = null; 
  136.         IDSoggetto soggettoFruitore = null;
  137.         IDServizio idServizio = null;
  138.         String servizioApplicativo = null;
  139.         String profiloGestione = null;
  140.         String servizioApplicativoFruitore = null;
  141.         String servizioApplicativoErogatore = null;
  142.         String idCorrelazioneApplicativa = null;
  143.         String idCorrelazioneApplicativaRisposta = null;
  144.         IDSoggetto soggettoErogatoreServizioHeaderIntegrazione = null;
  145.         
  146.         if(richiestaApplicativa!=null){
  147.             identitaPdD = richiestaApplicativa.getDominio();
  148.             idModuloInAttesa = richiestaApplicativa.getIdModuloInAttesa();
  149.             scenarioCooperazione = richiestaApplicativa.getScenario();
  150.             soggettoFruitore = richiestaApplicativa.getSoggettoFruitore();
  151.             idServizio = richiestaApplicativa.getIDServizio();
  152.             servizioApplicativo = richiestaApplicativa.getServizioApplicativo();
  153.             soggettoErogatoreServizioHeaderIntegrazione = idServizio.getSoggettoErogatore();
  154.             profiloGestione = richiestaApplicativa.getProfiloGestione();
  155.             servizioApplicativoFruitore = richiestaApplicativa.getIdentitaServizioApplicativoFruitore();
  156.             servizioApplicativoErogatore = richiestaApplicativa.getServizioApplicativo();
  157.             idCorrelazioneApplicativa = richiestaApplicativa.getIdCorrelazioneApplicativa();
  158.             idCorrelazioneApplicativaRisposta = richiestaApplicativa.getIdCorrelazioneApplicativaRisposta();
  159.         }else{
  160.             identitaPdD = richiestaDelegata.getDominio();
  161.             idModuloInAttesa = richiestaDelegata.getIdModuloInAttesa();
  162.             scenarioCooperazione = richiestaDelegata.getScenario();
  163.             soggettoFruitore = richiestaDelegata.getIdSoggettoFruitore();
  164.             idServizio = richiestaDelegata.getIdServizio();
  165.             servizioApplicativo = richiestaDelegata.getServizioApplicativo();
  166.             soggettoErogatoreServizioHeaderIntegrazione = idServizio.getSoggettoErogatore();
  167.             profiloGestione = richiestaDelegata.getProfiloGestione();
  168.             servizioApplicativoFruitore = richiestaDelegata.getServizioApplicativo();
  169.             idCorrelazioneApplicativa = richiestaDelegata.getIdCorrelazioneApplicativa();
  170.             idCorrelazioneApplicativaRisposta = richiestaDelegata.getIdCorrelazioneApplicativaRisposta();
  171.         }
  172.         
  173.         IDServizio servizioHeaderIntegrazione = null;
  174.         if(bustaRichiesta!=null){
  175.             try{
  176.                 servizioHeaderIntegrazione = IDServizioFactory.getInstance().getIDServizioFromValues(bustaRichiesta.getTipoServizio(), bustaRichiesta.getServizio(), 
  177.                         soggettoErogatoreServizioHeaderIntegrazione, bustaRichiesta.getVersioneServizio());
  178.                 // Per ricambiare il servizio in correlato per AsincronoAsimmetrico, richiestaStato
  179.                 servizioHeaderIntegrazione.setAzione(bustaRichiesta.getAzione());
  180.             }catch(Exception e){
  181.                 msgDiag.logErroreGenerico(e, "IDServizioFactory.getIDServizioFromValues"); 
  182.                 openspcoopstate.releaseResource(); 
  183.                 esito.setEsitoInvocazione(false); 
  184.                 esito.setStatoInvocazioneErroreNonGestito(e); 
  185.                 return esito;
  186.             }
  187.         }
  188.         
  189.         msgDiag.mediumDebug("Profilo di gestione ["+ImbustamentoRisposte.ID_MODULO+"] della busta: "+profiloGestione);
  190.         msgDiag.setDominio(identitaPdD);  // imposto anche il dominio nel msgDiag


  193.         //           Aggiornamento Informazioni
  194.         msgDiag.setIdMessaggioRichiesta(idMessageRequest);
  195.         msgDiag.setIdMessaggioRisposta(idMessageResponse);
  196.         msgDiag.setFruitore(soggettoFruitore);
  197.         if(servizioHeaderIntegrazione!=null){
  198.             msgDiag.setServizio(servizioHeaderIntegrazione);
  199.         }else{
  200.             msgDiag.setServizio(idServizio);
  201.         }
  202.         msgDiag.setServizioApplicativo(servizioApplicativo);
  203.         msgDiag.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  204.         msgDiag.setIdCorrelazioneRisposta(idCorrelazioneApplicativaRisposta);
  205.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO_RISPOSTE);
  206.         msgDiag.addKeywords(bustaRichiesta, true);
  207.         msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessageRequest);
  208.         msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, idMessageResponse);
  209.         msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, servizioApplicativo);
  210.         if(servizioApplicativoFruitore!=null){
  211.             msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, servizioApplicativoFruitore);
  212.         }
  213.         msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, idCorrelazioneApplicativa);
  214.         
  215.         


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




  228.         /* ------------------ Inizializzazione Contesto di gestione della Richiesta --------------- */
  229.         msgDiag.mediumDebug("Inizializzo contesto per la gestione...");
  230.         // EJBUtils (per eventuali errori)
  231.         EJBUtils ejbUtils = null;
  232.         try{
  233.             ejbUtils = new EJBUtils(identitaPdD,tipoPdD,ImbustamentoRisposte.ID_MODULO,idMessageRequest,
  234.                     idMessageResponse,Costanti.OUTBOX, openspcoopstate ,msgDiag,false,
  235.                     imbustamentoRisposteMsg.getImplementazionePdDSoggettoMittente(),
  236.                     imbustamentoRisposteMsg.getImplementazionePdDSoggettoDestinatario(),
  237.                     profiloGestione,pddContext);
  238.             ejbUtils.setSpedizioneMsgIngresso(imbustamentoRisposteMsg.getSpedizioneMsgIngresso());
  239.             ejbUtils.setRicezioneMsgRisposta(imbustamentoRisposteMsg.getRicezioneMsgRisposta());
  240.             ejbUtils.setServizioApplicativoErogatore(servizioApplicativo);
  241.         }catch(Exception e){
  242.             msgDiag.logErroreGenerico(e, "EJBUtils.new"); 
  243.             openspcoopstate.releaseResource(); 
  244.             esito.setEsitoInvocazione(false); 
  245.             esito.setStatoInvocazioneErroreNonGestito(e); 
  246.             return esito;
  247.         }
  248.         
  249.         try{
  250.             RicezioneBusteExternalErrorGenerator generatoreErrorePA = new RicezioneBusteExternalErrorGenerator(this.log, this.idModulo, requestInfo,openspcoopstate.getStatoRichiesta());
  251.             generatoreErrorePA.updateInformazioniCooperazione(soggettoFruitore, idServizio);
  252.             generatoreErrorePA.updateInformazioniCooperazione(servizioApplicativoFruitore);
  253.             generatoreErrorePA.updateTipoPdD(TipoPdD.APPLICATIVA);
  254.             ejbUtils.setGeneratoreErrorePortaApplicativa(generatoreErrorePA);
  255.         }catch(Exception e){
  256.             msgDiag.logErroreGenerico(e, "RicezioneBusteExternalErrorGenerator.instanziazione"); 
  257.             openspcoopstate.releaseResource();
  258.             esito.setEsitoInvocazione(false); 
  259.             esito.setStatoInvocazioneErroreNonGestito(e);
  260.             return esito;
  261.         }
  262.         
  263.         // Oneway versione 11
  264.         boolean oneWayVersione11 = imbustamentoRisposteMsg.isOneWayVersione11();
  265.         ejbUtils.setOneWayVersione11(oneWayVersione11);

  267.         // Gestori funzionalita'
  268.         IState statoRichiesta = openspcoopstate.getStatoRichiesta();
  269.         ProfiloDiCollaborazione profiloCollaborazione = null;
  270.         try{
  271.             profiloCollaborazione = new ProfiloDiCollaborazione(statoRichiesta,protocolFactory);
  272.         }catch(Exception e){
  273.             msgDiag.logErroreGenerico(e, "ProfiloDiCollaborazione.new");
  274.             openspcoopstate.releaseResource();
  275.             esito.setEsitoInvocazione(false); 
  276.             esito.setStatoInvocazioneErroreNonGestito(e);
  277.             return esito;
  278.         }
  279.         RepositoryBuste repositoryBuste = new RepositoryBuste(statoRichiesta, true, protocolFactory);

  281.         // Gestore Messaggi
  282.         GestoreMessaggi msgResponse = null; // Risposta inviata

  284.         //  Modalita' gestione risposta (Sincrona/Fault/Ricevute...)
  285.         // Per i profili diversi dal sincrono e' possibile impostare dove far ritornare l'errore
  286.         boolean newConnectionForResponse = false; 
  287.         if( (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())==false) &&
  288.                 (imbustamentoRisposteMsg.isStateless()==false) ) {
  289.             newConnectionForResponse = configurazionePdDManager.newConnectionForResponse();
  290.         }
  291.         ejbUtils.setReplyOnNewConnection(newConnectionForResponse);
  292.         
  293.         
  294.         // Gestione indirizzo telematico
  295.         boolean gestioneIndirizzoTelematico = false;
  296.         if(imbustamentoRisposteMsg.isStateless()==false){
  297.             gestioneIndirizzoTelematico = configurazionePdDManager.isUtilizzoIndirizzoTelematico();
  298.         }
  299.         ejbUtils.setUtilizzoIndirizzoTelematico(gestioneIndirizzoTelematico);



  303.         // Punto di inizio per la transazione.
  304.         try {

  306.             IProtocolVersionManager protocolManager = protocolFactory.createProtocolVersionManager(profiloGestione);

  308.             Busta bustaRisposta = null;
  309.             TipoOraRegistrazione tipoTempo = this.propertiesReader.getTipoTempoBusta(implementazionePdDMittente);
  310.             boolean asincronoStateless = false;
  311.             
  312.             /* ------------   Risposta Profilo Sincrono  ------------- */
  313.             if(Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione)){               
  314.                 try{
  315.                     msgDiag.mediumDebug("Generazione busta per il profilo di Collaborazione Sincrono...");
  316.                     bustaRisposta = profiloCollaborazione.sincrono_generaBustaRisposta(idMessageRequest,tipoTempo);
  317.                 }catch(Exception e){
  318.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.sincrono_generaBustaRisposta"); 
  319.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  320.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  321.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  322.                             idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,
  323.                             parseException);
  324.                     openspcoopstate.releaseResource();
  325.                     esito.setEsitoInvocazione(true); 
  326.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  327.                             "profiloCollaborazione.sincrono_generaBustaRisposta");
  328.                     return esito;
  329.                 }
  330.             }
  331.             /* ------------   Invocazione Asincrono Simmetrico ------------- */
  332.             else if(Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ){
  333.                 try{
  334.                     msgDiag.mediumDebug("Generazione busta per il profilo di Collaborazione Asincrono Simmetrico (richiesta)...");
  335.                     bustaRisposta = profiloCollaborazione.asincronoSimmetrico_getBustaRicevuta(idMessageRequest,idMessageRequest,true,tipoTempo);
  336.                     asincronoStateless = imbustamentoRisposteMsg.isStateless();
  337.                 }catch(Exception e){
  338.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.asincronoSimmetrico_getBustaRicevuta(Richiesta)"); 
  339.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  340.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  341.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  342.                             idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,
  343.                             parseException);
  344.                     openspcoopstate.releaseResource();
  345.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  346.                             "profiloCollaborazione.asincronoSimmetrico_getBustaRicevuta(Richiesta)");
  347.                     esito.setEsitoInvocazione(true); return esito;
  348.                 }
  349.             }
  350.             /* ------------  Risposta Asincrono Simmetrico ------------- */
  351.             else if(Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione) ){
  352.                 try{
  353.                     msgDiag.mediumDebug("Generazione busta per il profilo di Collaborazione Asincrono Simmetrico (risposta)...");
  354.                     bustaRisposta = profiloCollaborazione.asincronoSimmetrico_getBustaRicevuta(protocolManager.getIdCorrelazioneAsincrona(bustaRichiesta),idMessageRequest,false,tipoTempo);
  355.                     if(bustaRisposta!=null){
  356.                         bustaRisposta.setRiferimentoMsgBustaRichiedenteServizio(bustaRichiesta.getRiferimentoMessaggio());
  357.                         // La ricevuta deve avere l'azione della risposta
  358.                         bustaRisposta.setAzione(bustaRichiesta.getAzione());
  359.                     }
  360.                     asincronoStateless = imbustamentoRisposteMsg.isStateless();
  361.                 }catch(Exception e){
  362.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.asincronoSimmetrico_getBustaRicevuta(Risposta)"); 
  363.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  364.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  365.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  366.                             idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,
  367.                             parseException);
  368.                     openspcoopstate.releaseResource();
  369.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  370.                             "profiloCollaborazione.asincronoSimmetrico_getBustaRicevuta(Risposta)");
  371.                     esito.setEsitoInvocazione(true); return esito;
  372.                 }
  373.             }
  374.             /* ------------   Invocazione Asincrono Asimmetrico ------------- */
  375.             else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ){
  376.                 try{
  377.                     boolean generazionAttributiAsincroni = protocolManager.isGenerazioneInformazioniServizioCorrelatoAsincronoAsimmetrico() && 
  378.                         this.propertiesReader.isGenerazioneAttributiAsincroni(implementazionePdDMittente);
  379.                     msgDiag.mediumDebug("Generazione busta per il profilo di Collaborazione Asincrono Asimmetrico (richiesta)...");
  380.                     bustaRisposta = profiloCollaborazione.asincronoAsimmetrico_getBustaRicevuta(idMessageRequest,idMessageRequest,true,generazionAttributiAsincroni,tipoTempo);
  381.                     asincronoStateless = imbustamentoRisposteMsg.isStateless();
  382.                 }catch(Exception e){
  383.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.asincronoAsimmetrico_getBustaRicevuta(Richiesta)"); 
  384.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  385.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  386.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  387.                             idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,
  388.                             parseException);
  389.                     openspcoopstate.releaseResource();
  390.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  391.                             "profiloCollaborazione.asincronoAsimmetrico_getBustaRicevuta(Richiesta)");
  392.                     esito.setEsitoInvocazione(true); return esito;
  393.                 }
  394.             }
  395.             /* ------------  Risposta Asincrono Asimmetrico ------------- */
  396.             else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(scenarioCooperazione) ){
  397.                 try{
  398.                     msgDiag.mediumDebug("Generazione busta per il profilo di Collaborazione Asincrono Asimmetrico (richiestaStato)...");
  399.                     boolean generazionAttributiAsincroni = protocolManager.isGenerazioneInformazioniServizioCorrelatoAsincronoAsimmetrico() && 
  400.                         this.propertiesReader.isGenerazioneAttributiAsincroni(implementazionePdDMittente);
  401.                     bustaRisposta = profiloCollaborazione.asincronoAsimmetrico_getBustaRicevuta(protocolManager.getIdCorrelazioneAsincrona(bustaRichiesta),idMessageRequest,false,generazionAttributiAsincroni,tipoTempo);
  402.                     if(bustaRisposta!=null){
  403.                         bustaRisposta.setRiferimentoMsgBustaRichiedenteServizio(bustaRichiesta.getRiferimentoMessaggio());
  404.                         // La ricevuta deve avere l'azione della richiesta-stato
  405.                         bustaRisposta.setAzione(bustaRichiesta.getAzione());
  406.                     }
  407.                     asincronoStateless = imbustamentoRisposteMsg.isStateless();
  408.                 }catch(Exception e){
  409.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.asincronoAsimmetrico_getBustaRicevuta(Risposta)"); 
  410.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  411.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  412.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  413.                             idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,
  414.                             parseException);
  415.                     openspcoopstate.releaseResource(); 
  416.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  417.                             "profiloCollaborazione.asincronoAsimmetrico_getBustaRicevuta(Risposta)");
  418.                     esito.setEsitoInvocazione(true); return esito;
  419.                 }
  420.             }

  422.             /* ------ Check Busta di Risposta ------- */
  423.             msgDiag.mediumDebug("Check busta...");
  424.             if(bustaRisposta==null){
  425.                 throw new Exception("Busta di risposta ["+scenarioCooperazione+"] non generata.");
  426.             }

  428.             switch (protocolManager.getConsegnaAffidabile(bustaRisposta)) {
  429.             case ABILITATA:
  430.                 bustaRisposta.setConfermaRicezione(true);
  431.                 break;
  432.             case DISABILITATA:
  433.                 bustaRisposta.setConfermaRicezione(false);
  434.                 break;
  435.             default:
  436.                 // valore della busta di risposta
  437.                 break;
  438.             }
  439.             
  440.             switch (protocolManager.getFiltroDuplicati(bustaRisposta)) {
  441.             case ABILITATA:
  442.                 bustaRisposta.setInoltro(Inoltro.SENZA_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));
  443.                 break;
  444.             case DISABILITATA:
  445.                 bustaRisposta.setInoltro(Inoltro.CON_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.CON_DUPLICATI));
  446.                 break;
  447.             default:
  448.                 // valore della busta di risposta
  449.             }
  450.             

  452.             /* -------------- Aggiungo ID Risposta ------------------- */
  453.             bustaRisposta.setID(idMessageResponse);
  454.             msgDiag.addKeywords(bustaRisposta, false);
  455.             
  456.             
  457.             /* -------------- Aggiungo SA Applicativo Erogatore ------------------- */
  458.             bustaRisposta.setServizioApplicativoErogatore(servizioApplicativoErogatore);            


  461.             /* -------------- Imposto eventuali informazioni DirectVM ------------------- */
  462.             DirectVMProtocolInfo.setInfoFromContext(pddContext, bustaRisposta);
  463.             
  464.             
  465.             /* ------------  Spedizione Risposta   ------------- */
  466.             msgDiag.mediumDebug("Spedizione busta di risposta al modulo in uscita (RicezioneBuste/InoltroRisposte)...");
  467.             msgResponse = 
  468.                 ejbUtils.sendBustaRisposta(idModuloInAttesa,bustaRisposta,profiloGestione,
  469.                         idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);

  471.             // elimino utilizzo PdD della richiesta
  472.             msgDiag.mediumDebug("Elimino utilizzo busta dalla PdD...");
  473.             repositoryBuste.eliminaUtilizzoPdDFromInBox(idMessageRequest,asincronoStateless);


  476.             // Commit JDBC
  477.             openspcoopstate.commit();

  479.             // Aggiornamento cache messaggio
  480.             if(msgResponse!=null)
  481.                 msgResponse.addMessaggiIntoCache_readFromTable(ImbustamentoRisposte.ID_MODULO, "risposta");

  483.             // Aggiornamento cache proprietario messaggio
  484.             if(msgResponse!=null)
  485.                 msgResponse.addProprietariIntoCache_readFromTable(ImbustamentoRisposte.ID_MODULO, "risposta",idMessageRequest,false);

  487.             // Rilascio connessione
  488.             msgDiag.mediumDebug("Rilascio connessione al database...");
  489.             openspcoopstate.releaseResource();

  491.             msgDiag.mediumDebug("Lavoro Terminato.");
  492.             esito.setStatoInvocazione(EsitoLib.OK, null);
  493.             esito.setEsitoInvocazione(true); return esito; 



  497.         }catch(Throwable e){    
  498.             this.log.error("ErroreGenerale",e);
  499.             msgDiag.logErroreGenerico(e, "Generale");
  500.             
  501.             try{
  502.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,bustaRichiesta,
  503.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  504.                         idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,e,
  505.                         parseException);
  506.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"ErroreGenerale");
  507.                 esito.setEsitoInvocazione(true);
  508.             }catch(Exception er){
  509.                 msgDiag.logErroreGenerico(er,"ejbUtils.sendErroreGenerale(profiloConRisposta)");
  510.                 ejbUtils.rollbackMessage("Spedizione Errore al Mittente durante una richiesta con gestione della risposta non riuscita", esito);
  511.                 esito.setStatoInvocazioneErroreNonGestito(er);
  512.                 esito.setEsitoInvocazione(false); 
  513.             }
  514.             openspcoopstate.releaseResource(); 
  515.             return esito;
  516.         }

  518.     }
  519. }
Created with JaCoCo 0.8.8.202204050719