Sbustamento.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.openspcoop2.core.config.PortaApplicativa;
  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.constants.TipoEccezione;
  31. import org.openspcoop2.core.eccezione.details.utils.XMLUtils;
  32. import org.openspcoop2.core.id.IDPortaDelegata;
  33. import org.openspcoop2.core.id.IDServizio;
  34. import org.openspcoop2.core.id.IDServizioApplicativo;
  35. import org.openspcoop2.core.id.IDSoggetto;
  36. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  37. import org.openspcoop2.message.OpenSPCoop2Message;
  38. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  39. import org.openspcoop2.message.constants.MessageRole;
  40. import org.openspcoop2.message.utils.MessageUtilities;
  41. import org.openspcoop2.pdd.config.ClassNameProperties;
  42. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  43. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  44. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  45. import org.openspcoop2.pdd.config.RichiestaDelegata;
  46. import org.openspcoop2.pdd.core.CostantiPdD;
  47. import org.openspcoop2.pdd.core.EJBUtils;
  48. import org.openspcoop2.pdd.core.EJBUtilsConsegnaException;
  49. import org.openspcoop2.pdd.core.GestoreMessaggi;
  50. import org.openspcoop2.pdd.core.PdDContext;
  51. import org.openspcoop2.pdd.core.behaviour.Behaviour;
  52. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  53. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  54. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  55. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  56. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  57. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  58. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  59. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  60. import org.openspcoop2.protocol.engine.constants.Costanti;
  61. import org.openspcoop2.protocol.engine.driver.History;
  62. import org.openspcoop2.protocol.engine.driver.IFiltroDuplicati;
  63. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  64. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  65. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  66. import org.openspcoop2.protocol.registry.RisultatoValidazione;
  67. import org.openspcoop2.protocol.sdk.Busta;
  68. import org.openspcoop2.protocol.sdk.Eccezione;
  69. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  70. import org.openspcoop2.protocol.sdk.Integrazione;
  71. import org.openspcoop2.protocol.sdk.Riscontro;
  72. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  73. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  74. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  75. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  76. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  77. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  78. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  79. import org.openspcoop2.protocol.sdk.constants.ErroreCooperazione;
  80. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  81. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  82. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  83. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  84. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  85. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  86. import org.openspcoop2.protocol.sdk.constants.RuoloBusta;
  87. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  88. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  89. import org.openspcoop2.utils.date.DateManager;
  90. import org.openspcoop2.utils.date.DateUtils;
  91. import org.openspcoop2.utils.resources.Loader;
  92. import org.slf4j.Logger;


  95. /**
  96.  * 
  97.  * Contiene la libreria Sbustamento
  98.  * 
  99.  * @author Poli Andrea (apoli@link.it)
  100.  * @author Tronci Fabio (tronci@link.it)
  101.  * @author $Author$
  102.  * @version $Rev$, $Date$
  103.  * 
  104.  */
  105. public class Sbustamento extends GenericLib{

  107.     public static final String ID_MODULO = "Sbustamento";

  109.     /** XMLBuilder */
  110.     private RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore;


  113.     public Sbustamento(Logger log) throws GenericLibException {
  114.         super(Sbustamento.ID_MODULO, log);
  115.         inizializza();
  116.     }

  118.     @Override
  119.     protected synchronized void inizializza() throws GenericLibException {
  120.         super.inizializza();
  121.     }

  123.     @Override
  124.     public EsitoLib _onMessage(IOpenSPCoopState openspcoopstate,
  125.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  126.             MsgDiagnostico msgDiag) throws OpenSPCoopStateException {

  128.         SbustamentoMessage sbustamentoMsg = (SbustamentoMessage) openspcoopstate.getMessageLib();
  129.         
  130.         EsitoLib esito = new EsitoLib();

  132.         /* PddContext */
  133.         PdDContext pddContext = sbustamentoMsg.getPddContext();
  134.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  135.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  136.         
  137.         /* Protocol Factory */
  138.         IProtocolFactory<?> protocolFactory = null;
  139.         IProtocolVersionManager protocolManager = null;
  140.         ITraduttore traduttore = null;
  141.         try{
  142.             protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  143.             protocolManager = protocolFactory.createProtocolVersionManager(sbustamentoMsg.getRichiestaApplicativa().getProfiloGestione());
  144.             traduttore = protocolFactory.createTraduttore();
  145.         }catch(Exception e){
  146.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  147.             openspcoopstate.releaseResource();
  148.             esito.setEsitoInvocazione(false); 
  149.             esito.setStatoInvocazioneErroreNonGestito(e);
  150.             return esito;
  151.         }
  152.         
  153.         
  154.         msgDiag.setPddContext(pddContext, protocolFactory);
  155.         
  156.         /* Busta e tipo di implementazione PdD con cui interoperare */
  157.         Busta bustaRichiesta = sbustamentoMsg.getBusta();
  158.         String implementazionePdDMittente = sbustamentoMsg.getImplementazionePdDSoggettoMittente();
  159.         
  160.         /* Intrepretazione informazioni */
  161.         RichiestaApplicativa richiestaApplicativa = sbustamentoMsg.getRichiestaApplicativa();
  162.         if(richiestaApplicativa==null) {
  163.             msgDiag.logErroreGenerico("RichiestaApplicativa is null", "RichiestaApplicativa.checkNull"); 
  164.             openspcoopstate.releaseResource();
  165.             esito.setEsitoInvocazione(false); 
  166.             return esito;
  167.         }
  168.     
  169.         TipoPdD tipoPdD = TipoPdD.APPLICATIVA;
  170.         if(msgDiag.getPorta()==null) {
  171.             if(richiestaApplicativa!=null && richiestaApplicativa.getIdPortaApplicativa()!=null) {
  172.                 msgDiag.updatePorta(tipoPdD, richiestaApplicativa.getIdPortaApplicativa().getNome(), requestInfo);
  173.             }
  174.         }
  175.         
  176.         IDServizio idServizio = richiestaApplicativa.getIDServizio();
  177.         IDSoggetto idSoggettoFruitore = richiestaApplicativa.getSoggettoFruitore();
  178.         java.util.List<Eccezione> errors = sbustamentoMsg.getErrors();
  179.         IntegrationFunctionError validazione_integrationFunctionError = sbustamentoMsg.getIntegrationFunctionErrorValidazione();
  180.         boolean isMessaggioErroreProtocollo = sbustamentoMsg.isMessaggioErroreProtocollo();
  181.         boolean bustaDiServizio = sbustamentoMsg.getIsBustaDiServizio();
  182.         IDSoggetto identitaPdD = sbustamentoMsg.getRichiestaApplicativa().getDominio();
  183.         
  184.         msgDiag.setDominio(identitaPdD);  // imposto anche il dominio nel msgDiag
  185.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_SBUSTAMENTO);
  186.         msgDiag.addKeywords(bustaRichiesta, true);
  187.         if(richiestaApplicativa.getIdentitaServizioApplicativoFruitore()!=null){
  188.             msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, richiestaApplicativa.getIdentitaServizioApplicativoFruitore());
  189.         }
  190.         msgDiag.setIdCorrelazioneApplicativa(richiestaApplicativa.getIdCorrelazioneApplicativa());
  191.         msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, richiestaApplicativa.getIdCorrelazioneApplicativa());
  192.         
  193.         String profiloGestione = richiestaApplicativa.getProfiloGestione();
  194.         msgDiag.mediumDebug("Profilo di gestione ["+Sbustamento.ID_MODULO+"] della busta: "+profiloGestione);
  195.         
  196.         try{
  197.             this.generatoreErrore = new RicezioneContenutiApplicativiInternalErrorGenerator(this.log, this.idModulo, requestInfo);
  198.             this.generatoreErrore.updateInformazioniCooperazione(idSoggettoFruitore, idServizio);
  199.             this.generatoreErrore.updateTipoPdD(TipoPdD.APPLICATIVA);
  200.         }catch(Exception e){
  201.             msgDiag.logErroreGenerico(e, "RicezioneContenutiApplicativiGeneratoreErrore.instanziazione"); 
  202.             openspcoopstate.releaseResource();
  203.             esito.setEsitoInvocazione(false); 
  204.             esito.setStatoInvocazioneErroreNonGestito(e);
  205.             return esito;
  206.         }
  207.         

  209.         /* ------------------ Inizializzo stato OpenSPCoop  --------------- */
  210.         msgDiag.mediumDebug("Inizializzo stato per la gestione della richiesta...");
  211.         openspcoopstate.initResource(identitaPdD, Sbustamento.ID_MODULO,idTransazione);
  212.         registroServiziManager = registroServiziManager.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  213.         configurazionePdDManager = configurazionePdDManager.refreshState(registroServiziManager);
  214.         msgDiag.updateState(configurazionePdDManager);


  217.         /* ------------- STATO RICHIESTA E STATO RISPOSTA ------------------------------- */
  218.         //  IState statoRichiesta = openSPCoopState.getStatoRichiesta();
  219.         //  IState statoRisposta = openSPCoopState.getStatoRisposta();

  221.         /* ----------------- ID RICHIESTA ---------------------------------------------- */
  222.         String idMessageRequest = openspcoopstate.getIDMessaggioSessione();


  225.         // Aggiornamento Informazioni
  226.         msgDiag.setIdMessaggioRichiesta(idMessageRequest);
  227.         msgDiag.setFruitore(idSoggettoFruitore);
  228.         msgDiag.setServizio(idServizio);



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

  235.         // EJBUtils (per eventuali errori)
  236.         EJBUtils ejbUtils = null;
  237.         try{
  238.             ejbUtils = new EJBUtils(identitaPdD,tipoPdD,Sbustamento.ID_MODULO,idMessageRequest, idMessageRequest,Costanti.INBOX,openspcoopstate,msgDiag,false,
  239.                     sbustamentoMsg.getImplementazionePdDSoggettoMittente(),
  240.                     sbustamentoMsg.getImplementazionePdDSoggettoDestinatario(),
  241.                     profiloGestione,pddContext);
  242.         }catch(Exception e){
  243.             msgDiag.logErroreGenerico(e, "EJBUtils.new");
  244.             openspcoopstate.releaseResource(); 
  245.             esito.setEsitoInvocazione(false); 
  246.             esito.setStatoInvocazioneErroreNonGestito(e);
  247.             return esito;
  248.         }
  249.         
  250.         try{
  251.             RicezioneBusteExternalErrorGenerator generatoreErrorePA = new RicezioneBusteExternalErrorGenerator(this.log, this.idModulo, requestInfo, openspcoopstate.getStatoRichiesta());
  252.             generatoreErrorePA.updateInformazioniCooperazione(idSoggettoFruitore, idServizio);
  253.             generatoreErrorePA.updateInformazioniCooperazione(richiestaApplicativa.getIdentitaServizioApplicativoFruitore());
  254.             generatoreErrorePA.updateTipoPdD(TipoPdD.APPLICATIVA);
  255.             ejbUtils.setGeneratoreErrorePortaApplicativa(generatoreErrorePA);
  256.         }catch(Exception e){
  257.             msgDiag.logErroreGenerico(e, "RicezioneBusteExternalErrorGenerator.instanziazione"); 
  258.             openspcoopstate.releaseResource();
  259.             esito.setEsitoInvocazione(false); 
  260.             esito.setStatoInvocazioneErroreNonGestito(e);
  261.             return esito;
  262.         }

  264.         // Oneway versione 11
  265.         boolean oneWayVersione11 = sbustamentoMsg.isOneWayVersione11();
  266.         ejbUtils.setOneWayVersione11(oneWayVersione11);
  267.         ejbUtils.setPortaDiTipoStateless_esclusoOneWay11(sbustamentoMsg.isStateless());
  268.         
  269.         // Gestori funzionalita'
  270.         ProfiloDiCollaborazione profiloCollaborazione = null;
  271.         try{
  272.             profiloCollaborazione = new ProfiloDiCollaborazione(openspcoopstate.getStatoRichiesta(),protocolFactory);
  273.         }catch(Exception e){
  274.             msgDiag.logErroreGenerico(e, "ProfiloDiCollaborazione.new");
  275.             openspcoopstate.releaseResource();
  276.             esito.setEsitoInvocazione(false); 
  277.             esito.setStatoInvocazioneErroreNonGestito(e);
  278.             return esito;
  279.         }
  280.         History historyBuste = new History(openspcoopstate.getStatoRichiesta());
  281.         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true,protocolFactory);
  282.         String ricevutaAsincrona = null;

  284.         
  285.         // Gestore Messaggi
  286.         GestoreMessaggi msgRequest = new GestoreMessaggi(openspcoopstate,true, idMessageRequest,Costanti.INBOX,msgDiag,pddContext);
  287.         GestoreMessaggi msgResponse = null; // Evenutuale busta spedita indietro contenente riscontri...
  288.         msgRequest.setOneWayVersione11(oneWayVersione11);
  289.         
  290.         // Informazioni di integrazione
  291.         String servizioApplicativoFruitore = richiestaApplicativa.getIdentitaServizioApplicativoFruitore();
  292.         String idCorrelazioneApplicativa = richiestaApplicativa.getIdCorrelazioneApplicativa();

  294.                 
  295.         // Modalita' gestione risposta (Sincrona/Fault/Ricevute...)
  296.         // Per i profili diversi dal sincrono e' possibile impostare dove far ritornare l'errore
  297.         boolean newConnectionForResponse = false; 
  298.         if( (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())==false) &&
  299.                 (sbustamentoMsg.isStateless()==false) ) {
  300.             newConnectionForResponse = configurazionePdDManager.newConnectionForResponse();
  301.         }
  302.         ejbUtils.setReplyOnNewConnection(newConnectionForResponse);
  303.         
  304.         // Gestione indirizzo telematico
  305.         boolean gestioneIndirizzoTelematico = false;
  306.         if(sbustamentoMsg.isStateless()==false){
  307.             gestioneIndirizzoTelematico = configurazionePdDManager.isUtilizzoIndirizzoTelematico();
  308.         }
  309.         ejbUtils.setUtilizzoIndirizzoTelematico(gestioneIndirizzoTelematico);
  310.     
  311.         

  313.         // Indicazione se deve essere spedito lo sblocco al moduloRicezione
  314.         // non deve essere spedito SOLO se il modulo ha gia' terminato di gestire.
  315.         // Succede se:
  316.         // - e' abilitata la gestione dell'indirizzo telematico e la busta lo possiede nel mittente
  317.         // - profilo della busta non è sincrono e le risposte vengono mandate su di una nuova connessione
  318.         boolean sendSbloccoRicezioneBuste = true;
  319.         if ( configurazionePdDManager.isUtilizzoIndirizzoTelematico() && bustaRichiesta.getIndirizzoMittente()!=null &&
  320.                 (sbustamentoMsg.isStateless()==false) ){
  321.             sendSbloccoRicezioneBuste = false;
  322.         }else if( newConnectionForResponse ) {
  323.             sendSbloccoRicezioneBuste = false;
  324.         }

  326.         // Ruolo Busta ricevuta
  327.         RuoloBusta ruoloBustaRicevuta = sbustamentoMsg.getRuoloBustaRicevuta();



  331.         



  335.         // Punto di inizio per la transazione.
  336.         Busta bustaHTTPReply = null;
  337.         try{

  339.             boolean ricezioneRiscontri = false;
  340.             switch (protocolManager.getConsegnaAffidabile(bustaRichiesta)) {
  341.             case ABILITATA:
  342.                 ricezioneRiscontri = true;
  343.                 break;
  344.             case DISABILITATA:
  345.                 ricezioneRiscontri = false;
  346.                 break;
  347.             default:
  348.                 ricezioneRiscontri = this.propertiesReader.isGestioneRiscontri(implementazionePdDMittente);
  349.                 break;
  350.             }

  352.             boolean consegnaAffidabile = false;
  353.             switch (protocolManager.getConsegnaAffidabile(bustaRichiesta)) {
  354.             case ABILITATA:
  355.                 consegnaAffidabile = true;
  356.                 break;
  357.             case DISABILITATA:
  358.                 consegnaAffidabile = false;
  359.                 break;
  360.             default:
  361.                 consegnaAffidabile = this.propertiesReader.isGestioneRiscontri(implementazionePdDMittente) && bustaRichiesta.isConfermaRicezione();
  362.                 break;
  363.             }
  364.             
  365.             boolean idCollaborazione = false;
  366.             switch (protocolManager.getCollaborazione(bustaRichiesta)) {
  367.             case ABILITATA:
  368.                 idCollaborazione = true;
  369.                 break;
  370.             case DISABILITATA:
  371.                 idCollaborazione = false;
  372.                 break;
  373.             default:
  374.                 idCollaborazione = this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente) && (bustaRichiesta.getCollaborazione()!=null);
  375.                 break;
  376.             }
  377.                     
  378.             boolean consegnaInOrdine = false;
  379.             switch (protocolManager.getConsegnaInOrdine(bustaRichiesta)) {
  380.                 case ABILITATA:
  381.                     consegnaInOrdine = true;
  382.                     break;
  383.                 case DISABILITATA:
  384.                     consegnaInOrdine = false;
  385.                     break;
  386.                 default:
  387.                     boolean gestioneConsegnaInOrdineAbilitata =  this.propertiesReader.isGestioneRiscontri(implementazionePdDMittente) && 
  388.                     this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente) && 
  389.                     this.propertiesReader.isGestioneConsegnaInOrdine(implementazionePdDMittente);   
  390.                     consegnaInOrdine = gestioneConsegnaInOrdineAbilitata &&
  391.                         bustaRichiesta.getSequenza()!=-1;
  392.                     break;
  393.             }
  394.             
  395.             boolean imbustamentoFiltroDuplicatiAbilitato = false;
  396.             switch (protocolManager.getFiltroDuplicati(bustaRichiesta)) {
  397.             case ABILITATA:
  398.                 imbustamentoFiltroDuplicatiAbilitato = true;
  399.                 break;
  400.             case DISABILITATA:
  401.                 imbustamentoFiltroDuplicatiAbilitato = false;
  402.                 break;
  403.             default:
  404.                 imbustamentoFiltroDuplicatiAbilitato = (Inoltro.SENZA_DUPLICATI.equals(bustaRichiesta.getInoltro())) ||
  405.                 (this.propertiesReader.isCheckFromRegistroFiltroDuplicatiAbilitato(implementazionePdDMittente) && sbustamentoMsg.isFiltroDuplicatiRichiestoAccordo());
  406.                 break;
  407.             }
  408.             
  409.             
  410.             
  411.             
  412.             
  413.             // ------------- Controllo funzionalita di protocollo richieste siano compatibili con il protocollo -----------------------------
  414.             try{
  415.                 
  416.                 // NOTA: Usare getIntegrationServiceBinding poichè le funzionalità si riferiscono al tipo di integrazione scelta
  417.                 
  418.                 IProtocolConfiguration protocolConfiguration = protocolFactory.createProtocolConfiguration();
  419.                 if(bustaRichiesta.getProfiloDiCollaborazione()!=null && 
  420.                         !org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.UNKNOWN.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  421.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),bustaRichiesta.getProfiloDiCollaborazione())==false){
  422.                         throw new Exception("Profilo di Collaborazione ["+bustaRichiesta.getProfiloDiCollaborazione().getEngineValue()+"]");
  423.                     }
  424.                 }
  425.                 if(imbustamentoFiltroDuplicatiAbilitato){
  426.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.FILTRO_DUPLICATI)==false){
  427.                         throw new Exception(FunzionalitaProtocollo.FILTRO_DUPLICATI.getEngineValue());
  428.                     }
  429.                 }
  430.                 if(consegnaAffidabile){
  431.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.CONFERMA_RICEZIONE)==false){
  432.                         throw new Exception(FunzionalitaProtocollo.CONFERMA_RICEZIONE.getEngineValue());
  433.                     }
  434.                 }
  435.                 if(idCollaborazione){
  436.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.COLLABORAZIONE)==false){
  437.                         throw new Exception(FunzionalitaProtocollo.COLLABORAZIONE.getEngineValue());
  438.                     }
  439.                 }
  440.                 if(consegnaInOrdine){
  441.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.CONSEGNA_IN_ORDINE)==false){
  442.                         throw new Exception(FunzionalitaProtocollo.CONSEGNA_IN_ORDINE.getEngineValue());
  443.                     }
  444.                 }               
  445.             }catch(Exception e){    
  446.                 msgDiag.addKeywordErroreProcessamento(e);
  447.                 msgDiag.logPersonalizzato("protocolli.funzionalita.unsupported");
  448.                 ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL);
  449.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  450.                         ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.
  451.                         getErrore439_FunzionalitaNotSupportedByProtocol(e.getMessage(), protocolFactory),
  452.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  453.                         null);
  454.                 openspcoopstate.releaseResource();
  455.                 esito.setEsitoInvocazione(true);    
  456.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  457.                         msgDiag.getMessaggio_replaceKeywords("protocolli.funzionalita.unsupported")); 
  458.                 return esito;
  459.             }
  460.             
  461.             
  462.             
  463.             
  464.             
  465.             
  466.             
  467.             




  472.             /*   -------------- Validazione: Gestione messaggio Errore Protocollo -----------------  */ 
  473.             if(isMessaggioErroreProtocollo){

  475.                 msgDiag.mediumDebug("Gestione messaggio errore protocollo...");
  476.                 boolean msgErroreProtocolloValido = true;

  478.                 // validazione
  479.                 if(configurazionePdDManager.getTipoValidazione(implementazionePdDMittente).equals(CostantiConfigurazione.STATO_CON_WARNING_DISABILITATO) == false){

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

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

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

  500.                         // Il lavoro deve essere terminato solo in caso di Modalita Active
  501.                         if(configurazionePdDManager.getTipoValidazione(implementazionePdDMittente).equals(CostantiConfigurazione.STATO_CON_WARNING_ABILITATO) == true){
  502.                             msgErroreProtocolloValido=false;
  503.                         }  
  504.                     }

  506.                 }// -- end if not active

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

  517.                 DettaglioEccezione dettaglioEccezione = sbustamentoMsg.getDettaglioEccezione();
  518.                 if(dettaglioEccezione!=null){
  519.                     msgDiag.addKeyword(CostantiPdD.KEY_OPENSPCOOP2_DETAILS, XMLUtils.toString(dettaglioEccezione));
  520.                     msgDiag.logPersonalizzato("ricezioneBustaErroreDetails");
  521.                 }
  522.                 
  523.                 if(sendSbloccoRicezioneBuste){
  524.                     msgDiag.mediumDebug("Invio messaggio di sblocco a RicezioneBuste...");
  525.                     msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  526.                 }

  528.                 // spedizioneErrore  (se la validazione e' disattivata)
  529.                 msgDiag.mediumDebug("Invio eventuale messaggio di errore al servizio applicativo (gestione errore)...");
  530.                 Eccezione eccezioneDaInviareServizioApplicativo = 
  531.                         Eccezione.getEccezioneValidazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), protocolFactory);
  532.                 ErroreIntegrazione erroreIntegrazioneDaInviareServizioApplicativo = null;
  533.                 if(msgErroreProtocolloValido){
  534.                     if(bustaRichiesta.sizeListaEccezioni()>1){
  535.                         StringBuilder bfDescrizione = new StringBuilder();
  536.                         for(int k=0; k<bustaRichiesta.sizeListaEccezioni();k++){
  537.                             Eccezione eccLista = bustaRichiesta.getEccezione(k);
  538.                             if(eccLista.getDescrizione(protocolFactory)!=null)
  539.                                 bfDescrizione.append("["+traduttore.toString(eccLista.getCodiceEccezione(),eccLista.getSubCodiceEccezione())+"] "+eccLista.getDescrizione(protocolFactory)+"\n");
  540.                         }
  541.                         if(bfDescrizione.length()>0)
  542.                             eccezioneDaInviareServizioApplicativo.setDescrizione(bfDescrizione.toString());
  543.                     }   else {
  544.                         if(bustaRichiesta.sizeListaEccezioni()==1){
  545.                             eccezioneDaInviareServizioApplicativo = bustaRichiesta.getEccezione(0);
  546.                         }else{
  547.                             if(dettaglioEccezione!=null && dettaglioEccezione.getExceptions()!=null && dettaglioEccezione.getExceptions().sizeExceptionList()>0){
  548.                                 org.openspcoop2.core.eccezione.details.Eccezione e = dettaglioEccezione.getExceptions().getException(0);
  549.                                 if(TipoEccezione.PROTOCOL.equals(e.getType())){
  550.                                     ErroreCooperazione msgErroreCooperazione =
  551.                                             new ErroreCooperazione(e.getDescription(), traduttore.toCodiceErroreCooperazione(e.getCode()));
  552.                                     eccezioneDaInviareServizioApplicativo = new Eccezione(msgErroreCooperazione, false, Sbustamento.ID_MODULO, protocolFactory);
  553.                                 }else{
  554. //                                  erroreIntegrazioneDaInviareServizioApplicativo = 
  555. //                                          new ErroreIntegrazione(e.getDescrizione(), traduttore.toCodiceErroreIntegrazione(e.getCodiceAAA(), propertiesReader.getProprietaGestioneErrorePD(protocolManager).getFaultPrefixCode()));
  556.                                     // Se e' arrivato un details di errore di integrazione, comunque genero una busta di errore di processamento, visto che di fatto ho ricevuto questa.
  557.                                     eccezioneDaInviareServizioApplicativo = Eccezione.
  558.                                             getEccezioneProcessamento(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento(e.getDescription()), protocolFactory);
  559.                                 }
  560.                             }else{
  561.                                 eccezioneDaInviareServizioApplicativo = 
  562.                                         new Eccezione(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreCooperazione(), 
  563.                                                 false, Sbustamento.ID_MODULO, protocolFactory);
  564.                             }
  565.                         }
  566.                     }                   
  567.                 }
  568.                 else{
  569.                     if(errors.size()>1){
  570.                         StringBuilder bfDescrizione = new StringBuilder();
  571.                         for(int k=0; k<errors.size();k++){
  572.                             Eccezione error = errors.get(k);
  573.                             if(error.getDescrizione(protocolFactory)!=null)
  574.                                 bfDescrizione.append("["+traduttore.toString(error.getCodiceEccezione(),error.getSubCodiceEccezione())+"] "+error.getDescrizione(protocolFactory)+"\n");
  575.                         }
  576.                         if(bfDescrizione.length()>0)
  577.                             eccezioneDaInviareServizioApplicativo.setDescrizione(bfDescrizione.toString());
  578.                     }else{
  579.                         eccezioneDaInviareServizioApplicativo = errors.get(0);
  580.                     }
  581.                 }

  583.                 IntegrationFunctionError integrationFunctionError = validazione_integrationFunctionError;
  584.                 if(integrationFunctionError==null) {
  585.                     if( ruoloBustaRicevuta!=null && RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  586.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  587.                     }
  588.                     else {
  589.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  590.                     }
  591.                 }
  592.                 
  593.                 gestioneErroreProtocollo(configurazionePdDManager,ejbUtils,profiloCollaborazione,repositoryBuste,
  594.                         bustaRichiesta,identitaPdD,eccezioneDaInviareServizioApplicativo,erroreIntegrazioneDaInviareServizioApplicativo,
  595.                         new IDSoggetto(bustaRichiesta.getTipoMittente(),bustaRichiesta.getMittente()),
  596.                         dettaglioEccezione, protocolFactory, protocolManager, pddContext, requestInfo,
  597.                         integrationFunctionError);

  599.                 // Commit modifiche
  600.                 openspcoopstate.commit();
  601.                 
  602.                 msgDiag.mediumDebug("Rilascio connessione...");
  603.                 openspcoopstate.releaseResource();
  604.                 esito.setEsitoInvocazione(true);
  605.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"RicevutoMsgBustaErrore");
  606.                 return esito;
  607.             }













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

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

  631.                     if(validazioneConErrori){  

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

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

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

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

  661.                             // bustaOriginale per gestione errore
  662.                             Busta bustaNonValida = bustaRichiesta.newInstance();

  664.                             // Spedisco un Errore ad un mittente conosciuto...
  665.                             ejbUtils.setRollbackRichiestaInCasoErrore(false); // viene effettuato da gestioneErrore
  666.                             if(mittenteRegistrato){
  667.                                 msgDiag.mediumDebug("Invio segnalazione di errore ...");
  668.                                 IntegrationFunctionError integrationFunctionError = validazione_integrationFunctionError;
  669.                                 if(integrationFunctionError==null) {
  670.                                     if( ruoloBustaRicevuta!=null && RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  671.                                         integrationFunctionError = IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_RESPONSE;
  672.                                     }
  673.                                     else {
  674.                                         integrationFunctionError = IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_REQUEST;
  675.                                     }
  676.                                 }
  677.                                 ejbUtils.setIntegrationFunctionErrorPortaApplicativa(integrationFunctionError);
  678.                                 ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,errorsClone,
  679.                                         idCorrelazioneApplicativa,null,servizioApplicativoFruitore);
  680.                             }
  681.                             else{
  682.                                 if(sendSbloccoRicezioneBuste){
  683.                                     msgDiag.mediumDebug("Invio messaggio di sblocco a RicezioneBuste...");
  684.                                     // se il mittente non e' conosciuto sblocco solo Ricezione
  685.                                     msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  686.                                 }
  687.                             }
  688.                             ejbUtils.setRollbackRichiestaInCasoErrore(true); // viene effettuato da gestioneErrore

  690.                             Eccezione eccezioneDaInviareServizioApplicativo = null;
  691.                             if(errors.size()>1){
  692.                                 eccezioneDaInviareServizioApplicativo =
  693.                                         Eccezione.getEccezioneValidazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), protocolFactory);
  694.                                 StringBuilder bfDescrizione = new StringBuilder();
  695.                                 for(int k=0; k<errors.size();k++){
  696.                                     Eccezione error = errors.get(k);
  697.                                     if(error.getDescrizione(protocolFactory)!=null)
  698.                                         bfDescrizione.append("["+traduttore.toString(error.getCodiceEccezione(),error.getSubCodiceEccezione())+"] "+error.getDescrizione(protocolFactory)+"\n");
  699.                                 }
  700.                                 if(bfDescrizione.length()>0)
  701.                                     eccezioneDaInviareServizioApplicativo.setDescrizione(bfDescrizione.toString());
  702.                             }else{
  703.                                 eccezioneDaInviareServizioApplicativo = errors.get(0);
  704.                             }

  706.                             // GESTIONE ERRORE INTERNO
  707.                             msgDiag.mediumDebug("Invio eventuale messaggio di errore al servizio applicativo (gestione errore)...");
  708.                             IntegrationFunctionError integrationFunctionError = validazione_integrationFunctionError;
  709.                             if(integrationFunctionError==null) {
  710.                                 if( ruoloBustaRicevuta!=null && RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  711.                                     integrationFunctionError = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR;
  712.                                 }
  713.                                 else {
  714.                                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  715.                                 }
  716.                             }
  717.                             if(validazione_integrationFunctionError!=null) {
  718.                                 integrationFunctionError = validazione_integrationFunctionError;
  719.                             }
  720.                             gestioneErroreProtocollo(configurazionePdDManager, ejbUtils, profiloCollaborazione, repositoryBuste,
  721.                                     bustaNonValida, identitaPdD, eccezioneDaInviareServizioApplicativo,null,
  722.                                     identitaPdD, null, protocolFactory, protocolManager, pddContext, requestInfo, 
  723.                                     integrationFunctionError);

  725.                             // Commit modifiche
  726.                             openspcoopstate.commit();
  727.                             
  728.                             msgDiag.mediumDebug("Rilascio connessione...");
  729.                             openspcoopstate.releaseResource();
  730.                             esito.setEsitoInvocazione(true); 
  731.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  732.                                     msgDiag.getMessaggio_replaceKeywords("validazioneBusta.bustaNonCorretta"));
  733.                             return esito;
  734.                         }
  735.                     }
  736.                 }
  737.             }







  745.             /*  Stampa dei messaggi di errore non GRAVI (frammento di codice raggiunto SOLO se profilo=LineeGuida1.1) ---------------- */
  746.             // Stampa di eventuali eccezioni NON GRAVI presenti nella busta
  747.             if( (bustaRichiesta.containsEccezioniGravi()==false) && (bustaRichiesta.sizeListaEccezioni()>0) ){
  748.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, bustaRichiesta.toStringListaEccezioni(protocolFactory));
  749.                 msgDiag.logPersonalizzato("ricezioneBusta.eccezioniNonGravi");
  750.             }
  751.             // Stampa di eventuali eccezioni NON GRAVI venute fuori durante la validazione della busta
  752.             if( (Busta.containsEccezioniGravi(errors)==false) && (errors.size()>0) ){
  753.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, Busta.toStringListaEccezioni(errors, protocolFactory));
  754.                 msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, errors.size()+"" );
  755.                 msgDiag.logPersonalizzato("validazioneBusta.eccezioniNonGravi");
  756.             }










  767.             /* ------  Ricezione riscontri per il NAL (deve essere la prima attivita', poiche' effettua commit JDBC) -------- */
  768.             if(ricezioneRiscontri){
  769.                 if(bustaRichiesta.sizeListaRiscontri() > 0){ 
  770.                     for(int i=0;i<bustaRichiesta.sizeListaRiscontri();i++){  
  771.                         Riscontro r = bustaRichiesta.getRiscontro(i);
  772.                         
  773.                         msgDiag.addKeyword(CostantiPdD.KEY_ID_BUSTA_RISCONTRATA, r.getID());
  774.                         msgDiag.addKeyword(CostantiPdD.KEY_DATA_RISCONTRO, r.getOraRegistrazione().toString());
  775.                         msgDiag.logPersonalizzato("ricezioneRiscontro");
  776.                         try{
  777.                             GestoreMessaggi msgRiscontrato = new GestoreMessaggi(openspcoopstate,true, r.getID(),Costanti.OUTBOX,msgDiag,pddContext);
  778.                             msgRiscontrato.validateAndDeleteMsgOneWayRiscontrato();
  779.                         }catch(Exception e){
  780.                             msgDiag.logErroreGenerico(e, "msgRiscontrato.validateAndDeleteMsgOneWayRiscontrato("+r.getID()+")"); 
  781.                         }
  782.                     }
  783.                 }
  784.             }





  790.             /*   -------------- Controllo esistenza soggetto destinatario  ------------------ */
  791.             msgDiag.mediumDebug("Controllo appartenenza Destinazione Busta (controllo esistenza soggetto)...");
  792.             boolean existsSoggetto = false;
  793.             try{
  794.                 existsSoggetto = configurazionePdDManager.existsSoggetto(idServizio.getSoggettoErogatore(), requestInfo);
  795.             }catch(Exception e){
  796.                 if(idServizio!=null && idServizio.getSoggettoErogatore()!=null)
  797.                     msgDiag.logErroreGenerico(e,"existsSoggetto("+idServizio.getSoggettoErogatore().toString()+")");
  798.                 else
  799.                     msgDiag.logErroreGenerico(e,"existsSoggetto()");
  800.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  801.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  802.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  803.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  804.                         null);
  805.                 openspcoopstate.releaseResource();
  806.                 esito.setEsitoInvocazione(true);    
  807.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  808.                         "existsSoggetto()"); 
  809.                 return esito;
  810.             }
  811.             boolean isSoggettoVirtuale = configurazionePdDManager.isSoggettoVirtuale(idServizio.getSoggettoErogatore(), requestInfo);
  812.             if(!existsSoggetto && !isSoggettoVirtuale){
  813.                 msgDiag.logPersonalizzato("soggettoDestinatarioNonGestito");
  814.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  815.                         ErroriIntegrazione.ERRORE_451_SOGGETTO_INESISTENTE.getErroreIntegrazione(),
  816.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  817.                         null);
  818.                 openspcoopstate.releaseResource();
  819.                 esito.setEsitoInvocazione(true);    
  820.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  821.                         msgDiag.getMessaggio_replaceKeywords("soggettoDestinatarioNonGestito")); 
  822.                 return esito;
  823.             }






  830.             /* ------------------- 
  831.              *  Controllo se la busta porta Dati in caso ad es. di riscontri ... arrivera' una busta senza dati, 
  832.                          e senza profilo di collaborazione.  o comunque non devono essere considerati   --------------------- */
  833.             if(bustaDiServizio == true) { 

  835.                 msgDiag.logPersonalizzato("ricezioneBustaServizio");

  837.                 // Send Sblocco a RicezioneBuste
  838.                 if(sendSbloccoRicezioneBuste){
  839.                     msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  840.                 }
  841.                 ejbUtils.releaseInboxMessage(false);
  842.                 openspcoopstate.releaseResource();
  843.                 esito.setEsitoInvocazione(true);    
  844.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  845.                         msgDiag.getMessaggio_replaceKeywords("ricezioneBustaServizio")); 
  846.                 return esito;
  847.             } 





  853.             /* ------------ 
  854.              * Dichiarazione Busta per HTTP Reply, utilizzata SOLO se il profilo e' asincrono  o oneway.
  855.              * Contiene la dichiarazione di eventuali:
  856.              * 1) Riscontri da ritornare
  857.              * 2) Ricevute da ritornare
  858.              * ------------- */
  859.             // Variabile che sara' settata a true se si verifica una situazione in cui nella busta HTTPReply 
  860.             // vengono impostati parametri di ritorno (ricevute,riscontri.....)
  861.             boolean returnProtocolReply = false;        
  862.             TipoOraRegistrazione tipoOraRegistrazione = this.propertiesReader.getTipoTempoBusta(implementazionePdDMittente);
  863.             bustaHTTPReply = bustaRichiesta.invertiBusta(tipoOraRegistrazione,protocolFactory.createTraduttore().toString(tipoOraRegistrazione));






  870.             
  871.             
  872.             
  873.             
  874.             
  875.             
  876.             
  877.             /* ------------  Check funzionalita' richieste nel registro dei servizi che combacino con quelle presente nella busta ------------- */
  878.             // Profilo di collaborazione: controllato durante la validazione
  879.             // Filtro duplicati: controllato dal blocco di codice seguente, e casomai forzato
  880.             // Consegna in ordine: se la busta non la possiede, ma e' richiesta viene sollevata una eccezione
  881.             // Conferma ricezione: se la busta non la possiede, ma e' richiesta viene sollevata una eccezione
  882.             
  883.             if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) ){
  884.                 
  885.                 // ConfermaRicezione check
  886.                 if((this.propertiesReader.isCheckFromRegistroConfermaRicezioneAbilitato(implementazionePdDMittente) && sbustamentoMsg.isConfermaRicezioneRichiestoAccordo() &&
  887.                         (bustaRichiesta.isConfermaRicezione()==false)) && !consegnaAffidabile){
  888.                     msgDiag.logPersonalizzato("funzionalitaRichiestaAccordo.confermaRicezioneNonPresente");
  889.                     Eccezione e = Eccezione.getEccezioneValidazione(ErroriCooperazione.PROFILO_TRASMISSIONE_CONFERMA_RICEZIONE_NON_PRESENTE.getErroreCooperazione(),protocolFactory);
  890.                     ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,e,
  891.                             idCorrelazioneApplicativa,servizioApplicativoFruitore);
  892.                     openspcoopstate.releaseResource();
  893.                     esito.setEsitoInvocazione(true); 
  894.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  895.                             msgDiag.getMessaggio_replaceKeywords("funzionalitaRichiestaAccordo.confermaRicezioneNonPresente"));
  896.                     return esito;
  897.                 }
  898.                 
  899.                 if((this.propertiesReader.isCheckFromRegistroConsegnaInOrdineAbilitato(implementazionePdDMittente) && sbustamentoMsg.isConsegnaOrdineRichiestoAccordo()) &&
  900.                         (bustaRichiesta.getSequenza()<0) ){
  901.                     msgDiag.logPersonalizzato("funzionalitaRichiestaAccordo.consegnaInOrdineNonPresente");
  902.                     Eccezione e = Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_NON_GESTIBILE.getErroreCooperazione(),protocolFactory);
  903.                     ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,e,
  904.                             idCorrelazioneApplicativa,servizioApplicativoFruitore);
  905.                     openspcoopstate.releaseResource();
  906.                     esito.setEsitoInvocazione(true); 
  907.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  908.                             msgDiag.getMessaggio_replaceKeywords("funzionalitaRichiestaAccordo.consegnaInOrdineNonPresente"));
  909.                     return esito;
  910.                 }
  911.             }
  912.             
  913.             
  914.             
  915.             
  916.             
  917.             
  918.             









  928.             /* ------------  Gestione Duplicati ------------- */
  929.                         
  930.             boolean checkDuplicato = imbustamentoFiltroDuplicatiAbilitato ;         
  931.             if(checkDuplicato){
  932.                                         
  933.                 /* 
  934.                  * 1) duplicato in caso di oneWay: se confermaRicezione=true e la gestione dei riscontri e' attiva, re-invio un riscontro
  935.                  * 1b) duplicato in caso di oneWay: se confermaRicezione=false o cmq la gestione dei riscontri non è attiva, genero Errore se indicato da file property, altrimenti ritorno http 202
  936.                  * 2) duplicati in caso sincrono: genero un msg Errore
  937.                  * 3) duplicati in caso asincrono: rigenero la ricevuta
  938.                  */
  939.                 try{
  940.                     
  941.                     // Istanzio gestore filtro duplicati
  942.                     IFiltroDuplicati gestoreFiltroDuplicati = getGestoreFiltroDuplicati(this.propertiesReader, this.loader, 
  943.                             openspcoopstate, pddContext, historyBuste, repositoryBuste, oneWayVersione11);
  944.                     
  945.                     boolean oldGestioneConnessione = false;
  946.                     boolean rinegozia = false;
  947.                     if(gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && !openspcoopstate.resourceReleased()) {
  948.                         rinegozia = true;
  949. //                      System.out.println("[RICHIESTA] rilascio!!");
  950.                         msgDiag.mediumDebug("Rilascio connessione al database prima di verificare se la richiesta è duplicata ...");
  951.                         oldGestioneConnessione = ((OpenSPCoopState)openspcoopstate).isUseConnection();
  952.                         ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  953.                         openspcoopstate.commit();
  954.                         openspcoopstate.releaseResource();
  955. //                      System.out.println("[RICHIESTA] rilasciata: "+
  956. //                              (((org.openspcoop2.pdd.core.state.OpenSPCoopState)openspcoopstate).getConnectionDB()==null || ((OpenSPCoopState)openspcoopstate).getConnectionDB().isClosed()));
  957.                     }
  958.                     boolean initConnectionForDuplicate = false;
  959.                     if(!gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && openspcoopstate.resourceReleased()) {
  960.                         // il vecchio engine che verifica il filtro duplicati ha bisogno della connessione
  961.                         // inizializzo
  962.                         ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  963.                         openspcoopstate.initResource(identitaPdD, this.idModulo, idTransazione);
  964.                         historyBuste.updateState(openspcoopstate.getStatoRichiesta());
  965.                         repositoryBuste.updateState(openspcoopstate.getStatoRichiesta());
  966.                         profiloCollaborazione.updateState(openspcoopstate.getStatoRichiesta());
  967.                         ejbUtils.updateOpenSPCoopState(openspcoopstate);
  968.                         initConnectionForDuplicate = true;
  969.                     }
  970.                     
  971.                     boolean bustaDuplicata = gestoreFiltroDuplicati.isDuplicata(protocolFactory, bustaRichiesta.getID());
  972.                                     
  973.                     // BUSTA GIA' PRECEDENTEMENTE RICEVUTA
  974.                     if (bustaDuplicata){
  975.     
  976.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.RICHIESTA_DUPLICATA, "true");
  977.                         
  978.                         // Aggiorno duplicati
  979.                         msgDiag.logPersonalizzato("ricezioneBustaDuplicata.count");
  980.                         gestoreFiltroDuplicati.incrementaNumeroDuplicati(protocolFactory,bustaRichiesta.getID());
  981.                         msgDiag.logPersonalizzato("ricezioneBustaDuplicata");
  982.                         
  983.                     }else { 
  984.     
  985.                         // REGISTRAZIONE BUSTA RICEVUTA NELL'HISTORY
  986.                         gestoreFiltroDuplicati.registraBusta(protocolFactory, bustaRichiesta);
  987.                         msgDiag.logPersonalizzato("ricezioneBusta.registrazionePerFiltroDuplicati");
  988.                         
  989.                     }  
  990.                     
  991.                     if(gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && rinegozia) {
  992. //                      System.out.println("[RICHIESTA] rinegozio!!");
  993.                         msgDiag.mediumDebug("Rinegozio connessione dopo la verifica di richiesta duplicata ...");
  994.                         try{
  995.                             openspcoopstate.updateResource(idTransazione);
  996.                             ((OpenSPCoopState)openspcoopstate).setUseConnection(oldGestioneConnessione);
  997. //                          // Aggiorno risorse
  998. //                          ejbUtils.updateOpenSPCoopState(openspcoopstate);
  999. //                          msgRequest.updateOpenSPCoopState(openspcoopstate);                          
  1000. //                          System.out.println("[RICHIESTA] rinegoziata: "+
  1001. //                                  (((org.openspcoop2.pdd.core.state.OpenSPCoopState)openspcoopstate).getConnectionDB()!=null && !((OpenSPCoopState)openspcoopstate).getConnectionDB().isClosed()));
  1002.                         }catch(Exception e){
  1003.                             throw new Exception("Rinegoziazione connessione dopo la verifica di richiesta duplicata fallita: "+e.getMessage(),e);
  1004.                         } 
  1005.                     }
  1006.                     if(!gestoreFiltroDuplicati.releaseRuntimeResourceBeforeCheck() && initConnectionForDuplicate) {
  1007.                         openspcoopstate.commit();
  1008.                     }
  1009.                     
  1010.                     if (bustaDuplicata){
  1011.     
  1012.                         // 1) 
  1013.                         if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) && consegnaAffidabile){
  1014.                             //System.out.println("CASO 1");
  1015.                             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE,"generazioneRiscontro");
  1016.     
  1017.                             // Costruisco riscontro da re-inviare
  1018.                             Riscontro r = new Riscontro();
  1019.                             r.setID(bustaRichiesta.getID());
  1020.                             r.setOraRegistrazione(bustaHTTPReply.getOraRegistrazione());
  1021.                             r.setTipoOraRegistrazione(this.propertiesReader.getTipoTempoBusta(implementazionePdDMittente));
  1022.                             bustaHTTPReply.setTipoServizioRichiedenteBustaDiServizio(bustaRichiesta.getTipoServizio());
  1023.                             bustaHTTPReply.setServizioRichiedenteBustaDiServizio(bustaRichiesta.getServizio());
  1024.                             bustaHTTPReply.setVersioneServizioRichiedenteBustaDiServizio(bustaRichiesta.getVersioneServizio());
  1025.                             bustaHTTPReply.setAzioneRichiedenteBustaDiServizio(bustaRichiesta.getAzione());
  1026.                             bustaHTTPReply.addRiscontro(r);
  1027.     
  1028.                             // Re-invio Riscontro
  1029.                             msgResponse = ejbUtils.buildAndSendBustaRisposta(richiestaApplicativa.getIdModuloInAttesa(),bustaHTTPReply,
  1030.                                     MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  1031.                                             requestInfo.getProtocolRequestMessageType(),MessageRole.RESPONSE),profiloGestione,
  1032.                                             idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1033.                         }
  1034.                         // 1b) 
  1035.                         else if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) &&
  1036.                                 ( (this.propertiesReader.isGestioneRiscontri(implementazionePdDMittente)==false) || (bustaRichiesta.isConfermaRicezione()==false) )  && 
  1037.                                 ( protocolManager.isGenerazioneErroreMessaggioOnewayDuplicato() || this.propertiesReader.isGenerazioneErroreProtocolloFiltroDuplicati(implementazionePdDMittente))){
  1038.                             //System.out.println("CASO 1b");
  1039.                             ejbUtils.setRollbackRichiestaInCasoErrore_rollbackHistory(false); // non devo cancellare l'history
  1040.                             ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.CONFLICT);
  1041.                             ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1042.                                     Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory),
  1043.                                     idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1044.                             openspcoopstate.releaseResource();
  1045.                             esito.setEsitoInvocazione(true); 
  1046.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1047.                                     msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata"));
  1048.                             return esito;
  1049.                         }
  1050.     
  1051.                         // 2)
  1052.                         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  1053.                             //System.out.println("CASO 2");
  1054.                             ejbUtils.setRollbackRichiestaInCasoErrore_rollbackHistory(false); // non devo cancellare l'history
  1055.                             ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.CONFLICT);
  1056.                             ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1057.                                     Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory),
  1058.                                     idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1059.                             openspcoopstate.releaseResource();
  1060.                             esito.setEsitoInvocazione(true); 
  1061.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1062.                                     msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata"));
  1063.                             return esito;
  1064.                         }
  1065.     
  1066.                         // 3
  1067.                         else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione()) ||
  1068.                                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  1069.                             String ricevuta = null;
  1070.                             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  1071.                                 //System.out.println("CASO 3 Asincrono Simmetrico");
  1072.                                 // Asincrono Simmetrico
  1073.                         
  1074.                                 boolean ricevutaAbilitata = true; // Default SICA
  1075.                                 try{
  1076.                                     if( RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  1077.                                         msgDiag.mediumDebug("Lettura Porta Delegata ...");
  1078.                                         String idAsincronoCorrelazioneRichiesta = bustaRichiesta.getRiferimentoMessaggio();
  1079.                                         if(idAsincronoCorrelazioneRichiesta==null){
  1080.                                             idAsincronoCorrelazioneRichiesta = bustaRichiesta.getCollaborazione();
  1081.                                         }
  1082.                                         Integrazione integrazione = repositoryBuste.getInfoIntegrazioneFromOutBox(idAsincronoCorrelazioneRichiesta);
  1083.                                         IDPortaDelegata idPD = new IDPortaDelegata();
  1084.                                         idPD.setNome(integrazione.getNomePorta());
  1085.                                         PortaDelegata pd = configurazionePdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  1086.                                         ricevutaAbilitata = configurazionePdDManager.ricevutaAsincronaSimmetricaAbilitata(pd);
  1087.                                     }else{
  1088.                                         msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1089.                                         PortaApplicativa pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1090.                                         ricevutaAbilitata = configurazionePdDManager.ricevutaAsincronaSimmetricaAbilitata(pa);
  1091.                                     }
  1092.                                 }catch(Exception e){
  1093.                                     this.log.error("Errore durante l'identificazione della Porta (Delegata/Applicativa) associata alla busta: "+e.getMessage(),e);
  1094.                                 }
  1095.                                 
  1096.                                 if(ricevutaAbilitata==false){
  1097.                                     if(bustaRichiesta.getRiferimentoMessaggio()==null)
  1098.                                         ricevuta = "ricevuta di una richiesta asincrona simmetrica";
  1099.                                     else if( RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  1100.                                         ricevuta = "ricevuta di una risposta asincrona simmetrica";
  1101.                                     }
  1102.                                 }else{
  1103.                                     //System.out.println("CASO 3 Asincrono Simmetrico con ricevuta sincrona");
  1104.                                     ejbUtils.setRollbackRichiestaInCasoErrore_rollbackHistory(false); // non devo cancellare l'history
  1105.                                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.CONFLICT);
  1106.                                     ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1107.                                             Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory),
  1108.                                             idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1109.                                     openspcoopstate.releaseResource();
  1110.                                     esito.setEsitoInvocazione(true); 
  1111.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1112.                                             msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata")); 
  1113.                                     return esito;
  1114.                                 }
  1115.     
  1116.                             }else{
  1117.                                 //System.out.println("CASO 3 Asincrono Asimmetrico");
  1118.                                 //  Asincrono Asimmetrico
  1119.                                 
  1120.                                 msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1121.                                 PortaApplicativa pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1122.                                 
  1123.                                 if(configurazionePdDManager.ricevutaAsincronaAsimmetricaAbilitata(pa)==false){
  1124.                                     if(bustaRichiesta.getRiferimentoMessaggio()==null){
  1125.                                         ricevuta = "ricevuta di una richiesta asincrona asimmetrica";
  1126.                                         // ServizioCorrelato da impostare nella ricevuta asincrona
  1127.                                     }else if( RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString()) ){
  1128.                                         ricevuta = "ricevuta di una risposta asincrona asimmetrica";
  1129.                                     }
  1130.                                 }else{
  1131.                                     //System.out.println("CASO 3 Asincrono Asimmetrico con ricevuta sincrona");
  1132.                                     ejbUtils.setRollbackRichiestaInCasoErrore_rollbackHistory(false); // non devo cancellare l'history
  1133.                                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.CONFLICT);
  1134.                                     ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1135.                                             Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory),
  1136.                                             idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1137.                                     openspcoopstate.releaseResource();
  1138.                                     esito.setEsitoInvocazione(true); 
  1139.                                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1140.                                             msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata")); 
  1141.                                     return esito;
  1142.                                 }
  1143.                             }
  1144.     
  1145.                             if(ricevuta!=null){
  1146.                                 //System.out.println("CASO 3 creazione ricevuta");
  1147.                                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_RICEVUTA_ASINCRONA, ricevuta);
  1148.                                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE,"generazioneRicevutaAsincrona");
  1149.                                 
  1150.                                 // Costruisco ricevuta da re-inviare
  1151.                                 bustaHTTPReply.setVersioneServizio(bustaRichiesta.getVersioneServizio());
  1152.                                 bustaHTTPReply.setServizio(bustaRichiesta.getServizio());
  1153.                                 bustaHTTPReply.setTipoServizio(bustaRichiesta.getTipoServizio());
  1154.                                 bustaHTTPReply.setAzione(bustaRichiesta.getAzione());
  1155.                                 bustaHTTPReply.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  1156.                                 bustaHTTPReply.setRiferimentoMessaggio(bustaRichiesta.getID());
  1157.                                 // (per gli asincroni devono sempre essere presenti la collaborazione)
  1158.                                 if( this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente))
  1159.                                     bustaHTTPReply.setCollaborazione(bustaRichiesta.getCollaborazione());   
  1160.                                 if(!consegnaAffidabile){
  1161.                                     bustaHTTPReply.setConfermaRicezione(false);
  1162.                                 }
  1163.                                 if(imbustamentoFiltroDuplicatiAbilitato){
  1164.                                     bustaHTTPReply.setInoltro(Inoltro.SENZA_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));
  1165.                                 }
  1166.                                 //  Re-invio Ricevuta
  1167.                                 msgResponse = ejbUtils.buildAndSendBustaRisposta(richiestaApplicativa.getIdModuloInAttesa(),bustaHTTPReply,
  1168.                                         MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  1169.                                                 requestInfo.getProtocolRequestMessageType(),MessageRole.RESPONSE),profiloGestione,
  1170.                                                 idCorrelazioneApplicativa,servizioApplicativoFruitore); 
  1171.                             }
  1172.     
  1173.                         }
  1174.     
  1175.                         // 4
  1176.                         else{
  1177.                             //System.out.println("Caso 4");
  1178.                             if( protocolManager.isGenerazioneErroreMessaggioOnewayDuplicato() || this.propertiesReader.isGenerazioneErroreProtocolloFiltroDuplicati(implementazionePdDMittente)){
  1179.                                 //System.out.println("Caso 4, spedizione errore di segnalazione id duplicato");
  1180.                                 ejbUtils.setRollbackRichiestaInCasoErrore_rollbackHistory(false); // non devo cancellare l'history
  1181.                                 ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.CONFLICT);
  1182.                                 ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1183.                                         Eccezione.getEccezioneValidazione(ErroriCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO.getErroreCooperazione(),protocolFactory),
  1184.                                         idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1185.                                 openspcoopstate.releaseResource();
  1186.                                 esito.setEsitoInvocazione(true); 
  1187.                                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1188.                                         msgDiag.getMessaggio_replaceKeywords("ricezioneBustaDuplicata")); 
  1189.                                 return esito;
  1190.                             }
  1191.     
  1192.                             // Msg di Sblocco per il modulo 'RicezioneBuste'
  1193.                             if(sendSbloccoRicezioneBuste){
  1194.                                 //System.out.println("Caso 4, solo segnalazione errore");
  1195.                                 msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  1196.                             }
  1197.     
  1198.                         } 
  1199.                         //System.out.println("RELEASE");
  1200.                         // Devo rilasciare il messaggio, senza cancellarlo dalla history.
  1201.                         ejbUtils.releaseInboxMessage(false,true);
  1202.     
  1203.                         // Aggiornamento cache messaggio risposta
  1204.                         if(msgResponse!=null)
  1205.                             msgResponse.addMessaggiIntoCache_readFromTable(Sbustamento.ID_MODULO, "risposta in seguito a busta duplicata");
  1206.     
  1207.                         // Aggiornamento cache proprietario messaggio risposta
  1208.                         if(msgResponse!=null)
  1209.                             msgResponse.addProprietariIntoCache_readFromTable(Sbustamento.ID_MODULO, "risposta in seguito a busta duplicata",idMessageRequest,false);
  1210.     
  1211.                         openspcoopstate.releaseResource();
  1212.                         esito.setEsitoInvocazione(true);  
  1213.                         esito.setStatoInvocazione(EsitoLib.OK,null); 
  1214.                         return esito;
  1215.     
  1216.                     }
  1217.                     
  1218.                 }catch(Exception e) {
  1219.                     msgDiag.logErroreGenerico(e, "GestioneHistoryBusteRicevute");
  1220.                     ejbUtils.rollbackMessage("Gestione dell'history delle buste ricevute non riuscita", esito);
  1221.                     openspcoopstate.releaseResource(); 
  1222.                     esito.setEsitoInvocazione(false); 
  1223.                     esito.setStatoInvocazioneErroreNonGestito(e); 
  1224.                     return esito;
  1225.                 } 
  1226.                 
  1227.                 pddContext.removeObject(org.openspcoop2.core.constants.Costanti.OPENSPCOOP_STATE);
  1228.             }
  1229.             
  1230.             








  1239.             /* ------------  Invio Riscontri (solo per profilo OneWay) ------------- */
  1240.             if(consegnaAffidabile){
  1241.                 msgDiag.mediumDebug("Gestione eventuali riscontri da inviare...");
  1242.                 boolean senza_piggy_backing = true;
  1243.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione()) ) {    
  1244.                     if ( (senza_piggy_backing) && (bustaRichiesta.isConfermaRicezione())){

  1246.                         // Riscontro ad hoc
  1247.                         Riscontro r = new Riscontro();
  1248.                         r.setID(bustaRichiesta.getID());
  1249.                         r.setOraRegistrazione(bustaHTTPReply.getOraRegistrazione());
  1250.                         r.setTipoOraRegistrazione(this.propertiesReader.getTipoTempoBusta(implementazionePdDMittente));
  1251.                         bustaHTTPReply.addRiscontro(r);
  1252.                         bustaHTTPReply.setTipoServizioRichiedenteBustaDiServizio(bustaRichiesta.getTipoServizio());
  1253.                         bustaHTTPReply.setServizioRichiedenteBustaDiServizio(bustaRichiesta.getServizio());
  1254.                         bustaHTTPReply.setAzioneRichiedenteBustaDiServizio(bustaRichiesta.getAzione());

  1256.                         returnProtocolReply = true;
  1257.                     }
  1258.                 }
  1259.             }









  1269.             /* ------------  Collaborazione e Sequenza  ------------- */
  1270.             // check Funzionalita' fornita solo con OneWay
  1271.             // Sequenza: deve essere abilitata la consegna affidabile + la collaborazione e infine la consegna in ordine
  1272.             if( consegnaInOrdine &&
  1273.                     (org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione())==false)  ){

  1275.                 msgDiag.mediumDebug("Gestione vincoli consegna in ordine...");

  1277.                 msgDiag.logPersonalizzato("consegnaInOrdine.profiloDiversoOneway");
  1278.                 Eccezione e = Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_NON_SUPPORTATA.getErroreCooperazione(),protocolFactory);
  1279.                 ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,e,
  1280.                         idCorrelazioneApplicativa,servizioApplicativoFruitore);
  1281.                 openspcoopstate.releaseResource();
  1282.                 esito.setEsitoInvocazione(true); 
  1283.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1284.                         msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.profiloDiversoOneway"));
  1285.                 return esito;
  1286.             }








  1295.             /* ------------  Profilo di Collaborazione  ------------- */
  1296.             String scenarioCooperazione = null;
  1297.             boolean generazioneMsgOK = false;
  1298.             boolean existsPA = true;
  1299.             PortaApplicativa pa = null;
  1300.             ServizioApplicativo sa = null;
  1301.             Integrazione integrazioneAsincrona = null;
  1302.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(bustaRichiesta.getProfiloDiCollaborazione())) { 

  1304.                 msgDiag.mediumDebug("Gestione profilo di collaborazione OneWay...");

  1306.                 scenarioCooperazione = Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO;

  1308.                 //  check esistenza porta applicativa
  1309.                 msgDiag.mediumDebug("Gestione profilo di collaborazione OneWay (existsPA)...");
  1310.                 try{
  1311.                     existsPA=configurazionePdDManager.existsPA(richiestaApplicativa, requestInfo);
  1312.                 }catch(Exception e){
  1313.                     msgDiag.logErroreGenerico(e, "existsPA(richiestaApplicativa,oneway)");
  1314.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1315.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1316.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1317.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1318.                             null);
  1319.                     openspcoopstate.releaseResource();
  1320.                     esito.setEsitoInvocazione(true); 
  1321.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"existsPA(richiestaApplicativa,oneway)");
  1322.                     return esito;
  1323.                 }
  1324.                 if(!existsPA){
  1325.                     String nomePA = "";
  1326.                     if(richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null){
  1327.                         nomePA = " ["+richiestaApplicativa.getIdPortaApplicativa().getNome()+"]";
  1328.                     }
  1329.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "Porta Applicativa"+nomePA+" non esistente");
  1330.                     msgDiag.logPersonalizzato("portaApplicativaNonEsistente");
  1331.                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.API_IN_UNKNOWN);
  1332.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1333.                             ErroriIntegrazione.ERRORE_450_PA_INESISTENTE.getErroreIntegrazione(),
  1334.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1335.                             null);
  1336.                     openspcoopstate.releaseResource();
  1337.                     esito.setEsitoInvocazione(true);
  1338.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1339.                             msgDiag.getMessaggio_replaceKeywords("portaApplicativaNonEsistente"));
  1340.                     return esito;
  1341.                 }
  1342.                 
  1343.                 // Lettura Porta Applicativa
  1344.                 msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1345.                 pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1346.                 
  1347.                 // Soggetto Virtuale
  1348.                 boolean soggettoVirtuale = false;
  1349.                 try{
  1350.                     if(richiestaApplicativa.getDominio()!=null) {
  1351.                         soggettoVirtuale = configurazionePdDManager.isSoggettoVirtuale( richiestaApplicativa.getDominio(), requestInfo );
  1352.                     }
  1353.                 }catch(Exception e){
  1354.                     msgDiag.logErroreGenerico(e, "isSoggettoVirtuale(richiestaApplicativa,oneway)");
  1355.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1356.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1357.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1358.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1359.                             null);
  1360.                     openspcoopstate.releaseResource();
  1361.                     esito.setEsitoInvocazione(true); 
  1362.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"isSoggettoVirtuale(richiestaApplicativa,oneway)");
  1363.                     return esito;
  1364.                 }
  1365.                 
  1366.                 // Modalita di trasmissione sincrona/asincrona
  1367.                 if(!soggettoVirtuale) {
  1368.                     if(configurazionePdDManager.isModalitaStateless(pa, bustaRichiesta.getProfiloDiCollaborazione())==false){
  1369.                         generazioneMsgOK = true;
  1370.                     }else{
  1371.                         generazioneMsgOK = false;
  1372.                     }
  1373.                 }
  1374.                 else {
  1375.                     generazioneMsgOK = true;
  1376.                 }

  1378.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione())) { 

  1380.                 msgDiag.mediumDebug("Gestione profilo di collaborazione Sincrono...");

  1382.                 if(bustaRichiesta.getRiferimentoMessaggio()!=null &&
  1383.                         (ruoloBustaRicevuta==null || !ruoloBustaRicevuta.equals(RuoloBusta.RICHIESTA))
  1384.                         ){
  1385.                     msgDiag.logPersonalizzato("ricezioneRispostaSincrona");
  1386.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1387.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1388.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1389.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1390.                             null);
  1391.                     openspcoopstate.releaseResource();
  1392.                     esito.setEsitoInvocazione(true); 
  1393.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1394.                             msgDiag.getMessaggio_replaceKeywords("ricezioneRispostaSincrona"));
  1395.                     return esito;
  1396.                 }

  1398.                 scenarioCooperazione = Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO;

  1400.                 //  check esistenza porta applicativa
  1401.                 msgDiag.mediumDebug("Gestione profilo di collaborazione Sincrono (existsPA)...");
  1402.                 try{
  1403.                     existsPA=configurazionePdDManager.existsPA(richiestaApplicativa, requestInfo);
  1404.                 }catch(Exception e){
  1405.                     msgDiag.logErroreGenerico(e, "existsPA(richiestaApplicativa,sincrono)");
  1406.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1407.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1408.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1409.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1410.                             null);
  1411.                     openspcoopstate.releaseResource();
  1412.                     esito.setEsitoInvocazione(true); 
  1413.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"existsPA(richiestaApplicativa,sincrono)");
  1414.                     return esito;
  1415.                 }
  1416.                 if(!existsPA){
  1417.                     String nomePA = "";
  1418.                     if(richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null){
  1419.                         nomePA = " ["+richiestaApplicativa.getIdPortaApplicativa().getNome()+"]";
  1420.                     }
  1421.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "Porta Applicativa"+nomePA+" non esistente");
  1422.                     msgDiag.logPersonalizzato("portaApplicativaNonEsistente");
  1423.                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.API_IN_UNKNOWN);
  1424.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1425.                             ErroriIntegrazione.ERRORE_450_PA_INESISTENTE.getErroreIntegrazione(),
  1426.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1427.                             null);
  1428.                     openspcoopstate.releaseResource();
  1429.                     esito.setEsitoInvocazione(true); 
  1430.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1431.                             msgDiag.getMessaggio_replaceKeywords("portaApplicativaNonEsistente"));
  1432.                     return esito;
  1433.                 }

  1435.                 // Lettura Porta Applicativa
  1436.                 msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1437.                 pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1438.                 
  1439.                 msgDiag.mediumDebug("Gestione profilo di collaborazione Sincrono (registra busta ricevuta)...");
  1440.                 try{
  1441.                     profiloCollaborazione.registraBustaRicevuta(bustaRichiesta.getID());
  1442.                 }catch(Exception e){
  1443.                     msgDiag.logErroreGenerico(e, "profiloCollaborazione.registraBustaRicevuta("+bustaRichiesta.getID()+")");
  1444.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1445.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1446.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1447.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1448.                             null);
  1449.                     openspcoopstate.releaseResource();
  1450.                     esito.setEsitoInvocazione(true); 
  1451.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"profiloCollaborazione.registraBustaRicevuta("+bustaRichiesta.getID()+")");
  1452.                     return esito;
  1453.                 } 

  1455.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) { 

  1457.                 if(openspcoopstate.resourceReleased()) {
  1458.                     // il vecchio engine che verifica il filtro duplicati ha bisogno della connessione
  1459.                     // inizializzo
  1460.                     ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  1461.                     openspcoopstate.initResource(identitaPdD, this.idModulo, idTransazione);
  1462.                     profiloCollaborazione.updateState(openspcoopstate.getStatoRichiesta());
  1463.                     repositoryBuste.updateState(openspcoopstate.getStatoRichiesta());
  1464.                 }
  1465.                 
  1466.                 // Richiesta Asincrona
  1467.                 if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString())){

  1469.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico richiesta...");

  1471.                     scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO;

  1473.                     //  check esistenza porta applicativa
  1474.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico richiesta (existsPA)...");
  1475.                     try{
  1476.                         existsPA=configurazionePdDManager.existsPA(richiestaApplicativa, requestInfo);
  1477.                     }catch(Exception e){
  1478.                         msgDiag.logErroreGenerico(e, "existsPA(richiestaApplicativa,asincronoSimmetricoRichiesta)");
  1479.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1480.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1481.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1482.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1483.                                 null);
  1484.                         openspcoopstate.releaseResource();
  1485.                         esito.setEsitoInvocazione(true); 
  1486.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"existsPA(richiestaApplicativa,asincronoSimmetricoRichiesta)"); 
  1487.                         return esito;
  1488.                     }
  1489.                     if(!existsPA){
  1490.                         String nomePA = "";
  1491.                         if(richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null){
  1492.                             nomePA = " ["+richiestaApplicativa.getIdPortaApplicativa().getNome()+"]";
  1493.                         }
  1494.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "Porta Applicativa"+nomePA+" non esistente");
  1495.                         msgDiag.logPersonalizzato("portaApplicativaNonEsistente");
  1496.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.API_IN_UNKNOWN);
  1497.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1498.                                 ErroriIntegrazione.ERRORE_450_PA_INESISTENTE.getErroreIntegrazione(),
  1499.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1500.                                 null);
  1501.                         openspcoopstate.releaseResource();
  1502.                         esito.setEsitoInvocazione(true); 
  1503.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1504.                                 msgDiag.getMessaggio_replaceKeywords("portaApplicativaNonEsistente"));
  1505.                         return esito;
  1506.                     }

  1508.                     
  1509.                     // Lettura Porta Applicativa
  1510.                     msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1511.                     pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1512.                     
  1513.                     
  1514.                     //  gestione ricevute asincrone
  1515.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico richiesta (controllo ricevuta abilitata)...");
  1516.                     try{
  1517.                         richiestaApplicativa.setRicevutaAsincrona(configurazionePdDManager.ricevutaAsincronaSimmetricaAbilitata(pa));
  1518.                     }catch(Exception e){
  1519.                         msgDiag.logErroreGenerico(e, "ricevutaAsincronaSimmetricaAbilitata(pa)");
  1520.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1521.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1522.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1523.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1524.                                 null);
  1525.                         openspcoopstate.releaseResource();
  1526.                         esito.setEsitoInvocazione(true); 
  1527.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"ricevutaAsincronaSimmetricaAbilitata(pa)"); 
  1528.                         return esito;
  1529.                     }

  1531.                     //  deve essere generato un msg OK se non e' abilitata la funzionalita' di ricevuta asincrona
  1532.                     // Modalita di trasmissione stateless/stateful
  1533.                     if(configurazionePdDManager.isModalitaStateless(pa,bustaRichiesta.getProfiloDiCollaborazione())==false){
  1534.                         generazioneMsgOK = !richiestaApplicativa.isRicevutaAsincrona();
  1535.                     }
  1536.                     else{
  1537.                         generazioneMsgOK = false;
  1538.                     }

  1540.                     // registrazione
  1541.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico richiesta (registrazione busta ricevuta)...");
  1542.                     try{
  1543.                         String tipoServizioCorrelato = null;
  1544.                         String servizioCorrelato = null;
  1545.                         Integer versioneServizioCorrelato = null;
  1546.                         if(bustaRichiesta.getTipoServizioCorrelato()!=null &&
  1547.                                 bustaRichiesta.getServizioCorrelato() != null){
  1548.                             tipoServizioCorrelato = bustaRichiesta.getTipoServizioCorrelato();
  1549.                             servizioCorrelato = bustaRichiesta.getServizioCorrelato();
  1550.                             if(bustaRichiesta.getVersioneServizioCorrelato()!=null && bustaRichiesta.getVersioneServizioCorrelato().intValue()>0) {
  1551.                                 versioneServizioCorrelato = bustaRichiesta.getVersioneServizioCorrelato();
  1552.                             }
  1553.                             else {
  1554.                                 versioneServizioCorrelato = 1;
  1555.                             }
  1556.                         }else{
  1557.                             RisultatoValidazione validazione = registroServiziManager.validaServizio(idSoggettoFruitore,idServizio,null);
  1558.                             if( (validazione==null) || (validazione.getServizioRegistrato()==false))
  1559.                                 throw new Exception("Servizio ["+idServizio.toString()+"] non esiste nel registro dei servizi");
  1560.                             if( (validazione.getServizioCorrelato()==null) || (validazione.getTipoServizioCorrelato()==null) || (validazione.getVersioneServizioCorrelato()==null) )
  1561.                                 throw new Exception("Servizio ["+idServizio.toString()+"] non possiede un servizio correlato associato");
  1562.                             tipoServizioCorrelato = validazione.getTipoServizioCorrelato();
  1563.                             servizioCorrelato = validazione.getServizioCorrelato();
  1564.                             versioneServizioCorrelato = validazione.getVersioneServizioCorrelato();
  1565.                         }

  1567.                         String collaborazione = null;
  1568.                         // (per gli asincroni devono sempre essere presenti)
  1569.                         if(this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente))
  1570.                             collaborazione = bustaRichiesta.getCollaborazione();
  1571.                         profiloCollaborazione.asincronoSimmetrico_registraRichiestaRicevuta(bustaRichiesta.getID(),collaborazione,
  1572.                                 tipoServizioCorrelato,servizioCorrelato,versioneServizioCorrelato,richiestaApplicativa.isRicevutaAsincrona(),
  1573.                                 this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  1574.                     }catch(Exception e){
  1575.                         msgDiag.logErroreGenerico(e, "SalvataggioInformazioniProfiloAsincronoSimmetrico");
  1576.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1577.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1578.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1579.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1580.                                 null);
  1581.                         openspcoopstate.releaseResource();
  1582.                         esito.setEsitoInvocazione(true); 
  1583.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"SalvataggioInformazioniProfiloAsincronoSimmetrico"); 
  1584.                         return esito;
  1585.                     } 

  1587.                     // RicevutaAsincrona immediata
  1588.                     if(generazioneMsgOK){
  1589.                         returnProtocolReply = true;
  1590.                         bustaHTTPReply.setServizio(bustaRichiesta.getServizio());
  1591.                         bustaHTTPReply.setTipoServizio(bustaRichiesta.getTipoServizio());
  1592.                         bustaHTTPReply.setAzione(bustaRichiesta.getAzione());
  1593.                         bustaHTTPReply.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  1594.                         bustaHTTPReply.setRiferimentoMessaggio(bustaRichiesta.getID());
  1595.                         // (per gli asincroni devono sempre essere presenti)
  1596.                         if(this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente))
  1597.                             bustaHTTPReply.setCollaborazione(bustaRichiesta.getCollaborazione());
  1598.                         if(!consegnaAffidabile){
  1599.                             bustaHTTPReply.setConfermaRicezione(false);
  1600.                         }
  1601.                         if(imbustamentoFiltroDuplicatiAbilitato){
  1602.                             bustaHTTPReply.setInoltro(Inoltro.SENZA_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));
  1603.                         }
  1604.                     }
  1605.                 }else{

  1607.                     // Risposta Asincrona
  1608.                     if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  1610.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico risposta...");
  1611.                         scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA;

  1613.                     }
  1614.                     //  Ricevuta alla richiesta.
  1615.                     else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())){

  1617.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico ricevuta richiesta asincrona...");
  1618.                         ricevutaAsincrona = "ricevuta di una richiesta asincrona simmetrica";

  1620.                     }
  1621.                     //  Ricevuta alla risposta.
  1622.                     else if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  1624.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico ricevuta risposta asincrona ...");
  1625.                         ricevutaAsincrona = "ricevuta di una risposta asincrona simmetrica";

  1627.                     }
  1628.                     else{

  1630.                         msgDiag.logPersonalizzato("profiloAsincrono.flussoRicevutaRichiestaRispostaNonCorretto");
  1631.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1632.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1633.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1634.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1635.                                 null);
  1636.                         openspcoopstate.releaseResource();
  1637.                         esito.setEsitoInvocazione(true); 
  1638.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1639.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincrono.flussoRicevutaRichiestaRispostaNonCorretto")); 
  1640.                         return esito;

  1642.                     }

  1644.                     //  Raccolgo dati consegna per Risposta o Ricevute
  1645.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico risposta (raccolta dati per consegna risposta)...");
  1646.                     try{
  1647.                         if(ricevutaAsincrona==null){
  1648.                             integrazioneAsincrona = profiloCollaborazione.asincronoSimmetrico_getDatiConsegnaRisposta(protocolManager.getIdCorrelazioneAsincrona(bustaRichiesta));
  1649.                         }else{
  1650.                             integrazioneAsincrona = profiloCollaborazione.asincronoSimmetrico_getDatiConsegnaRicevuta(bustaRichiesta.getRiferimentoMessaggio());
  1651.                         }
  1652.                     }catch(Exception e){
  1653.                         msgDiag.logErroreGenerico(e, "RaccoltaDatiIntegrazioneProfiloAsincronoSimmetrico");
  1654.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1655.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1656.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1657.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1658.                                 null);
  1659.                         openspcoopstate.releaseResource();
  1660.                         esito.setEsitoInvocazione(true); 
  1661.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"RaccoltaDatiIntegrazioneProfiloAsincronoSimmetrico"); 
  1662.                         return esito;
  1663.                     } 

  1665.                 }   

  1667.             } else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())) {   
  1668.                 
  1669.                 if(openspcoopstate.resourceReleased()) {
  1670.                     // il vecchio engine che verifica il filtro duplicati ha bisogno della connessione
  1671.                     // inizializzo
  1672.                     ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  1673.                     openspcoopstate.initResource(identitaPdD, this.idModulo, idTransazione);
  1674.                     profiloCollaborazione.updateState(openspcoopstate.getStatoRichiesta());
  1675.                     repositoryBuste.updateState(openspcoopstate.getStatoRichiesta());
  1676.                 }
  1677.                 
  1678.                 //  Richiesta Asincrona
  1679.                 if(RuoloBusta.RICHIESTA.equals(ruoloBustaRicevuta.toString())){
  1680.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta...");

  1682.                     scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO;

  1684.                     //  check esistenza porta applicativa
  1685.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta (existsPA)...");
  1686.                     try{
  1687.                         existsPA=configurazionePdDManager.existsPA(richiestaApplicativa, requestInfo);
  1688.                     }catch(Exception e){
  1689.                         msgDiag.logErroreGenerico(e, "existsPA(richiestaApplicativa,asincronoAsimmetricoRichiesta)");
  1690.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1691.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1692.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1693.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1694.                                 null);
  1695.                         openspcoopstate.releaseResource();
  1696.                         esito.setEsitoInvocazione(true); 
  1697.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"existsPA(richiestaApplicativa,asincronoAsimmetricoRichiesta)"); 
  1698.                         return esito;
  1699.                     }
  1700.                     if(!existsPA){
  1701.                         String nomePA = "";
  1702.                         if(richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null){
  1703.                             nomePA = " ["+richiestaApplicativa.getIdPortaApplicativa().getNome()+"]";
  1704.                         }
  1705.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "Porta Applicativa"+nomePA+" non esistente");
  1706.                         msgDiag.logPersonalizzato_prefix("(Richiesta) ", "portaApplicativaNonEsistente");
  1707.                         ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.API_IN_UNKNOWN);
  1708.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1709.                                 ErroriIntegrazione.ERRORE_450_PA_INESISTENTE.getErroreIntegrazione(),
  1710.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1711.                                 null);
  1712.                         openspcoopstate.releaseResource();
  1713.                         esito.setEsitoInvocazione(true);
  1714.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1715.                                 "(Richiesta) "+msgDiag.getMessaggio_replaceKeywords("portaApplicativaNonEsistente")); 
  1716.                         return esito;
  1717.                     }

  1719.                     // Lettura Porta Applicativa
  1720.                     msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1721.                     pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1722.                     
  1723.                     // assegnamento servizioApplicativo
  1724.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta (lettura servizio applicativo)...");
  1725.                     String [] servizioApplicativo = null;
  1726.                     try{
  1727.                         servizioApplicativo = configurazionePdDManager.getServiziApplicativi(pa);
  1728.                         if(servizioApplicativo==null)
  1729.                             throw new Exception("Servizio applicativo non esistente");
  1730.                         if(servizioApplicativo.length>1)
  1731.                             throw new Exception("profilo non utilizzabile con una porta applicativa a cui sono stati associati piu' servizi applicativi");
  1732.                         if(servizioApplicativo.length<=0)
  1733.                             throw new Exception("Non sono stati associati servizi applicativi alla porta applicativa");
  1734.                     }
  1735.                     catch(Exception e){
  1736.                         msgDiag.logErroreGenerico(e, "LetturaServizioApplicatiProfiloAsincronoAsimmetrico");
  1737.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1738.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1739.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1740.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1741.                                 null);
  1742.                         openspcoopstate.releaseResource();
  1743.                         esito.setEsitoInvocazione(true);  
  1744.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"LetturaServizioApplicatiProfiloAsincronoAsimmetrico"); 
  1745.                         return esito;
  1746.                     }
  1747.                     richiestaApplicativa.setServizioApplicativo(servizioApplicativo[0]);


  1750.                     //  Lettura Servizio Applicativo
  1751.                     msgDiag.mediumDebug("Lettura Servizio Applicativo ...");
  1752.                     try{
  1753.                         IDServizioApplicativo idSA = new IDServizioApplicativo();
  1754.                         idSA.setNome(servizioApplicativo[0]);
  1755.                         idSA.setIdSoggettoProprietario(richiestaApplicativa.getIDServizio().getSoggettoErogatore());
  1756.                         sa = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo );
  1757.                     }catch(DriverConfigurazioneNotFound e){
  1758.                         msgDiag.logErroreGenerico("Servizio applicativo ["+servizioApplicativo[0]+"] non esistente", "getServizioApplicativoProfiloAsincronoAsimmetrico");
  1759.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1760.                                 ErroriIntegrazione.ERRORE_453_SA_INESISTENTE.getErroreIntegrazione(),
  1761.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1762.                                 null);
  1763.                         openspcoopstate.releaseResource();
  1764.                         esito.setEsitoInvocazione(true); 
  1765.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"Servizio applicativo ["+servizioApplicativo[0]+"] non esistente"); 
  1766.                         return esito;
  1767.                     }
  1768.                     catch(Exception e){
  1769.                         msgDiag.logErroreGenerico(e, "getServizioApplicativoProfiloAsincronoAsimmetrico");
  1770.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1771.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1772.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1773.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1774.                                 null);
  1775.                         openspcoopstate.releaseResource();
  1776.                         esito.setEsitoInvocazione(true); 
  1777.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"getServizioApplicativoProfiloAsincronoAsimmetrico"); 
  1778.                         return esito;
  1779.                     }
  1780.                     
  1781.                     
  1782.                     // check esistenza ConsegnaRispostaAsincrona
  1783.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta (exists ConsegnaRispostAsincrona)...");
  1784.                     boolean existsConsegnaRispostaAsincrona = false;
  1785.                     msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, sa.getNome());
  1786.                     try{
  1787.                         existsConsegnaRispostaAsincrona = configurazionePdDManager.existsConsegnaRispostaAsincrona(sa);
  1788.                     }catch(Exception e){
  1789.                         msgDiag.logErroreGenerico(e, "existsConsegnaRispostaAsincrona_ProfiloAsincronoAsimmetrico");
  1790.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1791.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1792.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1793.                                 null);
  1794.                         openspcoopstate.releaseResource();
  1795.                         esito.setEsitoInvocazione(true); 
  1796.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"existsConsegnaRispostaAsincrona_ProfiloAsincronoAsimmetrico"); 
  1797.                         return esito;
  1798.                     }
  1799.                     if (existsConsegnaRispostaAsincrona == false){
  1800.                         msgDiag.logPersonalizzato("profiloAsincronoAsimmetrico.saSenzaRispostaAsincrona");
  1801.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1802.                                 ErroriIntegrazione.ERRORE_411_RICEZIONE_CONTENUTI_ASINCRONA_RICHIESTA.getErroreIntegrazione(),
  1803.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1804.                                 null);
  1805.                         openspcoopstate.releaseResource();
  1806.                         esito.setEsitoInvocazione(true); 
  1807.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1808.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincronoAsimmetrico.saSenzaRispostaAsincrona")); 
  1809.                         return esito;
  1810.                     }

  1812.                     // check esistenza ServizioCorrelato associato al Servizio
  1813.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta (servizio correlato)...");
  1814.                     if(sbustamentoMsg.getServizioCorrelato()==null || sbustamentoMsg.getTipoServizioCorrelato()==null){
  1815.                         msgDiag.logPersonalizzato("profiloAsincronoAsimmetrico.servizioCorrelatoNonEsistente");
  1816.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1817.                                 ErroriIntegrazione.ERRORE_408_SERVIZIO_CORRELATO_NON_TROVATO.getErroreIntegrazione(),
  1818.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1819.                                 null);
  1820.                         openspcoopstate.releaseResource();
  1821.                         esito.setEsitoInvocazione(true); 
  1822.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1823.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincronoAsimmetrico.servizioCorrelatoNonEsistente")); 
  1824.                         return esito;
  1825.                     }

  1827.                     //  gestione ricevute asincrone
  1828.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta (ricevuta abilitata)...");
  1829.                     try{
  1830.                         richiestaApplicativa.setRicevutaAsincrona(configurazionePdDManager.ricevutaAsincronaAsimmetricaAbilitata(pa));
  1831.                     }catch(Exception e){
  1832.                         msgDiag.logErroreGenerico(e, "ricevutaAsincronaAsimmetricaAbilitata(pa)");
  1833.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1834.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1835.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1836.                                 null);
  1837.                         openspcoopstate.releaseResource();
  1838.                         esito.setEsitoInvocazione(true); 
  1839.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"ricevutaAsincronaAsimmetricaAbilitata(pa)"); 
  1840.                         return esito;
  1841.                     }

  1843.                     // deve essere generato un msg OK se non e' abilitata la funzionalita' di ricevuta asincrona
  1844.                     // Modalita di trasmissione stateless/stateful
  1845.                     if(configurazionePdDManager.isModalitaStateless(pa, bustaRichiesta.getProfiloDiCollaborazione())==false){
  1846.                         generazioneMsgOK = !richiestaApplicativa.isRicevutaAsincrona();
  1847.                     }
  1848.                     else{
  1849.                         generazioneMsgOK = false;
  1850.                     }

  1852.                     // registrazione
  1853.                     msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta (registrazione busta ricevuta)...");
  1854.                     try{
  1855.                         String collaborazione = null;
  1856.                         // (per gli asincroni devono sempre essere presenti)
  1857.                         if(this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente))
  1858.                             collaborazione = bustaRichiesta.getCollaborazione();
  1859.                         profiloCollaborazione.asincronoAsimmetrico_registraRichiestaRicevuta(bustaRichiesta.getID(),collaborazione,
  1860.                                 sbustamentoMsg.getTipoServizioCorrelato(),sbustamentoMsg.getServizioCorrelato(),sbustamentoMsg.getVersioneServizioCorrelato(),
  1861.                                 richiestaApplicativa.isRicevutaAsincrona(),
  1862.                                 this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  1863.                     }catch(Exception e){
  1864.                         msgDiag.logErroreGenerico(e, "SalvataggioInformazioniProfiloAsincronoAsimmetrico");
  1865.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1866.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1867.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1868.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1869.                                 null);
  1870.                         openspcoopstate.releaseResource();
  1871.                         esito.setEsitoInvocazione(true); 
  1872.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"SalvataggioInformazioniProfiloAsincronoAsimmetrico"); 
  1873.                         return esito;
  1874.                     } 

  1876.                     // RicevutaAsincrona immediata
  1877.                     if(generazioneMsgOK){
  1878.                         returnProtocolReply = true;
  1879.                         bustaHTTPReply.setServizio(bustaRichiesta.getServizio());
  1880.                         bustaHTTPReply.setTipoServizio(bustaRichiesta.getTipoServizio());

  1882.                         // PRODUZIONE tipo e nome Servizio Correlato
  1883.                         if( protocolManager.isGenerazioneInformazioniServizioCorrelatoAsincronoAsimmetrico() && 
  1884.                                 this.propertiesReader.isGenerazioneAttributiAsincroni(implementazionePdDMittente)){
  1885.                             bustaHTTPReply.setServizioCorrelato(sbustamentoMsg.getServizioCorrelato());
  1886.                             bustaHTTPReply.setTipoServizioCorrelato(sbustamentoMsg.getTipoServizioCorrelato());
  1887.                         }

  1889.                         bustaHTTPReply.setAzione(bustaRichiesta.getAzione());
  1890.                         bustaHTTPReply.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO);
  1891.                         bustaHTTPReply.setRiferimentoMessaggio(bustaRichiesta.getID());

  1893.                         // (per gli asincroni devono sempre essere presenti)
  1894.                         if(this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente))
  1895.                             bustaHTTPReply.setCollaborazione(bustaRichiesta.getCollaborazione());

  1897.                         if(!consegnaAffidabile){
  1898.                             bustaHTTPReply.setConfermaRicezione(false);
  1899.                         }
  1900.                         if(imbustamentoFiltroDuplicatiAbilitato){
  1901.                             bustaHTTPReply.setInoltro(Inoltro.SENZA_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));    
  1902.                         }
  1903.                     }
  1904.                 }else{

  1906.                     // Risposta Asincrona
  1907.                     if(RuoloBusta.RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  1909.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta Stato...");
  1910.                         scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING;

  1912.                         IDServizio idServizioOriginale = null;
  1913.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico richiesta Stato (lettura servizio originale)...");
  1914.                         try{
  1915.                             idServizioOriginale = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta(protocolManager.getIdCorrelazioneAsincrona(bustaRichiesta));
  1916.                         }catch(Exception e){
  1917.                             msgDiag.logErroreGenerico(e, "profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta");
  1918.                             ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1919.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1920.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  1921.                                     idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1922.                                     null);
  1923.                             openspcoopstate.releaseResource();
  1924.                             esito.setEsitoInvocazione(true); 
  1925.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRisposta"); 
  1926.                             return esito;
  1927.                         } 

  1929.                         // ripristino richiestaApplicativa con valori del servizio di richiesta (sovrascrivendo i valori del servizio correlato)
  1930.                         IDServizio idServizioRichiesta = 
  1931.                                 IDServizioFactory.getInstance().getIDServizioFromValues(idServizioOriginale.getTipo(), idServizioOriginale.getNome(), 
  1932.                                         richiestaApplicativa.getIDServizio().getSoggettoErogatore(), idServizioOriginale.getVersione());
  1933.                         idServizioRichiesta.setAzione(idServizioOriginale.getAzione());
  1934.                         idServizioRichiesta.setTipologia(richiestaApplicativa.getIDServizio().getTipologia());
  1935.                         idServizioRichiesta.setUriAccordoServizioParteComune(richiestaApplicativa.getIDServizio().getUriAccordoServizioParteComune());
  1936.                         richiestaApplicativa.updateIDServizio(idServizioRichiesta);
  1937.                         
  1938.                         // check esistenza porta applicativa
  1939.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico richiesta Stato (existsPA)...");
  1940.                         try{
  1941.                             existsPA=configurazionePdDManager.existsPA(richiestaApplicativa, requestInfo);
  1942.                         }catch(Exception e){
  1943.                             msgDiag.logErroreGenerico(e, "existsPA(richiestaApplicativa,asincronoAsimmetricoRichiestaStato)");
  1944.                             ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1945.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1946.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),
  1947.                                     idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  1948.                                     null);
  1949.                             openspcoopstate.releaseResource();
  1950.                             esito.setEsitoInvocazione(true);  
  1951.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"existsPA(richiestaApplicativa,asincronoAsimmetricoRichiestaStato)"); 
  1952.                             return esito;
  1953.                         }
  1954.                         if(!existsPA){
  1955.                             String nomePA = "";
  1956.                             if(richiestaApplicativa.getIdPortaApplicativa()!=null && richiestaApplicativa.getIdPortaApplicativa().getNome()!=null){
  1957.                                 nomePA = " ["+richiestaApplicativa.getIdPortaApplicativa().getNome()+"]";
  1958.                             }
  1959.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, "Porta Applicativa"+nomePA+" non esistente");
  1960.                             msgDiag.logPersonalizzato_prefix("(RichiestaStato) ", "portaApplicativaNonEsistente");
  1961.                             ejbUtils.setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError.API_IN_UNKNOWN);
  1962.                             ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1963.                                     ErroriIntegrazione.ERRORE_450_PA_INESISTENTE.getErroreIntegrazione(),
  1964.                                     idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  1965.                                     null);
  1966.                             openspcoopstate.releaseResource();
  1967.                             esito.setEsitoInvocazione(true);  
  1968.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1969.                                     "(RichiestaStato) "+msgDiag.getMessaggio_replaceKeywords("portaApplicativaNonEsistente")); 
  1970.                             return esito;
  1971.                         }
  1972.                         
  1973.                         
  1974.                         // Lettura Porta Applicativa
  1975.                         msgDiag.mediumDebug("Lettura Porta Applicativa ...");
  1976.                         pa = configurazionePdDManager.getPortaApplicativaSafeMethod(richiestaApplicativa.getIdPortaApplicativa(), requestInfo);
  1977.                         

  1979.                     }
  1980.                     //  Ricevuta alla richiesta.
  1981.                     else if(RuoloBusta.RICEVUTA_RICHIESTA.equals(ruoloBustaRicevuta.toString())){

  1983.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico ricevuta richiesta...");
  1984.                         ricevutaAsincrona = "ricevuta di una richiesta asincrona asimmetrica";

  1986.                     }
  1987.                     //  Ricevuta alla risposta.
  1988.                     else if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){

  1990.                         msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoSimmetrico ricevuta risposta...");
  1991.                         ricevutaAsincrona = "ricevuta di una risposta asincrona asimmetrica contenente l'esito della richiesta stato";

  1993.                     }
  1994.                     else{

  1996.                         msgDiag.logPersonalizzato("profiloAsincrono.flussoRicevutaRichiestaRispostaNonCorretto");
  1997.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  1998.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1999.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  2000.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,null,
  2001.                                 null);
  2002.                         openspcoopstate.releaseResource();
  2003.                         esito.setEsitoInvocazione(true);  
  2004.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  2005.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincrono.flussoRicevutaRichiestaRispostaNonCorretto")); 
  2006.                         return esito;

  2008.                     }


  2011.                     //  Raccolgo dati consegna per Ricevute
  2012.                     try{
  2013.                         if(ricevutaAsincrona!=null){
  2014.                             msgDiag.mediumDebug("Gestione profilo di collaborazione AsincronoAsimmetrico ricevuta (raccolta dati consegna per ricevuta)...");
  2015.                             integrazioneAsincrona = profiloCollaborazione.asincronoAsimmetrico_getDatiConsegnaRicevuta(bustaRichiesta.getRiferimentoMessaggio());
  2016.                         }
  2017.                     }catch(Exception e){
  2018.                         msgDiag.logErroreGenerico(e, "RaccoltaDatiIntegrazioneProfiloAsincronoAsimmetrico");
  2019.                         ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2020.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2021.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  2022.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2023.                                 null);
  2024.                         openspcoopstate.releaseResource();
  2025.                         esito.setEsitoInvocazione(true); 
  2026.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"RaccoltaDatiIntegrazioneProfiloAsincronoAsimmetrico"); 
  2027.                         return esito;
  2028.                     } 

  2030.                 }   

  2032.             }else{

  2034.                 // profilo non conosciuto
  2035.                 Eccezione ecc = 
  2036.                         Eccezione.getEccezioneValidazione(ErroriCooperazione.PROFILO_COLLABORAZIONE_SCONOSCIUTO.
  2037.                                 getErroreProfiloCollaborazioneSconosciuto(bustaRichiesta.getProfiloDiCollaborazioneValue()),
  2038.                                     protocolFactory);
  2039.                 msgDiag.addKeyword(CostantiPdD.KEY_ECCEZIONI, ecc.toString(protocolFactory));
  2040.                 msgDiag.addKeyword(CostantiPdD.KEY_NUMERO_ECCEZIONI, "1");
  2041.                 msgDiag.logPersonalizzato("validazioneBusta.bustaNonCorretta");
  2042.                 ejbUtils.sendAsRispostaBustaErroreValidazione(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,ecc,
  2043.                         idCorrelazioneApplicativa,servizioApplicativoFruitore);
  2044.                 openspcoopstate.releaseResource();
  2045.                 esito.setEsitoInvocazione(true); 
  2046.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  2047.                         msgDiag.getMessaggio_replaceKeywords("validazioneBusta.bustaNonCorretta")); 
  2048.                 return esito;

  2050.             }   











  2062.             /*   -------------- Creazione dati consegna applicativa per profili asincroni  ------------------ */
  2063.             msgDiag.mediumDebug("Gestione profilo di collaborazione Asincrono, raccolta dati consegna...");
  2064.             RichiestaDelegata consegnaApplicativaAsincrona = null;
  2065.             PortaDelegata pdConsegnaApplicativaAsincrona = null;
  2066.             ServizioApplicativo saConsegnaApplicativaAsincrona = null;
  2067.             try{
  2068.                 if(integrazioneAsincrona!=null){
  2069.                     IDSoggetto soggettoFruitoreRichiestaAsincrona = new IDSoggetto(bustaRichiesta.getTipoDestinatario(),bustaRichiesta.getDestinatario());
  2070.                     IDSoggetto soggettoErogatoreRichiestaAsincrona = new IDSoggetto(bustaRichiesta.getTipoMittente(),bustaRichiesta.getMittente());
  2071.                     IDServizio servizioRichiestaAsincrona = 
  2072.                         IDServizioFactory.getInstance().getIDServizioFromValues(bustaRichiesta.getTipoServizio(),bustaRichiesta.getServizio(), 
  2073.                                 soggettoErogatoreRichiestaAsincrona, bustaRichiesta.getVersioneServizio()); 
  2074.                     servizioRichiestaAsincrona.setAzione(bustaRichiesta.getAzione());
  2075.                     ProprietaErroreApplicativo proprietaErroreApplAsincrono = this.propertiesReader.getProprietaGestioneErrorePD(protocolManager);
  2076.                     proprietaErroreApplAsincrono.setDominio(identitaPdD.getCodicePorta());
  2077.                     proprietaErroreApplAsincrono.setIdModulo(Sbustamento.ID_MODULO);
  2078.                     IDPortaDelegata idPD = configurazionePdDManager.getIDPortaDelegata(integrazioneAsincrona.getNomePorta(), requestInfo, protocolFactory);
  2079.                     consegnaApplicativaAsincrona = new RichiestaDelegata(idPD,
  2080.                             integrazioneAsincrona.getServizioApplicativo(),null,proprietaErroreApplAsincrono,identitaPdD);
  2081.                     consegnaApplicativaAsincrona.setScenario(scenarioCooperazione);
  2082.                     consegnaApplicativaAsincrona.setProfiloGestione(profiloGestione);
  2083.                     
  2084.                     pdConsegnaApplicativaAsincrona = configurazionePdDManager.getPortaDelegata(consegnaApplicativaAsincrona.getIdPortaDelegata(), requestInfo);
  2085.                     try{
  2086.                         IDServizioApplicativo idSA = new IDServizioApplicativo();
  2087.                         idSA.setNome(consegnaApplicativaAsincrona.getServizioApplicativo());
  2088.                         idSA.setIdSoggettoProprietario(soggettoFruitoreRichiestaAsincrona);
  2089.                         saConsegnaApplicativaAsincrona = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo);
  2090.                     }catch(Exception e){
  2091.                         if( !(e instanceof DriverConfigurazioneNotFound) || 
  2092.                                 !(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(consegnaApplicativaAsincrona.getServizioApplicativo())) ){
  2093.                             throw e;
  2094.                         }
  2095.                     }
  2096.                     
  2097.                     configurazionePdDManager.aggiornaProprietaGestioneErrorePD(proprietaErroreApplAsincrono,saConsegnaApplicativaAsincrona);
  2098.                     

  2100.                     // gestione ricevute asincrone
  2101.                     if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  2102.                         // asincrono simmetrico
  2103.                         consegnaApplicativaAsincrona.setRicevutaAsincrona(configurazionePdDManager.ricevutaAsincronaSimmetricaAbilitata(pdConsegnaApplicativaAsincrona));
  2104.                     } else {
  2105.                         // asincrono asimmetrico, se sono in un contesto di richiestaStato pooling, devo sempre ritornare il contenuto applicativo nella richiesta
  2106.                         if(RuoloBusta.RICEVUTA_RISPOSTA.equals(ruoloBustaRicevuta.toString())){
  2107.                             consegnaApplicativaAsincrona.setRicevutaAsincrona(true);
  2108.                         }else{
  2109.                             consegnaApplicativaAsincrona.setRicevutaAsincrona(configurazionePdDManager.ricevutaAsincronaAsimmetricaAbilitata(pdConsegnaApplicativaAsincrona));
  2110.                         }
  2111.                     }

  2113.                     // Ricevute Asincrone Simmetriche e Asimmetriche 
  2114.                     if(ricevutaAsincrona!=null){
  2115.                         //  di default la ricezioneAsincrona viene utilizzata.
  2116.                         //  Non deve essere utilizzata solo nel caso di richiesta con profilo AsincronoSimmetrico 
  2117.                         consegnaApplicativaAsincrona.setUtilizzoConsegnaAsincrona(true);
  2118.                         if(profiloCollaborazione.asincrono_spedizioneRichiestaInCorso(bustaRichiesta.getRiferimentoMessaggio()) 
  2119.                                 && org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(bustaRichiesta.getProfiloDiCollaborazione())){
  2120.                             consegnaApplicativaAsincrona.setUtilizzoConsegnaAsincrona(false);
  2121.                         }

  2123.                         //  Il modulo in attesa e' il servizio di ricezioneContenutiApplicativi
  2124.                         consegnaApplicativaAsincrona.setIdModuloInAttesa(integrazioneAsincrona.getIdModuloInAttesa());
  2125.                     }

  2127.                     // Risposta Asincrona Simmetrica
  2128.                     else{
  2129.                         // Il modulo in attesa e' il servizio di ricezioneBuste
  2130.                         consegnaApplicativaAsincrona.setIdModuloInAttesa(richiestaApplicativa.getIdModuloInAttesa());

  2132.                         //  elimino busta per profilo se non devo attendere una risposta applicativa (altrimenti la elimino quando prendo la busta per la ricevuta )
  2133.                         if(consegnaApplicativaAsincrona.isRicevutaAsincrona() == false){
  2134.                             profiloCollaborazione.eliminaBustaInviata(protocolManager.getIdCorrelazioneAsincrona(bustaRichiesta),true);
  2135.                         }

  2137.                         //  di default la ricezioneAsincrona viene utilizzata.
  2138.                         //  Non deve essere utilizzata solo nel caso di richiesta con profilo AsincronoSimmetrico 
  2139.                         // qua siamo nella risposta asincrona
  2140.                         consegnaApplicativaAsincrona.setUtilizzoConsegnaAsincrona(true);

  2142.                         //  deve essere generato un msg OK se non e' abilitata la funzionalita' di ricevuta asincrona
  2143.                         if(configurazionePdDManager.isModalitaStateless(pdConsegnaApplicativaAsincrona, bustaRichiesta.getProfiloDiCollaborazione())==false){
  2144.                             generazioneMsgOK = !consegnaApplicativaAsincrona.isRicevutaAsincrona();
  2145.                         }
  2146.                         else{
  2147.                             generazioneMsgOK = false;
  2148.                         }
  2149.                         
  2150.                         //  RicevutaAsincrona immediata
  2151.                         if(generazioneMsgOK){
  2152.                             returnProtocolReply = true;
  2153.                             bustaHTTPReply.setServizio(bustaRichiesta.getServizio());
  2154.                             bustaHTTPReply.setTipoServizio(bustaRichiesta.getTipoServizio());
  2155.                             bustaHTTPReply.setAzione(bustaRichiesta.getAzione());
  2156.                             bustaHTTPReply.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  2157.                             bustaHTTPReply.setRiferimentoMessaggio(bustaRichiesta.getID());
  2158.                             // (per gli asincroni devono sempre essere presenti)
  2159.                             if(this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDMittente))
  2160.                                 bustaHTTPReply.setCollaborazione(bustaRichiesta.getCollaborazione());
  2161.                             bustaHTTPReply.setRiferimentoMsgBustaRichiedenteServizio(bustaRichiesta.getRiferimentoMessaggio());

  2163.                             if(!consegnaAffidabile){
  2164.                                 bustaHTTPReply.setConfermaRicezione(false);
  2165.                             }
  2166.                             if(imbustamentoFiltroDuplicatiAbilitato){
  2167.                                 bustaHTTPReply.setInoltro(Inoltro.SENZA_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));    
  2168.                             }
  2169.                         }


  2172.                     }
  2173.                 }   
  2174.             }catch(Exception e){
  2175.                 msgDiag.logErroreGenerico(e, "GestioneConsegnaProfiloAsincrono");
  2176.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2177.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2178.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  2179.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2180.                         null);
  2181.                 openspcoopstate.releaseResource();  
  2182.                 esito.setEsitoInvocazione(true); 
  2183.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"GestioneConsegnaProfiloAsincrono"); 
  2184.                 return esito;
  2185.             } 
















  2202.             /* ------------  Scenario di Cooperazione  ------------- */
  2203.             msgDiag.mediumDebug("Impostazione scenario di cooperazione...");
  2204.             try{
  2205.                 richiestaApplicativa.setScenario(scenarioCooperazione);
  2206.                 repositoryBuste.aggiornaInfoIntegrazioneIntoInBox_Scenario(bustaRichiesta.getID(), scenarioCooperazione);
  2207.                 ejbUtils.setScenarioCooperazione(scenarioCooperazione);
  2208.             }catch(Exception e){
  2209.                 msgDiag.logErroreGenerico(e, "repository.aggiornaInfoIntegrazioneIntoInBox_Scenario");
  2210.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2211.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2212.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),
  2213.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2214.                         null);
  2215.                 openspcoopstate.releaseResource();
  2216.                 esito.setEsitoInvocazione(true); 
  2217.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"repository.aggiornaInfoIntegrazioneIntoInBox_Scenario"); 
  2218.                 return esito;
  2219.             } 




  2224.             /* ---------  
  2225.              * Spedizione contenuto applicativi con
  2226.              * - ConsegnaContenutiApplicativiMessage al modulo ConsegnaContenutiApplicativi
  2227.              * - RicezioneContenutiApplicativiMessage al modulo RicezioneContenutiApplicativi
  2228.              * -------- */
  2229.             Behaviour behaviour = null;
  2230.             try{
  2231.                 if(ricevutaAsincrona==null){
  2232.                     if(consegnaApplicativaAsincrona==null){
  2233.                         msgDiag.mediumDebug("Invio messaggio a ConsegnaContenutiApplicativi...");
  2234.                         behaviour = ejbUtils.sendToConsegnaContenutiApplicativi(requestInfo,richiestaApplicativa,bustaRichiesta,msgRequest,pa,repositoryBuste);
  2235.                         if(ejbUtils.isGestioneStatelessConIntegrationManager()){
  2236.                             generazioneMsgOK = true;
  2237.                             sendSbloccoRicezioneBuste = true;
  2238.                         }
  2239.                     }else{
  2240.                         msgDiag.mediumDebug("Invio messaggio a ConsegnaContenutiApplicativi (consegnaAsincrona)...");
  2241.                         ejbUtils.sendToConsegnaContenutiApplicativi_gestioneMessaggio(consegnaApplicativaAsincrona,bustaRichiesta,msgRequest,saConsegnaApplicativaAsincrona);
  2242.                     }   
  2243.                 }else{
  2244.                     if(consegnaApplicativaAsincrona.isRicevutaAsincrona()){
  2245.                         // Aggiorno l'id di sessione al riferimento Messaggio, id utilizzato dal servizio
  2246.                         // RicezioneContenutiApplicativi per l'attesa di una risposta
  2247.                         msgDiag.mediumDebug("Invio messaggio asincrono a Ricezione/Consegna ContenutiApplicativi...");
  2248.                         ejbUtils.updateIdSessione(bustaRichiesta.getRiferimentoMessaggio());

  2250.                         // Spedizione contenuto ricevuta applicativa
  2251.                         msgRequest = ejbUtils.sendRispostaApplicativa(consegnaApplicativaAsincrona,pdConsegnaApplicativaAsincrona,saConsegnaApplicativaAsincrona);

  2253.                         // ripristino old id sessione
  2254.                         ejbUtils.updateIdSessione(idMessageRequest);
  2255.                     }
  2256.                 }
  2257.                 // La gestione puo' avvenire per diversi servizi applicativi di una stessa PA.
  2258.                 // Quindi il servizio applicativo non e' identificavile in questo modulo. Lo sara' in Consegna contenuti applicativi.
  2259.                 // Viene effettuato il log di correlazione in EJBUtils
  2260.                 msgDiag.setServizioApplicativo(null);

  2262.             }catch(EJBUtilsConsegnaException e){
  2263.                 msgDiag.logPersonalizzato_custom(e.getMessaggio(), e.getLivello(), e.getCodice());
  2264.                 if(e.getIntegrationFunctionError()!=null) {
  2265.                     ejbUtils.setIntegrationFunctionErrorPortaApplicativa(e.getIntegrationFunctionError());
  2266.                 }
  2267.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2268.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2269.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),
  2270.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2271.                         null);
  2272.                 openspcoopstate.releaseResource();
  2273.                 esito.setEsitoInvocazione(true); 
  2274.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,e.getMessaggio()); 
  2275.                 return esito;
  2276.             }
  2277.             catch(Exception e){
  2278.                 //viene loggato dentro ejbUtils. msgDiag.errorOpenSPCoop("Abilitazione modulo ConsegnaMessaggio non riuscita (Busta "+bustaRichiesta.getID()+"): "+e.getMessage());

  2280.                 ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2281.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2282.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),
  2283.                         idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2284.                         null);
  2285.                 openspcoopstate.releaseResource();
  2286.                 esito.setEsitoInvocazione(true); 
  2287.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"Abilitazione modulo ConsegnaMessaggio non riuscita (Busta "+bustaRichiesta.getID()+"): "+e.getMessage()); 
  2288.                 return esito;
  2289.             }








  2298.             
  2299.             
  2300.             







  2308.             /* ------------  Gestione Risposta verso RicezioneBuste ------------- */
  2309.             // se il profilo e' oneWay, 
  2310.             // AsincronoSimmetrico o AsincronoAsimmetricoRichiesta senza gestione della ricevuta applicativa 
  2311.             // viene generata una risposta inviata al modulo.
  2312.             boolean behaviourResponseTo = behaviour!=null && behaviour.isResponseTo();
  2313.             if(  generazioneMsgOK || behaviourResponseTo ) {
  2314.                 try{
  2315.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.DATA_PRESA_IN_CARICO, 
  2316.                             DateUtils.getSimpleDateFormatMs().format(DateManager.getDate()));
  2317.                     
  2318.                     if(behaviourResponseTo){
  2319.                     
  2320.                         // Invio risposta richiesta dalla configurazione di behaviour
  2321.                         OpenSPCoop2Message msgReplyTo = null;
  2322.                         Busta bustaReplyTo = null;
  2323.                         if(behaviour.getResponseTo()!=null){
  2324.                             msgReplyTo = behaviour.getResponseTo().getMessage();
  2325.                             bustaReplyTo = behaviour.getResponseTo().getBusta();
  2326.                         }
  2327.                         if(msgReplyTo==null){
  2328.                             msgReplyTo = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  2329.                                     requestInfo.getProtocolRequestMessageType(),MessageRole.RESPONSE);
  2330.                         }
  2331.                         msgDiag.mediumDebug("Invio messaggio a Ricezione/Consegna ContenutiApplicativi (Behaviour)...");
  2332.                         msgResponse = ejbUtils.buildAndSendBustaRisposta(richiestaApplicativa.getIdModuloInAttesa(),
  2333.                                 bustaReplyTo,
  2334.                                 msgReplyTo,profiloGestione,
  2335.                                 idCorrelazioneApplicativa,servizioApplicativoFruitore);
  2336.                         
  2337.                     }else if( returnProtocolReply == false){
  2338.                         // Invio sblocco se e' attesa una risposta dal modulo
  2339.                         // Se non e' abilitato la risposta su di una nuova connessione, e l'indirizzo telematico 
  2340.                         // non e' abilitato o cmq non presente, allora devo inviare lo sblocco
  2341.                         if(sendSbloccoRicezioneBuste){
  2342.                             msgDiag.mediumDebug("Invio messaggio di sblocco a RicezioneBuste...");
  2343.                             msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  2344.                         }
  2345.                     }
  2346.                     else{
  2347.                         // Invio risposta immediata in seguito alla richiesta ricevuta
  2348.                         msgDiag.mediumDebug("Invio messaggio a Ricezione/Consegna ContenutiApplicativi...");
  2349.                         msgResponse = ejbUtils.buildAndSendBustaRisposta(richiestaApplicativa.getIdModuloInAttesa(),bustaHTTPReply,
  2350.                                 MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  2351.                                         requestInfo.getProtocolRequestMessageType(),MessageRole.RESPONSE),profiloGestione,
  2352.                                         idCorrelazioneApplicativa,servizioApplicativoFruitore);
  2353.                     }
  2354.                 }catch(Exception e){
  2355.                     msgDiag.logErroreGenerico(e, "GenerazioneMsgOK(Riscontro/Ricevuta/Sblocco)");
  2356.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2357.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2358.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),
  2359.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2360.                             null);
  2361.                     openspcoopstate.releaseResource();
  2362.                     esito.setEsitoInvocazione(true); 
  2363.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"GenerazioneMsgOK(Riscontro/Ricevuta/Sblocco)"); 
  2364.                     return esito;
  2365.                 }
  2366.             }else if( ricevutaAsincrona !=null ){
  2367.                 try{
  2368.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.DATA_PRESA_IN_CARICO, 
  2369.                             DateUtils.getSimpleDateFormatMs().format(DateManager.getDate()));
  2370.                     
  2371.                     //  Invio sblocco
  2372.                     // Se non e' abilitato la risposta su di una nuova connessione, e l'indirizzo telematico 
  2373.                     // non e' abilitato o cmq non presente, allora devo inviare lo sblocco
  2374.                     if(sendSbloccoRicezioneBuste){
  2375.                         msgDiag.mediumDebug("Invio messaggio di sblocco a RicezioneBuste (ricevuta asincrona)...");
  2376.                         msgResponse = ejbUtils.sendSbloccoRicezioneBuste(richiestaApplicativa.getIdModuloInAttesa());
  2377.                     }
  2378.                 }catch(Exception e){
  2379.                     msgDiag.logErroreGenerico(e, "SendSbloccoDopoRicezione("+ricevutaAsincrona+")");
  2380.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2381.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2382.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),
  2383.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2384.                             null);
  2385.                     openspcoopstate.releaseResource();
  2386.                     esito.setEsitoInvocazione(true); 
  2387.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"SendSbloccoDopoRicezione("+ricevutaAsincrona+")"); 
  2388.                     return esito;
  2389.                 }
  2390.             }
  2391.             
  2392.             







  2400.             /* ---------- Gestione Transazione Modulo ---------------- */
  2401.             // se non ho gestito una ricevuta asincrona, sono andato verso ConsegnaContenutiApplicativi
  2402.             msgDiag.mediumDebug("Aggiornamento proprietario messaggio...");

  2404.             if(ricevutaAsincrona==null){
  2405.                 msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi.ID_MODULO);
  2406.             }
  2407.             // se ho gestito una ricevuta asincrona, guardo se e' abilitata la gestione del contenuto applicativo nella risposta
  2408.             // se non e' abilitato devo cancellare il messaggio. 
  2409.             else if(consegnaApplicativaAsincrona!=null){
  2410.                 if(consegnaApplicativaAsincrona.isRicevutaAsincrona()==false){
  2411.                     repositoryBuste.eliminaUtilizzoPdDFromInBox(idMessageRequest,true);
  2412.                     msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.timers.TimerGestoreMessaggi.ID_MODULO);
  2413.                 }
  2414.             }
  2415.             // else l'ho gia inviato al modulo di ricezione contenuti applicativi il contenuto della ricevuta asincrona

  2417.             // Commit JDBC
  2418.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della busta...");
  2419.             openspcoopstate.commit();


  2422.         }catch(Throwable e){
  2423.             this.log.error("ErroreGenerale",e);
  2424.             msgDiag.logErroreGenerico(e, "Generale");
  2425.             
  2426.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(bustaRichiesta.getProfiloDiCollaborazione()) == true  ) {
  2427.                 try{
  2428.                     ejbUtils.sendAsRispostaBustaErroreProcessamento(richiestaApplicativa.getIdModuloInAttesa(),bustaRichiesta,
  2429.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),
  2430.                             idCorrelazioneApplicativa,servizioApplicativoFruitore,e,
  2431.                             null);
  2432.                     esito.setEsitoInvocazione(true); 
  2433.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"ErroreGenerale");
  2434.                 }catch(Exception er){
  2435.                     msgDiag.logErroreGenerico(er,"ejbUtils.sendErroreGenerale(profiloConRisposta)");
  2436.                     ejbUtils.rollbackMessage("Spedizione Errore al Mittente durante una richiesta sincrona non riuscita", esito);
  2437.                     esito.setEsitoInvocazione(false); 
  2438.                     esito.setStatoInvocazioneErroreNonGestito(er);
  2439.                 }    
  2440.             }else{
  2441.                 ejbUtils.rollbackMessage("ErroreGenerale:"+e.getMessage(), esito); 
  2442.                 esito.setStatoInvocazioneErroreNonGestito(e);
  2443.                 esito.setEsitoInvocazione(false);
  2444.             }
  2445.             openspcoopstate.releaseResource();
  2446.             return esito;
  2447.         }

  2449.         // Aggiornamento cache messaggio
  2450.         if(msgRequest!=null)
  2451.             msgRequest.addMessaggiIntoCache_readFromTable(Sbustamento.ID_MODULO, "richiesta");
  2452.         if(msgResponse!=null)
  2453.             msgResponse.addMessaggiIntoCache_readFromTable(Sbustamento.ID_MODULO, "risposta");

  2455.         // Aggiornamento cache proprietario messaggio
  2456.         if(msgRequest!=null)
  2457.             msgRequest.addProprietariIntoCache_readFromTable(Sbustamento.ID_MODULO, "richiesta",null,false);
  2458.         if(msgResponse!=null)
  2459.             msgResponse.addProprietariIntoCache_readFromTable(Sbustamento.ID_MODULO, "risposta",idMessageRequest,false);

  2461.         // Gestione ricevute
  2462.         if(ricevutaAsincrona!=null){
  2463.             msgDiag.mediumDebug("Gestione ricevute asincrone...");
  2464.             try{
  2465.                 
  2466.                 boolean forzaEliminazioneMessaggio = false;
  2467.                 if( (openspcoopstate instanceof OpenSPCoopStateless) &&  
  2468.                         ("ricevuta di una richiesta asincrona simmetrica".equals(ricevutaAsincrona)) ){
  2469.                     forzaEliminazioneMessaggio = true;
  2470.                 }
  2471.                 
  2472.                 GestoreMessaggi msgRiscontrato = new GestoreMessaggi(openspcoopstate, true, bustaRichiesta.getRiferimentoMessaggio(),Costanti.OUTBOX,msgDiag,pddContext);
  2473.                 msgRiscontrato.setReadyForDrop(forzaEliminazioneMessaggio);
  2474.                 msgRiscontrato.validateAndDeleteMsgAsincronoRiscontrato(bustaRichiesta);
  2475.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_RICEVUTA_ASINCRONA, ricevutaAsincrona);
  2476.                 msgDiag.logPersonalizzato("validazioneRicevutaAsincrona");
  2477.             }catch(Exception e){
  2478.                 msgDiag.logErroreGenerico(e,"Validazione("+ricevutaAsincrona+")");
  2479.             }
  2480.         }

  2482.         // Rilascio connessione al DB
  2483.         msgDiag.mediumDebug("Rilascio connessione al database...");
  2484.         openspcoopstate.releaseResource();

  2486.         msgDiag.mediumDebug("Lavoro Terminato.");

  2488.         esito.setEsitoInvocazione(true); 
  2489.         esito.setStatoInvocazione(EsitoLib.OK, null); 
  2490.         return esito;

  2492.     }



  2496.     /**
  2497.      * Gestione errore.
  2498.      *
  2499.      * 
  2500.      */
  2501.     private void gestioneErroreProtocollo(ConfigurazionePdDManager configurazionePdDManager, EJBUtils ejbUtils, ProfiloDiCollaborazione profiloCollaborazione, RepositoryBuste repositoryBuste,
  2502.             Busta busta, IDSoggetto identitaPdD, Eccezione eccezioneProtocollo, ErroreIntegrazione erroreIntegrazione, IDSoggetto soggettoProduttoreEccezione, DettaglioEccezione dettaglioEccezione, 
  2503.             IProtocolFactory<?> protocolFactory, IProtocolManager protocolManager, PdDContext pddContext, RequestInfo requestInfo,
  2504.             IntegrationFunctionError integrationFunctionError) throws Exception{

  2506.         // Gestione ERRORE
  2507.         if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO.equals(busta.getProfiloDiCollaborazione()) && busta.getRiferimentoMessaggio()!=null){
  2508.             // oltre al messaggio in ingresso, viene effettuato il rollback sul riferimento messaggio.
  2509.             // una risposta al SIL in attesa verra' ritornata quando scadra il timeout sulla connessione JMS della coda 'RicezioneContenutiApplicativi'
  2510.             ejbUtils.releaseInboxMessage(Costanti.OUTBOX,busta.getRiferimentoMessaggio(), true);
  2511.         }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ||
  2512.                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ){
  2513.             Integrazione integrazioneRispostaErrore = null;
  2514.             boolean spedizioneRichiestaInCorso = profiloCollaborazione.asincrono_spedizioneRichiestaInCorso(busta.getRiferimentoMessaggio());
  2515.             boolean spedizioneRispostaInCorso = profiloCollaborazione.asincrono_spedizioneRispostaInCorso(busta.getRiferimentoMessaggio());
  2516.             boolean ricevutaApplicativaAbilitata=true;
  2517.             boolean gestioneEffettuata = false;
  2518.             if(spedizioneRichiestaInCorso || spedizioneRispostaInCorso){
  2519.                 ricevutaApplicativaAbilitata = profiloCollaborazione.asincrono_ricevutaApplicativaAbilitata(busta.getRiferimentoMessaggio());
  2520.                 if(ricevutaApplicativaAbilitata){
  2521.                     try{
  2522.                         integrazioneRispostaErrore = repositoryBuste.getInfoIntegrazioneFromOutBox(busta.getRiferimentoMessaggio());
  2523.                     }catch(Exception e){
  2524.                         throw new Exception("Riscontrato errore durante l'esamina dei dati di integrazione per la generazione di una risposta applicativa asincrona, in seguito alla ricezione di un Messaggio Errore Protocollo: "+e.getMessage());
  2525.                     }
  2526.                     if(integrazioneRispostaErrore!=null){
  2527.                         // Costruzione Richiesta Delegata
  2528.                         IDSoggetto soggettoFruitoreAsincrono = new IDSoggetto(busta.getTipoDestinatario(),busta.getDestinatario());
  2529.                         IDSoggetto soggettoErogatoreAsincrono = new IDSoggetto(busta.getTipoMittente(),busta.getMittente());
  2530.                         IDServizio servizioAsincrono = 
  2531.                             IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(),busta.getServizio(), 
  2532.                                     soggettoErogatoreAsincrono, busta.getVersioneServizio()); 
  2533.                         servizioAsincrono.setAzione(busta.getAzione());
  2534.                         ProprietaErroreApplicativo proprietaErroreApplAsincrono = this.propertiesReader.getProprietaGestioneErrorePD(protocolManager);
  2535.                         proprietaErroreApplAsincrono.setDominio(identitaPdD.getCodicePorta());
  2536.                         proprietaErroreApplAsincrono.setIdModulo(Sbustamento.ID_MODULO);
  2537.                         
  2538.                         IDPortaDelegata idPD = configurazionePdDManager.getIDPortaDelegata(integrazioneRispostaErrore.getNomePorta(), requestInfo, protocolFactory);
  2539.                         RichiestaDelegata consegnaApplicativaAsincrona = new RichiestaDelegata(idPD,
  2540.                                 integrazioneRispostaErrore.getServizioApplicativo(),null,proprietaErroreApplAsincrono,identitaPdD);
  2541.                         
  2542.                         PortaDelegata pd = configurazionePdDManager.getPortaDelegata(consegnaApplicativaAsincrona.getIdPortaDelegata(), requestInfo);
  2543.                         ServizioApplicativo sappl = null;
  2544.                         try{
  2545.                             IDServizioApplicativo idSA = new IDServizioApplicativo();
  2546.                             idSA.setNome(consegnaApplicativaAsincrona.getServizioApplicativo());
  2547.                             idSA.setIdSoggettoProprietario(soggettoFruitoreAsincrono);
  2548.                             sappl = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo);
  2549.                         }catch(Exception e){
  2550.                             if( !(e instanceof DriverConfigurazioneNotFound) || !(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(consegnaApplicativaAsincrona.getServizioApplicativo())) ){
  2551.                                 throw e;
  2552.                             }
  2553.                         }
  2554.                         configurazionePdDManager.aggiornaProprietaGestioneErrorePD(proprietaErroreApplAsincrono,sappl);
  2555.                     
  2556.                         
  2557.                         //  di default la ricezioneAsincrona viene utilizzata.
  2558.                         //  Non deve essere utilizzata solo nel caso di richiesta con profilo AsincronoSimmetrico 
  2559.                         consegnaApplicativaAsincrona.setUtilizzoConsegnaAsincrona(true);
  2560.                         if(spedizioneRichiestaInCorso && org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione())){
  2561.                             consegnaApplicativaAsincrona.setUtilizzoConsegnaAsincrona(false);
  2562.                         }
  2563.                         //  Il modulo in attesa e' il servizio di ricezioneContenutiApplicativi
  2564.                         consegnaApplicativaAsincrona.setIdModuloInAttesa(integrazioneRispostaErrore.getIdModuloInAttesa());

  2566.                         this.generatoreErrore.updateDominio(consegnaApplicativaAsincrona.getDominio());
  2567.                         this.generatoreErrore.updateProprietaErroreApplicativo(proprietaErroreApplAsincrono);
  2568.                         this.generatoreErrore.updateTipoPdD(TipoPdD.DELEGATA);
  2569.                         this.generatoreErrore.updateInformazioniCooperazione(consegnaApplicativaAsincrona.getServizioApplicativo());
  2570.                         this.generatoreErrore.updateInformazioniCooperazione(consegnaApplicativaAsincrona.getIdSoggettoFruitore(),consegnaApplicativaAsincrona.getIdServizio());
  2571.                         
  2572.                         OpenSPCoop2Message responseMessageError = null;
  2573.                         if(eccezioneProtocollo!=null){
  2574.                             responseMessageError = this.generatoreErrore.build(pddContext, integrationFunctionError,
  2575.                                     eccezioneProtocollo,soggettoProduttoreEccezione,dettaglioEccezione,
  2576.                                     null);
  2577.                         }else{
  2578.                             responseMessageError = this.generatoreErrore.build(pddContext, integrationFunctionError,erroreIntegrazione,null,null);
  2579.                         }
  2580.                         //  Aggiorno l'id di sessione al riferimento Messaggio, id utilizzato dal servizio
  2581.                         // RicezioneContenutiApplicativi per l'attesa di una risposta
  2582.                         ejbUtils.updateIdSessione(busta.getRiferimentoMessaggio());
  2583.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,consegnaApplicativaAsincrona,spedizioneRichiestaInCorso,pd,sappl);
  2584.                         // ripristino old id sessione
  2585.                         ejbUtils.updateIdSessione(busta.getID());

  2587.                         gestioneEffettuata = true;
  2588.                     }
  2589.                     else{
  2590.                         // una risposta al SIL in attesa verra' ritornata quando scadra il timeout sulla connessione JMS della coda 'RicezioneContenutiApplicativi'
  2591.                         if(spedizioneRichiestaInCorso){
  2592.                             //  oltre al messaggio in ingresso, viene effettuato il rollback sul riferimento messaggio.
  2593.                             ejbUtils.releaseInboxMessage(Costanti.OUTBOX,busta.getRiferimentoMessaggio(), true);

  2595.                             gestioneEffettuata = true;
  2596.                         }// else se vi e' una risposta in corso, basta rilasciare la busta di errore.
  2597.                     }
  2598.                 }// else se non e' attiva la gestione della ricevuta applicativa, basta rilasciare la busta di errore.
  2599.             }// else se non e' in corso ne una richiesta ne una risposta, basta rilasciare la busta di errore.
  2600.             if(gestioneEffettuata == false){
  2601.                 ejbUtils.releaseInboxMessage(true);
  2602.             }                   
  2603.         }else{
  2604.             ejbUtils.releaseInboxMessage(true);
  2605.         }

  2607.     }

  2609.     
  2610.     public static IFiltroDuplicati getGestoreFiltroDuplicati(OpenSPCoop2Properties propertiesReader,Loader loader, 
  2611.             IOpenSPCoopState openspcoopstate,PdDContext pddContext, History historyBuste, RepositoryBuste repositoryBuste, boolean oneWayVersione11) throws Exception{
  2612.         // Istanzio gestore filtro duplicati
  2613.         String gestoreFiltroDuplicatiType = propertiesReader.getGestoreFiltroDuplicatiRepositoryBuste();
  2614.         ClassNameProperties prop = ClassNameProperties.getInstance();
  2615.         String gestoreFiltroDuplicatiClass = prop.getFiltroDuplicati(gestoreFiltroDuplicatiType);
  2616.         if(gestoreFiltroDuplicatiClass == null){
  2617.             throw new Exception("GestoreFiltroDuplicati non registrato ("+gestoreFiltroDuplicatiType+")");
  2618.         }
  2619.         IFiltroDuplicati gestoreFiltroDuplicati = (IFiltroDuplicati) loader.newInstance(gestoreFiltroDuplicatiClass);
  2620.         if(pddContext!=null) {
  2621.             pddContext.addObject(org.openspcoop2.core.constants.Costanti.OPENSPCOOP_STATE, openspcoopstate );
  2622.         }
  2623.         gestoreFiltroDuplicati.init(pddContext);
  2624.         if(gestoreFiltroDuplicati instanceof org.openspcoop2.protocol.engine.driver.FiltroDuplicati){
  2625.             ((org.openspcoop2.protocol.engine.driver.FiltroDuplicati)gestoreFiltroDuplicati).setHistoryBuste(historyBuste);
  2626.             ((org.openspcoop2.protocol.engine.driver.FiltroDuplicati)gestoreFiltroDuplicati).setRepositoryBuste(repositoryBuste);
  2627.             ((org.openspcoop2.protocol.engine.driver.FiltroDuplicati)gestoreFiltroDuplicati).setGestioneStateless((openspcoopstate instanceof OpenSPCoopStateless) && (oneWayVersione11==false));
  2628.             ((org.openspcoop2.protocol.engine.driver.FiltroDuplicati)gestoreFiltroDuplicati).setRepositoryIntervalloScadenzaMessaggi(propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  2629.         }
  2630.         else if(gestoreFiltroDuplicati instanceof org.openspcoop2.pdd.core.transazioni.FiltroDuplicati) {
  2631.             if(pddContext!=null && pddContext.containsKey(CostantiPdD.FILTRO_DUPLICATI_TEST)) {
  2632.                 ((org.openspcoop2.pdd.core.transazioni.FiltroDuplicati)gestoreFiltroDuplicati).setUseTransactionIdForTest(true);
  2633.             }
  2634.         }
  2635.         return gestoreFiltroDuplicati;
  2636.     }
  2637. }
Created with JaCoCo 0.8.8.202204050719