Imbustamento.java

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


  22. package org.openspcoop2.pdd.mdb;

  24. import java.util.Date;

  26. import org.openspcoop2.core.config.PortaDelegata;
  27. import org.openspcoop2.core.config.ServizioApplicativo;
  28. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  29. import org.openspcoop2.core.constants.TipoPdD;
  30. import org.openspcoop2.core.id.IDServizio;
  31. import org.openspcoop2.core.id.IDServizioApplicativo;
  32. import org.openspcoop2.core.id.IDSoggetto;
  33. import org.openspcoop2.message.OpenSPCoop2Message;
  34. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  35. import org.openspcoop2.message.constants.MessageRole;
  36. import org.openspcoop2.message.utils.MessageUtilities;
  37. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  38. import org.openspcoop2.pdd.config.RichiestaDelegata;
  39. import org.openspcoop2.pdd.core.CostantiPdD;
  40. import org.openspcoop2.pdd.core.EJBUtils;
  41. import org.openspcoop2.pdd.core.GestoreMessaggi;
  42. import org.openspcoop2.pdd.core.PdDContext;
  43. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  44. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  45. import org.openspcoop2.pdd.core.state.OpenSPCoopStateException;
  46. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  47. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  48. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  49. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  50. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  51. import org.openspcoop2.protocol.engine.constants.Costanti;
  52. import org.openspcoop2.protocol.engine.driver.ConsegnaInOrdine;
  53. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  54. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  55. import org.openspcoop2.protocol.engine.driver.Riscontri;
  56. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  57. import org.openspcoop2.protocol.sdk.Busta;
  58. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  59. import org.openspcoop2.protocol.sdk.Integrazione;
  60. import org.openspcoop2.protocol.sdk.ProtocolException;
  61. import org.openspcoop2.protocol.sdk.Servizio;
  62. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  63. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  64. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  65. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  66. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  67. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  68. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  69. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  70. import org.openspcoop2.protocol.sdk.constants.InitialIdConversationType;
  71. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  72. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  73. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  74. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  75. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  76. import org.openspcoop2.utils.Utilities;
  77. import org.openspcoop2.utils.date.DateManager;
  78. import org.openspcoop2.utils.date.DateUtils;
  79. import org.slf4j.Logger;

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

  91.     public static final String ID_MODULO = "Imbustamento";

  93.     public Imbustamento(Logger log) throws GenericLibException {
  94.         super(Imbustamento.ID_MODULO, log);
  95.         inizializza();
  96.     }   

  98.     @Override
  99.     protected synchronized void inizializza() throws GenericLibException {
  100.         super.inizializza();
  101.     }

  103.     @Override
  104.     public EsitoLib _onMessage(IOpenSPCoopState openspcoopstate,
  105.             RegistroServiziManager registroServiziManager,ConfigurazionePdDManager configurazionePdDManager, 
  106.             MsgDiagnostico msgDiag) throws OpenSPCoopStateException {

  108.         EsitoLib esito = new EsitoLib();

  110.         ImbustamentoMessage imbustamentoMsg = (ImbustamentoMessage) openspcoopstate.getMessageLib();
  111.         
  112.         /* PddContext */
  113.         PdDContext pddContext = imbustamentoMsg.getPddContext();
  114.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  115.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  116.         
  117.         /* Protocol Factory */
  118.         IProtocolFactory<?> protocolFactory = null;
  119.         IProtocolVersionManager protocolManager = null;
  120.         ITraduttore traduttore = null;
  121.         try{
  122.             protocolFactory = this.protocolFactoryManager.getProtocolFactoryByName((String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  123.             protocolManager = protocolFactory.createProtocolVersionManager(imbustamentoMsg.getRichiestaDelegata().getProfiloGestione());
  124.             traduttore = protocolFactory.createTraduttore();
  125.         }catch(Exception e){
  126.             msgDiag.logErroreGenerico(e, "ProtocolFactory.instanziazione"); 
  127.             openspcoopstate.releaseResource();
  128.             esito.setEsitoInvocazione(false); 
  129.             esito.setStatoInvocazioneErroreNonGestito(e);
  130.             return esito;
  131.         }
  132.         
  133.         msgDiag.setPddContext(pddContext, protocolFactory);
  134.         
  135.         /* ID e tipo di implementazione PdD con cui interoperare */
  136.         String idMessageRequest = openspcoopstate.getIDMessaggioSessione();
  137.         String implementazionePdDDestinatario = imbustamentoMsg.getImplementazionePdDSoggettoDestinatario();
  138.         
  139.         RichiestaDelegata richiestaDelegata = imbustamentoMsg.getRichiestaDelegata();
  140.         if(richiestaDelegata==null) {
  141.             msgDiag.logErroreGenerico("RichiestaDelegata is null", "RichiestaDelegata.checkNull"); 
  142.             openspcoopstate.releaseResource();
  143.             esito.setEsitoInvocazione(false); 
  144.             return esito;
  145.         }
  146.         IDSoggetto identitaPdD = imbustamentoMsg.getRichiestaDelegata().getDominio();
  147.         TipoPdD tipoPdD = TipoPdD.DELEGATA;
  148.         msgDiag.setDominio(identitaPdD);  // imposto anche il dominio nel msgDiag

  150.         // Aggiornamento Informazioni messaggio diagnostico
  151.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO);
  152.         msgDiag.setIdMessaggioRichiesta(idMessageRequest);
  153.         msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessageRequest);
  154.         if(msgDiag.getPorta()==null) {
  155.             if(richiestaDelegata!=null && richiestaDelegata.getIdPortaDelegata()!=null) {
  156.                 msgDiag.updatePorta(tipoPdD, richiestaDelegata.getIdPortaDelegata().getNome(), requestInfo);
  157.             }
  158.         }
  159.         msgDiag.setFruitore(richiestaDelegata.getIdSoggettoFruitore());
  160.         msgDiag.addKeywords(richiestaDelegata.getIdSoggettoFruitore());
  161.         msgDiag.setServizio(richiestaDelegata.getIdServizio());
  162.         msgDiag.addKeywords(richiestaDelegata.getIdServizio());
  163.         msgDiag.setServizioApplicativo(richiestaDelegata.getServizioApplicativo());
  164.         msgDiag.addKeyword(CostantiPdD.KEY_SA_FRUITORE, richiestaDelegata.getServizioApplicativo());
  165.         if(richiestaDelegata.getProfiloCollaborazione()!=null)
  166.             msgDiag.addKeyword(CostantiPdD.KEY_PROFILO_COLLABORAZIONE,traduttore.toString(richiestaDelegata.getProfiloCollaborazione()));
  167.         msgDiag.setIdCorrelazioneApplicativa(richiestaDelegata.getIdCorrelazioneApplicativa());
  168.         msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, richiestaDelegata.getIdCorrelazioneApplicativa());
  169.         msgDiag.addKeyword(CostantiPdD.KEY_FUNZIONALITA_COLLABORAZIONE, imbustamentoMsg.getInfoServizio().getCollaborazione()+"");
  170.         msgDiag.addKeyword(CostantiPdD.KEY_FUNZIONALITA_CONFERMA_RICEZIONE, imbustamentoMsg.getInfoServizio().getConfermaRicezione()+"");
  171.         msgDiag.addKeyword(CostantiPdD.KEY_FUNZIONALITA_FILTRO_DUPLICATI, Inoltro.SENZA_DUPLICATI.equals(imbustamentoMsg.getInfoServizio().getInoltro()) + "");
  172.     
  173.                 
  174.         //  ProprietaErroreApplicativo  
  175.         ProprietaErroreApplicativo proprietaErroreAppl = richiestaDelegata.getFault();
  176.         proprietaErroreAppl.setIdModulo(Imbustamento.ID_MODULO);
  177.         
  178.         // GeneratoreErrore
  179.         RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore = null;
  180.         try{
  181.             generatoreErrore = new RicezioneContenutiApplicativiInternalErrorGenerator(this.log, this.idModulo, requestInfo);
  182.             generatoreErrore.updateInformazioniCooperazione(richiestaDelegata.getIdSoggettoFruitore(), richiestaDelegata.getIdServizio());
  183.             generatoreErrore.updateInformazioniCooperazione(richiestaDelegata.getServizioApplicativo());
  184.             generatoreErrore.updateProprietaErroreApplicativo(proprietaErroreAppl);
  185.         }catch(Exception e){
  186.             msgDiag.logErroreGenerico(e, "RicezioneContenutiApplicativiGeneratoreErrore.instanziazione"); 
  187.             openspcoopstate.releaseResource();
  188.             esito.setEsitoInvocazione(false); 
  189.             esito.setStatoInvocazioneErroreNonGestito(e);
  190.             return esito;
  191.         }
  192.         

  194.         /* ------------------ Inizializzo stato OpenSPCoop  --------------- */
  195.         msgDiag.mediumDebug("Inizializzo stato per la gestione della richiesta...");
  196.         openspcoopstate.initResource(identitaPdD, Imbustamento.ID_MODULO,idTransazione);
  197.         registroServiziManager = registroServiziManager.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  198.         configurazionePdDManager = configurazionePdDManager.refreshState(registroServiziManager);
  199.         msgDiag.updateState(configurazionePdDManager);


  202.         /* ------------------ Inizializzazione Contesto di gestione  --------------- */
  203.         msgDiag.mediumDebug("Inizializzo contesto per la gestione...");
  204.         // EJBUtils (per eventuali errori)
  205.         EJBUtils ejbUtils = null;
  206.         try{
  207.             ejbUtils = new EJBUtils(identitaPdD,tipoPdD,Imbustamento.ID_MODULO,idMessageRequest,
  208.                     idMessageRequest,Costanti.OUTBOX,openspcoopstate,msgDiag,false,
  209.                     imbustamentoMsg.getImplementazionePdDSoggettoMittente(),
  210.                     imbustamentoMsg.getImplementazionePdDSoggettoDestinatario(),
  211.                     imbustamentoMsg.getRichiestaDelegata().getProfiloGestione(),pddContext);
  212.         }catch(Exception e){
  213.             msgDiag.logErroreGenerico(e, "EJBUtils.new"); 
  214.             openspcoopstate.releaseResource();
  215.             esito.setEsitoInvocazione(false); 
  216.             esito.setStatoInvocazioneErroreNonGestito(e);
  217.             return esito;
  218.         }

  220.         // Oneway versione 11
  221.         boolean oneWayVersione11 = imbustamentoMsg.isOneWayVersione11();
  222.         ejbUtils.setOneWayVersione11(oneWayVersione11);

  224.         // Gestori funzionalita'
  225.         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true,protocolFactory);
  226.         Riscontri gestoreRiscontri = new Riscontri(openspcoopstate.getStatoRichiesta());
  227.         ProfiloDiCollaborazione profiloCollaborazione = null;
  228.         try{
  229.             profiloCollaborazione = new ProfiloDiCollaborazione(openspcoopstate.getStatoRichiesta(),protocolFactory);
  230.         }catch(Exception e){
  231.             msgDiag.logErroreGenerico(e, "ProfiloDiCollaborazione.new");
  232.             openspcoopstate.releaseResource();
  233.             esito.setEsitoInvocazione(false); 
  234.             esito.setStatoInvocazioneErroreNonGestito(e);
  235.             return esito;
  236.         }
  237.         ConsegnaInOrdine ordineConsegna = new ConsegnaInOrdine(openspcoopstate.getStatoRichiesta(),protocolFactory);
  238.         GestoreMessaggi msgRequest = null;
  239.         GestoreMessaggi msgOK = null; // Evenutuale busta OK (rigirata a ID_MODULO o a RICEZIONE_CONTENUTI_APPLICATIVI)

  241.         Servizio infoServizio = imbustamentoMsg.getInfoServizio();
  242.         String riferimentoServizioCorrelato = imbustamentoMsg.getRiferimentoServizioCorrelato();
  243.         boolean isServizioCorrelato = infoServizio.isCorrelato();
  244.         IDServizio idServizio = richiestaDelegata.getIdServizio();
  245.         IDSoggetto soggettoFruitore = richiestaDelegata.getIdSoggettoFruitore();
  246.         

  248.         // Punto di inizio per la transazione.
  249.         PortaDelegata pd = null;
  250.         ServizioApplicativo sa = null;
  251.         try{
  252.             

  254.             /**---- Check Utilizzo Consegna Risposta Asincrona */
  255.             msgDiag.mediumDebug("Check utilizzo consegna risposta asincrona...");
  256.             // Non deve essere utilizzata solo nel caso di richiesta con profilo AsincronoSimmetrico 
  257.             if( !(infoServizio.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO) &&
  258.                     riferimentoServizioCorrelato==null 
  259.                     && isServizioCorrelato==false) ){
  260.                 // di default la ricezioneAsincrona viene utilizzata.
  261.                 // Per i casi di :
  262.                 // - profiloOneWay
  263.                 // - profiloSincrono
  264.                 // - profiloAsincronoSimmetrico solo in consegna risposta
  265.                 // - profiloAsincronoAsimmetrico 
  266.                 richiestaDelegata.setUtilizzoConsegnaAsincrona(true); 
  267.             }


  270.             Utilities.printFreeMemory("Imbustamento - Costruzione busta ...");


  273.             /* ---  Costruzione/Registrazione Busta  ----- */
  274.             msgDiag.mediumDebug("Costruzione busta ...");
  275.             Busta busta = new Busta(protocolFactory.getProtocol());

  277.             // identificatore del servizio richiesto
  278.             busta.setTipoDestinatario(idServizio.getSoggettoErogatore().getTipo());
  279.             busta.setDestinatario(idServizio.getSoggettoErogatore().getNome());
  280.             busta.setIdentificativoPortaDestinatario(idServizio.getSoggettoErogatore().getCodicePorta());
  281.             busta.setIndirizzoDestinatario(imbustamentoMsg.getIndirizzoSoggettoDestinatario());
  282.             
  283.             busta.setVersioneServizio(idServizio.getVersione());
  284.             busta.setServizio(idServizio.getNome());
  285.             busta.setTipoServizio(idServizio.getTipo());
  286.             busta.setAzione(idServizio.getAzione());

  288.             // mittente della richiesta
  289.             busta.setTipoMittente(soggettoFruitore.getTipo());
  290.             busta.setMittente(soggettoFruitore.getNome());
  291.             busta.setIdentificativoPortaMittente(soggettoFruitore.getCodicePorta());
  292.             busta.setIndirizzoMittente(imbustamentoMsg.getIndirizzoSoggettoMittente());
  293.             
  294.             busta.setServizioApplicativoFruitore(richiestaDelegata.getServizioApplicativo());

  296.             // Informazioni protocollo
  297.             msgDiag.highDebug("Costruzione Busta con ID = "+idMessageRequest);
  298.             busta.setID(idMessageRequest);

  300.             Date oraRegistrazione = DateManager.getDate();
  301.             msgDiag.highDebug("Costruzione Busta in data : ["+oraRegistrazione+"]");
  302.             busta.setOraRegistrazione(oraRegistrazione);
  303.             TipoOraRegistrazione tipoOraRegistrazione = this.propertiesReader.getTipoTempoBusta(implementazionePdDDestinatario);
  304.             busta.setTipoOraRegistrazione(tipoOraRegistrazione,protocolFactory.createTraduttore().toString(tipoOraRegistrazione));
  305.             busta.setScadenza(infoServizio.getScadenza());
  306.             long scadenzaBusta = infoServizio.getScadenzaMinuti();
  307.             if(scadenzaBusta<=0){
  308.                 scadenzaBusta = this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi();
  309.             }
  310.             
  311.             switch (protocolManager.getFiltroDuplicati(infoServizio)) {
  312.             case ABILITATA:
  313.                 busta.setInoltro(Inoltro.SENZA_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));
  314.                 break;
  315.             case DISABILITATA:
  316.                 busta.setInoltro(Inoltro.CON_DUPLICATI,protocolFactory.createTraduttore().toString(Inoltro.CON_DUPLICATI));
  317.                 break;
  318.             default:
  319.                 busta.setInoltro(infoServizio.getInoltro(),protocolFactory.createTraduttore().toString(infoServizio.getInoltro()));
  320.                 break;
  321.             }
  322.                 
  323.             boolean consegnaAffidabile = false;
  324.             switch (protocolManager.getConsegnaAffidabile(infoServizio)) {
  325.             case ABILITATA:
  326.                 consegnaAffidabile = true;
  327.                 break;
  328.             case DISABILITATA:
  329.                 consegnaAffidabile = false;
  330.                 break;
  331.             default:
  332.                 consegnaAffidabile = this.propertiesReader.isGestioneRiscontri(implementazionePdDDestinatario) && infoServizio.getConfermaRicezione();
  333.                 break;
  334.             }
  335.             
  336.             boolean idCollaborazione = false;
  337.             switch (protocolManager.getCollaborazione(infoServizio)) {
  338.             case ABILITATA:
  339.                 idCollaborazione = true;
  340.                 break;
  341.             case DISABILITATA:
  342.                 idCollaborazione = false;
  343.                 break;
  344.             default:
  345.                 idCollaborazione = this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDDestinatario) && infoServizio.getCollaborazione();
  346.                 break;
  347.             }
  348.             String idCollaborazioneCapostipite = null;
  349.             if(idCollaborazione) {
  350.                 InitialIdConversationType initial = protocolFactory.createProtocolConfiguration().isGenerateInitialIdConversation(TipoPdD.DELEGATA, FunzionalitaProtocollo.COLLABORAZIONE);
  351.                 if(InitialIdConversationType.ID_TRANSAZIONE.equals(initial)) {
  352.                     idCollaborazioneCapostipite = idTransazione;
  353.                 }
  354.                 else if(InitialIdConversationType.ID_MESSAGGIO.equals(initial)) {
  355.                     idCollaborazioneCapostipite = idMessageRequest;
  356.                 }
  357.             }
  358.             
  359.             boolean idRiferimentoMessaggioRichiesta = false;
  360.             switch (protocolManager.getIdRiferimentoRichiesta(infoServizio)) {
  361.             case ABILITATA:
  362.                 idRiferimentoMessaggioRichiesta = true;
  363.                 break;
  364.             case DISABILITATA:
  365.                 idRiferimentoMessaggioRichiesta = false;
  366.                 break;
  367.             default:
  368.                 idRiferimentoMessaggioRichiesta = this.propertiesReader.isGestioneElementoIdRiferimentoRichiesta(implementazionePdDDestinatario) && infoServizio.getIdRiferimentoRichiesta();
  369.                 break;
  370.             }
  371.             
  372.             boolean consegnaInOrdine = false;
  373.             switch (protocolManager.getConsegnaInOrdine(infoServizio)) {
  374.             case ABILITATA:
  375.                 consegnaInOrdine = true;
  376.                 break;
  377.             case DISABILITATA:
  378.                 consegnaInOrdine = false;
  379.                 break;
  380.             default:
  381.                 consegnaInOrdine = this.propertiesReader.isGestioneConsegnaInOrdine(implementazionePdDDestinatario) && infoServizio.getOrdineConsegna();
  382.                 break;
  383.             }
  384.             
  385.             
  386.             
  387.                         
  388.             /* ----------- ConsegnaAffidabile ------------- */
  389.             if( consegnaAffidabile )
  390.                 busta.setConfermaRicezione(true);
  391.             else
  392.                 busta.setConfermaRicezione(false);

  394.                         

  396.             /* ----------- Lettura PortaDelegata e Servizio Applicativo ------------- */
  397.             pd = configurazionePdDManager.getPortaDelegata(richiestaDelegata.getIdPortaDelegata(), requestInfo);
  398.             try{
  399.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  400.                 idSA.setNome(richiestaDelegata.getServizioApplicativo());
  401.                 idSA.setIdSoggettoProprietario(richiestaDelegata.getIdSoggettoFruitore());
  402.                 sa = configurazionePdDManager.getServizioApplicativo(idSA, requestInfo);
  403.             }catch(DriverConfigurazioneNotFound e){
  404.                 if(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(richiestaDelegata.getServizioApplicativo())==false)
  405.                     throw e;
  406.             }
  407.             
  408.                     
  409.             // ------------- Controllo funzionalita di protocollo richieste siano compatibili con il protocollo -----------------------------
  410.             try{
  411.                 
  412.                 // NOTA: Usare getIntegrationServiceBinding poichè le funzionalità si riferiscono al tipo di integrazione scelta
  413.                 
  414.                 IProtocolConfiguration protocolConfiguration = protocolFactory.createProtocolConfiguration();
  415.                 if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),infoServizio.getProfiloDiCollaborazione())==false){
  416.                     throw new Exception("Profilo di Collaborazione ["+infoServizio.getProfiloDiCollaborazione().getEngineValue()+"]");
  417.                 }
  418.                 if(busta.getInoltro()!=null && Inoltro.SENZA_DUPLICATI.equals(busta.getInoltro())){
  419.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.FILTRO_DUPLICATI)==false){
  420.                         throw new Exception(FunzionalitaProtocollo.FILTRO_DUPLICATI.getEngineValue());
  421.                     }
  422.                 }
  423.                 if(consegnaAffidabile){
  424.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.CONFERMA_RICEZIONE)==false){
  425.                         throw new Exception(FunzionalitaProtocollo.CONFERMA_RICEZIONE.getEngineValue());
  426.                     }
  427.                 }
  428.                 if(idCollaborazione){
  429.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.COLLABORAZIONE)==false){
  430.                         throw new Exception(FunzionalitaProtocollo.COLLABORAZIONE.getEngineValue());
  431.                     }
  432.                 }
  433.                 if(idRiferimentoMessaggioRichiesta){
  434.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.RIFERIMENTO_ID_RICHIESTA)==false){
  435.                         throw new Exception(FunzionalitaProtocollo.RIFERIMENTO_ID_RICHIESTA.getEngineValue());
  436.                     }
  437.                 }
  438.                 if(consegnaInOrdine){
  439.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.CONSEGNA_IN_ORDINE)==false){
  440.                         throw new Exception(FunzionalitaProtocollo.CONSEGNA_IN_ORDINE.getEngineValue());
  441.                     }
  442.                 }
  443.                 if(infoServizio.getScadenza()!=null){
  444.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.SCADENZA)==false){
  445.                         throw new Exception(FunzionalitaProtocollo.SCADENZA.getEngineValue());
  446.                     }
  447.                 }
  448.                 if(configurazionePdDManager.isGestioneManifestAttachments(pd,protocolFactory)){
  449.                     if(protocolConfiguration.isSupportato(requestInfo.getIntegrationServiceBinding(),FunzionalitaProtocollo.MANIFEST_ATTACHMENTS)==false){
  450.                         throw new Exception(FunzionalitaProtocollo.MANIFEST_ATTACHMENTS.getEngineValue());
  451.                     }
  452.                 }           
  453.             }catch(Exception e){    
  454.                 msgDiag.addKeywordErroreProcessamento(e);
  455.                 msgDiag.logPersonalizzato("protocolli.funzionalita.unsupported");
  456.                 OpenSPCoop2Message responseMessageError = 
  457.                         generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, 
  458.                                 ErroriIntegrazione.ERRORE_439_FUNZIONALITA_NOT_SUPPORTED_BY_PROTOCOL.
  459.                                 getErrore439_FunzionalitaNotSupportedByProtocol(e.getMessage(), protocolFactory),e,
  460.                                 null);
  461.                 ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  462.                 openspcoopstate.releaseResource();
  463.                 esito.setEsitoInvocazione(true); 
  464.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  465.                         msgDiag.getMessaggio_replaceKeywords("protocolli.funzionalita.unsupported"));
  466.                 return esito;
  467.             }
  468.             
  469.             
  470.             
  471.             
  472.             
  473.             
  474.             
  475.             /* ------------  Check Consegna in Ordine che sia con profilo OneWay 
  476.                              e che rispetti vincoli  ------------- */   
  477.             // Sequenza: deve essere abilitata la consegna affidabile + la collaborazione e infine la consegna in ordine
  478.                         
  479.             if( consegnaInOrdine ){
  480.                 msgDiag.mediumDebug("Check vincoli consegna in ordine...");
  481.                 if ( infoServizio.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY)==false) {
  482.                     msgDiag.addKeyword(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, traduttore.toString(infoServizio.getProfiloDiCollaborazione()));
  483.                     msgDiag.logPersonalizzato("consegnaInOrdine.profiloNonOneway");
  484.                     OpenSPCoop2Message responseMessageError = 
  485.                             generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, 
  486.                                     ErroriIntegrazione.ERRORE_414_CONSEGNA_IN_ORDINE_CON_PROFILO_NO_ONEWAY.getErroreIntegrazione(),null,
  487.                                 null);
  488.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  489.                     openspcoopstate.releaseResource();
  490.                     esito.setEsitoInvocazione(true); 
  491.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  492.                             msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.profiloNonOneway"));
  493.                     return esito;
  494.                 }
  495.                 if(this.propertiesReader.isGestioneRiscontri(implementazionePdDDestinatario)==false){
  496.                     msgDiag.logPersonalizzato("consegnaInOrdine.confermaRicezioneNonRichiesta");
  497.                     OpenSPCoop2Message responseMessageError = 
  498.                             generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, 
  499.                                     ErroriIntegrazione.ERRORE_415_CONSEGNA_IN_ORDINE_SENZA_VINCOLI_RICHIESTI.getErroreIntegrazione(),null,
  500.                                 null);
  501.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  502.                     openspcoopstate.releaseResource();
  503.                     esito.setEsitoInvocazione(true); 
  504.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  505.                             msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.confermaRicezioneNonRichiesta"));
  506.                     return esito;
  507.                 }
  508.                 if(this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDDestinatario)==false){
  509.                     msgDiag.logPersonalizzato("consegnaInOrdine.idCollaborazioneNonRichiesto");
  510.                     OpenSPCoop2Message responseMessageError = 
  511.                             generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL, 
  512.                                     ErroriIntegrazione.ERRORE_415_CONSEGNA_IN_ORDINE_SENZA_VINCOLI_RICHIESTI.getErroreIntegrazione(),null,
  513.                                     null);
  514.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  515.                     openspcoopstate.releaseResource();
  516.                     esito.setEsitoInvocazione(true); 
  517.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  518.                             msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.idCollaborazioneNonRichiesto"));
  519.                     return esito;
  520.                 }
  521.                 if(infoServizio.getCollaborazione()==false || infoServizio.getConfermaRicezione()==false || Inoltro.SENZA_DUPLICATI.equals(infoServizio.getInoltro())==false){
  522.                     msgDiag.logPersonalizzato("consegnaInOrdine.funzionalitaMancanti");
  523.                     OpenSPCoop2Message responseMessageError = 
  524.                             generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL,  
  525.                                     ErroriIntegrazione.ERRORE_415_CONSEGNA_IN_ORDINE_SENZA_VINCOLI_RICHIESTI.getErroreIntegrazione(),null,
  526.                                     null);
  527.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  528.                     openspcoopstate.releaseResource();
  529.                     esito.setEsitoInvocazione(true); 
  530.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  531.                             msgDiag.getMessaggio_replaceKeywords("consegnaInOrdine.funzionalitaMancanti"));
  532.                     return esito;
  533.                 }
  534.             }
  535.             boolean gestioneConsegnaInOrdineAbilitata = consegnaInOrdine &&
  536.                 this.propertiesReader.isGestioneRiscontri(implementazionePdDDestinatario) && 
  537.                 this.propertiesReader.isGestioneElementoCollaborazione(implementazionePdDDestinatario) && 
  538.                 this.propertiesReader.isGestioneConsegnaInOrdine(implementazionePdDDestinatario);


  541.             /* ----------- Verifica connessione per le funzionalità che la richiedono ------------- */
  542.             if(consegnaAffidabile || 
  543.                     gestioneConsegnaInOrdineAbilitata ||
  544.                     org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())  ||
  545.                     org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())
  546.                 ) {
  547.                 if(openspcoopstate.resourceReleased()) {
  548.                     // inizializzo
  549.                     ((OpenSPCoopState)openspcoopstate).setUseConnection(true);
  550.                     openspcoopstate.initResource(identitaPdD, this.idModulo, idTransazione);
  551.                     gestoreRiscontri.updateState(openspcoopstate.getStatoRichiesta());
  552.                     ordineConsegna.updateState(openspcoopstate.getStatoRichiesta());
  553.                     profiloCollaborazione.updateState(openspcoopstate.getStatoRichiesta());
  554.                     repositoryBuste.updateState(openspcoopstate.getStatoRichiesta());
  555.                 }
  556.             }
  557.             
  558.             
  559.             
  560.             
  561.             

  563.             
  564.             
  565.             

  567.             Utilities.printFreeMemory("Imbustamento - Gestione profilo di Collaborazione...");






  574.             /* ------------  Profilo di Collaborazione  ------------- */    
  575.             boolean generazioneMsgOK = false;
  576.             String scenarioCooperazione = null;
  577.             if(infoServizio.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY)) {   

  579.                 msgDiag.mediumDebug("Gestione profilo di Collaborazione OneWay ...");

  581.                 // MessaggioSingoloOneWay       
  582.                 busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY);
  583.                 scenarioCooperazione = Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO;

  585.                 // Collaborazione
  586.                 if( idCollaborazione ){
  587.                     if(imbustamentoMsg.getIdCollaborazione()!=null)
  588.                         busta.setCollaborazione(imbustamentoMsg.getIdCollaborazione());
  589.                     else
  590.                         busta.setCollaborazione(idCollaborazioneCapostipite);
  591.                 }
  592.                 
  593.                 // RiferimentoMessaggio
  594.                 if( idRiferimentoMessaggioRichiesta ){
  595.                     if(imbustamentoMsg.getIdRiferimentoMessaggio()!=null)
  596.                         busta.setRiferimentoMessaggio(imbustamentoMsg.getIdRiferimentoMessaggio());
  597.                 }

  599.                 if(gestioneConsegnaInOrdineAbilitata && infoServizio.getOrdineConsegna()){
  600.                     if(oneWayVersione11 || openspcoopstate instanceof OpenSPCoopStateful){
  601.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione OneWay (consegna in ordine)...");
  602.                         try{
  603.                             ordineConsegna.setNextSequenza_daInviare(busta);
  604.                         }catch(Exception e){
  605.                             msgDiag.logErroreGenerico(e, "ordineConsegna.setNextSequenza_daInviare");
  606.                             openspcoopstate.releaseResource();
  607.                             esito.setEsitoInvocazione(true); 
  608.                             esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "ordineConsegna.setNextSequenza_daInviare");
  609.                             return esito;
  610.                         }
  611.                     }

  613.                 }

  615.                 // Modalita di trasmissione sincrona/asincrona
  616.                 if(configurazionePdDManager.isModalitaStateless(pd, infoServizio.getProfiloDiCollaborazione())==false){
  617.                     generazioneMsgOK = true;
  618.                 }
  619.                 else{
  620.                     generazioneMsgOK = false;
  621.                 }


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

  626.                 msgDiag.mediumDebug("Gestione profilo di Collaborazione Sincrono ...");

  628.                 // Profilo Sincrono     
  629.                 busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO);
  630.                 scenarioCooperazione = Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO;

  632.                 try {
  633.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione Sincrono (Registrazione Busta da inviare)...");
  634.                     profiloCollaborazione.registraBustaInviata(idMessageRequest);
  635.                 } catch(ProtocolException e){
  636.                     msgDiag.logErroreGenerico(e, "profiloDiCollaborazione.registraBustaInviata");
  637.                     OpenSPCoop2Message responseMessageError = 
  638.                             generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  639.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  640.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,
  641.                                 null);
  642.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  643.                     openspcoopstate.releaseResource();
  644.                     esito.setEsitoInvocazione(true); 
  645.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO, "profiloDiCollaborazione.registraBustaInviata");
  646.                     return esito;
  647.                 }

  649.                 //  Collaborazione
  650.                 if( idCollaborazione ){
  651.                     if(imbustamentoMsg.getIdCollaborazione()!=null)
  652.                         busta.setCollaborazione(imbustamentoMsg.getIdCollaborazione());
  653.                     else
  654.                         busta.setCollaborazione(idCollaborazioneCapostipite);
  655.                 }
  656.                 
  657.                 // RiferimentoMessaggio
  658.                 if( idRiferimentoMessaggioRichiesta ){
  659.                     if(imbustamentoMsg.getIdRiferimentoMessaggio()!=null)
  660.                         busta.setRiferimentoMessaggio(imbustamentoMsg.getIdRiferimentoMessaggio());
  661.                 }

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

  665.                 msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico ...");

  667.                 // Profilo Asincrono Simmetrico       
  668.                 busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO); 
  669.                 // deve essere generato un msg OK se non e' abilitata la funzionalita' di ricevuta asincrona
  670.                 msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico (check ricevuta abilitata)...");
  671.                 richiestaDelegata.setRicevutaAsincrona(configurazionePdDManager.ricevutaAsincronaSimmetricaAbilitata(pd));
  672.                 
  673.                 // Modalita di trasmissione stateless/stateful
  674.                 if(configurazionePdDManager.isModalitaStateless(pd, infoServizio.getProfiloDiCollaborazione())==false){
  675.                     generazioneMsgOK = !richiestaDelegata.isRicevutaAsincrona();
  676.                 }
  677.                 else{
  678.                     generazioneMsgOK = false;
  679.                 }

  681.                 //  Richiesta Asincrona
  682.                 if(riferimentoServizioCorrelato==null && isServizioCorrelato==false){

  684.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico richiesta...");

  686.                     // check autenticazione richiesta
  687.                     if(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(richiestaDelegata.getServizioApplicativo())){
  688.                         msgDiag.logPersonalizzato("profiloAsincronoSimmetrico.saAnonimo");
  689.                         OpenSPCoop2Message responseMessageError = 
  690.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.AUTHENTICATION, 
  691.                                         ErroriIntegrazione.ERRORE_410_AUTENTICAZIONE_RICHIESTA.getErroreIntegrazione(),null,
  692.                                     null);
  693.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  694.                         openspcoopstate.releaseResource();

  696.                         esito.setEsitoInvocazione(true); 
  697.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  698.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincronoSimmetrico.saAnonimo"));
  699.                         return esito;
  700.                     }

  702.                     // check esistenza consegna risposta asincrona
  703.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico richiesta (consegna asincrona)...");
  704.                     boolean existsConsegnaRispostaAsincrona = false;
  705.                     try{
  706.                         existsConsegnaRispostaAsincrona = configurazionePdDManager.existsConsegnaRispostaAsincrona(sa);
  707.                     }catch(Exception e){
  708.                         msgDiag.logErroreGenerico(e, "existsConsegnaRispostaAsincrona("+sa+")");
  709.                         OpenSPCoop2Message responseMessageError = 
  710.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  711.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  712.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null);
  713.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  714.                         openspcoopstate.releaseResource();  
  715.                         esito.setEsitoInvocazione(true); 
  716.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  717.                                 "existsConsegnaRispostaAsincrona("+sa+")");
  718.                         return esito;
  719.                     }
  720.                     if (existsConsegnaRispostaAsincrona == false){
  721.                         msgDiag.logPersonalizzato("profiloAsincronoSimmetrico.saSenzaRispostaAsincrona");
  722.                         OpenSPCoop2Message responseMessageError = 
  723.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  724.                                     ErroriIntegrazione.ERRORE_411_RICEZIONE_CONTENUTI_ASINCRONA_RICHIESTA.getErroreIntegrazione(),null,null);
  725.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  726.                         openspcoopstate.releaseResource();
  727.                         esito.setEsitoInvocazione(true); 
  728.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  729.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincronoSimmetrico.saSenzaRispostaAsincrona"));
  730.                         return esito;
  731.                     }

  733.                     scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO;

  735.                     // impostazione dati servizio correlato
  736.                     if(infoServizio.getServizioCorrelato()==null || infoServizio.getTipoServizioCorrelato()==null){
  737.                         msgDiag.logPersonalizzato("profiloAsincronoSimmetrico.servizioCorrelatoNonEsistente");
  738.                         OpenSPCoop2Message responseMessageError = 
  739.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  740.                                     ErroriIntegrazione.ERRORE_408_SERVIZIO_CORRELATO_NON_TROVATO.getErroreIntegrazione(),null,null);
  741.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  742.                         openspcoopstate.releaseResource();
  743.                         esito.setEsitoInvocazione(true); 
  744.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  745.                                 msgDiag.getMessaggio_replaceKeywords("profiloAsincronoSimmetrico.servizioCorrelatoNonEsistente"));
  746.                         return esito;
  747.                     }
  748.                     // PRODUZIONE tipo e nome Servizio Correlato
  749.                     if( protocolManager.isGenerazioneInformazioniServizioCorrelatoAsincronoSimmetrico() && 
  750.                             this.propertiesReader.isGenerazioneAttributiAsincroni(implementazionePdDDestinatario)){
  751.                         busta.setServizioCorrelato(infoServizio.getServizioCorrelato());
  752.                         busta.setTipoServizioCorrelato(infoServizio.getTipoServizioCorrelato());
  753.                     }

  755.                     //  Collaborazione (per gli asincroni devono sempre essere presenti)
  756.                     if( idCollaborazione ){
  757.                         if(imbustamentoMsg.getIdCollaborazione()!=null)
  758.                             busta.setCollaborazione(imbustamentoMsg.getIdCollaborazione());
  759.                         else
  760.                             busta.setCollaborazione(idCollaborazioneCapostipite);
  761.                     }

  763.                     // registrazione richiesta asincrona simmetrica
  764.                     try{
  765.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico richiesta (registrazione busta da inviare)...");
  766.                         
  767.                         Integrazione infoIntegrazione = null;
  768.                         if(configurazionePdDManager.isModalitaStateless(pd, infoServizio.getProfiloDiCollaborazione())){
  769.                             infoIntegrazione = new Integrazione();
  770.                             infoIntegrazione.setIdModuloInAttesa(this.idModulo);
  771.                             infoIntegrazione.setNomePorta(richiestaDelegata.getIdPortaDelegata().getNome());
  772.                             infoIntegrazione.setServizioApplicativo(richiestaDelegata.getServizioApplicativo());
  773.                             
  774.                             if(busta.getScadenza()==null){
  775.                                 busta.setScadenza(new Date(DateManager.getTimeMillis()+(scadenzaBusta*60*1000)));
  776.                             }
  777.                             if(openspcoopstate instanceof OpenSPCoopStateless){
  778.                                 ((StatelessMessage)openspcoopstate.getStatoRichiesta()).setBusta(busta);
  779.                             }
  780.                         }
  781.                         profiloCollaborazione.asincronoSimmetrico_registraRichiestaInviata(idMessageRequest,busta.getCollaborazione(),
  782.                                 infoServizio.getTipoServizioCorrelato(),
  783.                                 infoServizio.getServizioCorrelato(),
  784.                                 infoServizio.getVersioneServizioCorrelato(),
  785.                                 richiestaDelegata.isRicevutaAsincrona(),infoIntegrazione,scadenzaBusta);
  786.                     }catch(ProtocolException e){
  787.                         msgDiag.logErroreGenerico(e, "profiloDiCollaborazione.asincronoSimmetrico_registraRichiestaInviata");
  788.                         openspcoopstate.releaseResource();
  789.                         OpenSPCoop2Message responseMessageError = 
  790.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  791.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  792.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,null);
  793.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  794.                         esito.setEsitoInvocazione(true); 
  795.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  796.                                 "profiloDiCollaborazione.asincronoSimmetrico_registraRichiestaInviata");
  797.                         return esito;
  798.                     }

  800.                     // Non deve essere utilizzato la definizione dell'elemento 'ricezioneRispostaAsincrona'
  801.                     // per ritornare la ricevuta o l'ok.
  802.                     // L'elemento 'ricezioneRispostaAsincrona' sara' utilizzato per ritornare la risposta.
  803.                     richiestaDelegata.setUtilizzoConsegnaAsincrona(false); 


  806.                 }
  807.                 // Risposta Asincrona
  808.                 else{
  809.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico risposta...");
  810.                     
  811.                     scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA;

  813.                     msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_ASINCRONA, riferimentoServizioCorrelato);
  814.                     msgDiag.logPersonalizzato("profiloAsincronoSimmetrico.risposta.correlazioneRichiesta");
  815.                     
  816.                     if(openspcoopstate instanceof OpenSPCoopStateless){
  817.                         
  818.                         if(busta.getScadenza()==null){
  819.                             busta.setScadenza(new Date(DateManager.getTimeMillis()+(scadenzaBusta*60*1000)));
  820.                         }
  821.                         
  822.                         ((StatelessMessage)openspcoopstate.getStatoRichiesta()).setBusta(busta);
  823.                     }
  824.                     
  825.                     // imposto dati risposta
  826.                     try{
  827.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico risposta (lettura busta risposta)...");
  828.                         Busta rispostaAsincrona = profiloCollaborazione.asincronoSimmetrico_getBustaRisposta(riferimentoServizioCorrelato,idMessageRequest,scadenzaBusta);

  830.                         // Check di coerenza
  831.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoSimmetrico risposta (check coerenza)...");
  832.                         if( busta.getTipoMittente().equals(rispostaAsincrona.getTipoDestinatario())==false){
  833.                             throw new ProtocolException("Il tipo di mittente della risposta non rispetta quello atteso nella gestione del profilo asincrono simmetrico.");
  834.                         }
  835.                         if( busta.getMittente().equals(rispostaAsincrona.getDestinatario())==false){
  836.                             throw new ProtocolException("Il mittente della risposta non rispetta quello atteso nella gestione del profilo asincrono simmetrico.");
  837.                         }
  838.                         if( busta.getTipoDestinatario().equals(rispostaAsincrona.getTipoMittente())==false){
  839.                             throw new ProtocolException("Il tipo di destinatario della risposta non rispetta quello atteso nella gestione del profilo asincrono simmetrico.");
  840.                         }
  841.                         if( busta.getDestinatario().equals(rispostaAsincrona.getMittente())==false){
  842.                             throw new ProtocolException("Il destinatario della risposta non rispetta quello atteso nella gestione del profilo asincrono simmetrico.");
  843.                         }
  844.                         if( busta.getTipoServizio().equals(rispostaAsincrona.getTipoServizioCorrelato())==false){
  845.                             throw new ProtocolException("Il tipo del servizio correlato invocato non rispetta quello atteso nella gestione del profilo asincrono simmetrico.");
  846.                         }
  847.                         if( busta.getServizio().equals(rispostaAsincrona.getServizioCorrelato())==false){
  848.                             throw new ProtocolException("Il servizio correlato invocato non rispetta quello atteso nella gestione del profilo asincrono simmetrico.");
  849.                         }
  850.                         /* L'azione della risposta puo' essere diversa da quella della richiesta.
  851.                         if( (busta.getAzione()!=null) &&
  852.                             (busta.getAzione().equals(rispostaAsincrona.getAzione())==false)){
  853.                             throw new ProtocolException("L'azione invocata non rispetta quella attesa nella gestione del profilo asincrono simmetrico.");
  854.                         }
  855.                          */

  857.                         if(protocolManager.isCorrelazioneRichiestaPresenteRispostaAsincronaSimmetrica()){
  858.                             busta.setRiferimentoMessaggio(riferimentoServizioCorrelato);
  859.                         }

  861.                     }catch(ProtocolException e){
  862.                         ErroreIntegrazione erroreIntegrazione = null;
  863.                         IntegrationFunctionError integrationFunctionError = null;
  864.                         this.log.error("Busta per correlazione asincrona simmetrica ("+riferimentoServizioCorrelato+") non trovata",e);
  865.                         if(e.getMessage()!=null && (e.getMessage().indexOf("Busta non trovata")!=-1) || (e.getMessage().indexOf("Tipo/Nome servizio correlato non trovato")!=-1)){
  866.                             msgDiag.logPersonalizzato("profiloAsincronoSimmetrico.rispostaNonCorrelataRichiesta");
  867.                             erroreIntegrazione = ErroriIntegrazione.ERRORE_409_RISPOSTA_ASINCRONA_NON_CORRELATA_ALLA_RICHIESTA.getErroreIntegrazione();
  868.                             integrationFunctionError = IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND;
  869.                         }else{
  870.                             msgDiag.logErroreGenerico(e, "profiloDiCollaborazione.asincronoSimmetrico_getBustaRisposta");
  871.                             erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  872.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO);
  873.                             integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  874.                         }

  876.                         OpenSPCoop2Message responseMessageError = 
  877.                                 generatoreErrore.build(pddContext,integrationFunctionError, erroreIntegrazione,e,null);
  878.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  879.                         openspcoopstate.releaseResource();
  880.                         esito.setEsitoInvocazione(true); 
  881.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  882.                                 "Busta per correlazione asincrona simmetrica ("+riferimentoServizioCorrelato+") non trovata");
  883.                         return esito;
  884.                     }

  886.                     //  Collaborazione (per gli asincroni devono sempre essere presenti)
  887.                     if( idCollaborazione ){
  888.                         if(imbustamentoMsg.getIdCollaborazione()!=null)
  889.                             busta.setCollaborazione(imbustamentoMsg.getIdCollaborazione());
  890.                         else
  891.                             busta.setCollaborazione(riferimentoServizioCorrelato);
  892.                     }
  893.                     
  894.                 }

  896.             }else if(infoServizio.getProfiloDiCollaborazione().equals(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)) {  

  898.                 msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico ...");

  900.                 //  Profilo Asincrono Asimmetrico         
  901.                 busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO); 

  903.                 //  Richiesta Asincrona
  904.                 if(riferimentoServizioCorrelato==null && isServizioCorrelato==false){

  906.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico richiesta...");

  908.                     //  deve essere generato un msg OK se non e' abilitata la funzionalita' di ricevuta asincrona
  909.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico richiesta (ricevuta abilitata)...");
  910.                     richiestaDelegata.setRicevutaAsincrona(configurazionePdDManager.ricevutaAsincronaAsimmetricaAbilitata(pd));
  911.                     
  912.                     // Modalita di trasmissione stateless/stateful
  913.                     if(configurazionePdDManager.isModalitaStateless(pd, infoServizio.getProfiloDiCollaborazione())==false){
  914.                         generazioneMsgOK = !richiestaDelegata.isRicevutaAsincrona();
  915.                     }
  916.                     else{
  917.                         generazioneMsgOK = false;
  918.                     }

  920.                     scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO;

  922.                     // Collaborazione (per gli asincroni devono sempre essere presenti)
  923.                     if( idCollaborazione ){
  924.                         if(imbustamentoMsg.getIdCollaborazione()!=null)
  925.                             busta.setCollaborazione(imbustamentoMsg.getIdCollaborazione());
  926.                         else
  927.                             busta.setCollaborazione(idCollaborazioneCapostipite);
  928.                     }

  930.                     // registrazione richiesta asincrona asimmetrica
  931.                     try{
  932.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico richiesta (registrazione busta da inviare)...");
  933.                         
  934.                         if(configurazionePdDManager.isModalitaStateless(pd, infoServizio.getProfiloDiCollaborazione())){
  935.                             if(busta.getScadenza()==null){
  936.                                 busta.setScadenza(new Date(DateManager.getTimeMillis()+(scadenzaBusta*60*1000)));
  937.                             }
  938.                             if(openspcoopstate instanceof OpenSPCoopStateless){
  939.                                 ((StatelessMessage)openspcoopstate.getStatoRichiesta()).setBusta(busta);
  940.                             }
  941.                         }
  942.                         
  943.                         profiloCollaborazione.asincronoAsimmetrico_registraRichiestaInviata(idMessageRequest,busta.getCollaborazione(),richiestaDelegata.isRicevutaAsincrona(),scadenzaBusta);
  944.                     }catch(ProtocolException e){
  945.                         msgDiag.logErroreGenerico(e, "profiloDiCollaborazione.asincronoAsimmetrico_registraRichiestaInviata");
  946.                         OpenSPCoop2Message responseMessageError = 
  947.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  948.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  949.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,
  950.                                     null);
  951.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  952.                         openspcoopstate.releaseResource();
  953.                         esito.setEsitoInvocazione(true); 
  954.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  955.                                 "profiloDiCollaborazione.asincronoAsimmetrico_registraRichiestaInviata");
  956.                         return esito;
  957.                     }


  960.                 }
  961.                 // Risposta Asincrona
  962.                 else{
  963.                     msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico richiestaStato...");

  965.                     scenarioCooperazione = Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING;

  967.                     msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_ASINCRONA, riferimentoServizioCorrelato);
  968.                     msgDiag.logPersonalizzato("profiloAsincronoAsimmetrico.richiestaStato.correlazioneRichiesta");
  969.                     
  970.                     // il polling e' sempre con gestione della ricevuta
  971.                     richiestaDelegata.setRicevutaAsincrona(true);

  973.                     if(openspcoopstate instanceof OpenSPCoopStateless){
  974.                         
  975.                         if(busta.getScadenza()==null){
  976.                             busta.setScadenza(new Date(DateManager.getTimeMillis()+(scadenzaBusta*60*1000)));
  977.                         }
  978.                         
  979.                         ((StatelessMessage)openspcoopstate.getStatoRichiesta()).setBusta(busta);
  980.                     }
  981.                     
  982.                     // imposto dati risposta
  983.                     try{
  984.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico richiestaStato (lettura busta)...");
  985.                         Busta richiestaStatoAsincrona = profiloCollaborazione.asincronoAsimmetrico_getBustaRisposta(riferimentoServizioCorrelato,idMessageRequest,scadenzaBusta);

  987.                         // Check di coerenza
  988.                         msgDiag.mediumDebug("Gestione profilo di Collaborazione AsincronoAsimmetrico richiestaStato (check coerenza)...");
  989.                         if( busta.getTipoMittente().equals(richiestaStatoAsincrona.getTipoMittente())==false){
  990.                             throw new ProtocolException("Il tipo di mittente della risposta non rispetta quello atteso nella gestione del profilo asincrono asimmetrico.");
  991.                         }
  992.                         if( busta.getMittente().equals(richiestaStatoAsincrona.getMittente())==false){
  993.                             throw new ProtocolException("Il mittente della risposta non rispetta quello atteso nella gestione del profilo asincrono asimmetrico.");
  994.                         }
  995.                         if( busta.getTipoDestinatario().equals(richiestaStatoAsincrona.getTipoDestinatario())==false){
  996.                             throw new ProtocolException("Il tipo di destinatario della risposta non rispetta quello atteso nella gestione del profilo asincrono asimmetrico.");
  997.                         }
  998.                         if( busta.getDestinatario().equals(richiestaStatoAsincrona.getDestinatario())==false){
  999.                             throw new ProtocolException("Il destinatario della risposta non rispetta quello atteso nella gestione del profilo asincrono asimmetrico.");
  1000.                         }
  1001.                         if( busta.getTipoServizio().equals(richiestaStatoAsincrona.getTipoServizioCorrelato())==false){
  1002.                             throw new ProtocolException("Il tipo del servizio correlato invocato non rispetta quello atteso nella gestione del profilo asincrono asimmetrico.");
  1003.                         }
  1004.                         if( busta.getServizio().equals(richiestaStatoAsincrona.getServizioCorrelato())==false){
  1005.                             throw new ProtocolException("Il servizio correlato invocato non rispetta quello atteso nella gestione del profilo asincrono asimmetrico.");
  1006.                         }
  1007.                         /* L'azione della richiestaStato puo' essere diversa da quella della richiesta.
  1008.                         if( (busta.getAzione()!=null) &&
  1009.                             (busta.getAzione().equals(richiestaStatoAsincrona.getAzione())==false)){
  1010.                             throw new ProtocolException("L'azione invocata non rispetta quella attesa nella gestione del profilo asincrono asimmetrico.");
  1011.                         }
  1012.                          */

  1014.                         if(protocolManager.isCorrelazioneRichiestaPresenteRichiestaStatoAsincronaAsimmetrica()){
  1015.                             busta.setRiferimentoMessaggio(riferimentoServizioCorrelato);
  1016.                         }

  1018.                     }catch(ProtocolException e){
  1019.                         ErroreIntegrazione erroreIntegrazione = null;
  1020.                         IntegrationFunctionError integrationFunctionError = null;
  1021.                         this.log.error("Busta per correlazione asincrona asimmetrica ("+riferimentoServizioCorrelato+") non trovata",e);
  1022.                         if(e.getMessage()!=null && e.getMessage().indexOf("Busta non trovata")!=-1){
  1023.                             msgDiag.logPersonalizzato("profiloAsincronoAsimmetrico.richiestaStatoNonCorrelataRichiesta");
  1024.                             erroreIntegrazione = ErroriIntegrazione.ERRORE_409_RISPOSTA_ASINCRONA_NON_CORRELATA_ALLA_RICHIESTA.getErroreIntegrazione();
  1025.                             integrationFunctionError = IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND;
  1026.                         }else{
  1027.                             msgDiag.logErroreGenerico(e, "profiloDiCollaborazione.asincronoAsimmetrico_getBustaRisposta");
  1028.                             erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1029.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO);
  1030.                             integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1031.                         }
  1032.                         OpenSPCoop2Message responseMessageError = 
  1033.                                 generatoreErrore.build(pddContext,integrationFunctionError,erroreIntegrazione,e,null);
  1034.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  1035.                         openspcoopstate.releaseResource(); 
  1036.                         esito.setEsitoInvocazione(true); 
  1037.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1038.                                 "Busta per correlazione asincrona asimmetrica ("+riferimentoServizioCorrelato+") non trovata");
  1039.                         return esito;
  1040.                     }

  1042.                     //  Collaborazione (per gli asincroni devono sempre essere presenti)
  1043.                     if( idCollaborazione ){
  1044.                         if(imbustamentoMsg.getIdCollaborazione()!=null)
  1045.                             busta.setCollaborazione(imbustamentoMsg.getIdCollaborazione());
  1046.                         else
  1047.                             busta.setCollaborazione(riferimentoServizioCorrelato);
  1048.                     }

  1050.                 }

  1052.             }   else{

  1054.                 // Profilo non conosciuto??
  1055.                 msgDiag.logErroreGenerico("Profilo di Collaborazione ["+infoServizio.getProfiloDiCollaborazione()+"] non gestito", "gestioneProfiloCollaborazione");
  1056.                 OpenSPCoop2Message responseMessageError = 
  1057.                         generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1058.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1059.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),null,null);
  1060.                 ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  1061.                 openspcoopstate.releaseResource();
  1062.                 esito.setEsitoInvocazione(true); 
  1063.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1064.                         "Profilo di Collaborazione ["+infoServizio.getProfiloDiCollaborazione()+"] non gestito");
  1065.                 return esito;
  1066.             }

  1068.             richiestaDelegata.setScenario(scenarioCooperazione);
  1069.             ejbUtils.setScenarioCooperazione(scenarioCooperazione);
  1070.             richiestaDelegata.setIdCollaborazione(busta.getCollaborazione());
  1071.             richiestaDelegata.setProfiloCollaborazione(busta.getProfiloDiCollaborazione(),busta.getProfiloDiCollaborazioneValue());


  1074.             boolean stateless = configurazionePdDManager.isModalitaStateless(pd, infoServizio.getProfiloDiCollaborazione());
  1075.                         
  1076.             if (!oneWayVersione11 && !stateless) {
  1077.                 
  1078.                 /* ------------  Registro busta nel Repository Buste ------------- */
  1079.                 msgDiag.mediumDebug("Aggiornamento busta nel RepositoryBuste...");
  1080.                 try{
  1081.                     repositoryBuste.aggiornaBustaIntoOutBox(busta,this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  1082.                     repositoryBuste.aggiornaInfoIntegrazioneIntoOutBox_Scenario(busta.getID(),scenarioCooperazione);
  1083.                 }catch(ProtocolException e){
  1084.                     msgDiag.logErroreGenerico(e, "repositoryBuste.aggiornaBusta/InfoIntegrazione_IntoOutBox");
  1085.                     OpenSPCoop2Message responseMessageError = 
  1086.                             generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1087.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1088.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e, null);
  1089.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  1090.                     openspcoopstate.releaseResource();
  1091.                     esito.setEsitoInvocazione(true); 
  1092.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1093.                             "repositoryBuste.aggiornaBusta/InfoIntegrazione_IntoOutBox");
  1094.                     return esito;
  1095.                 }

  1097.             }




  1102.             /* ------------  Ricezione riscontri per il NAL 
  1103.                       (vengono gestiti solo se la busta contiene un profilo oneWay)  ------------- */
  1104.             if( consegnaAffidabile ){
  1105.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(infoServizio.getProfiloDiCollaborazione())) {

  1107.                     msgDiag.logPersonalizzato("consegnaAffidabile.salvataggioInformazioni");
  1108.                     try{
  1109.                         gestoreRiscontri.registraRiscontroDaRicevere( busta.getID() , DateManager.getDate());
  1110.                     }catch(ProtocolException e){
  1111.                         msgDiag.logErroreGenerico(e, "gestoreRiscontri.registraRiscontroDaRicevere");
  1112.                         OpenSPCoop2Message responseMessageError = 
  1113.                                 generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1114.                                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1115.                                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e, null);
  1116.                         ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  1117.                         openspcoopstate.releaseResource();
  1118.                         esito.setEsitoInvocazione(true); 
  1119.                         esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1120.                                 "gestoreRiscontri.registraRiscontroDaRicevere");
  1121.                         return esito;
  1122.                     }
  1123.                 }else{
  1124.                     msgDiag.logPersonalizzato("consegnaAffidabile.profiloNonOneway");
  1125.                 }
  1126.             }



  1130.             Utilities.printFreeMemory("Imbustamento - Invio messaggio al modulo di InoltroBuste...");



  1134.             /* ------------  Spedizione InoltroBusteMessage al modulo InoltroBuste   ------------- */

  1136.             // Creazione InoltroBusteMessage
  1137.             // (infoBusta da spedire)
  1138.             msgDiag.mediumDebug("Invio messaggio al modulo di InoltroBuste...");
  1139.             InoltroBusteMessage inoltroMSG = new InoltroBusteMessage();
  1140.             inoltroMSG.setRichiestaDelegata(richiestaDelegata);
  1141.             inoltroMSG.setBusta(busta);
  1142.             inoltroMSG.setOneWayVersione11(oneWayVersione11);
  1143.             inoltroMSG.setImplementazionePdDSoggettoMittente(imbustamentoMsg.getImplementazionePdDSoggettoMittente());
  1144.             inoltroMSG.setImplementazionePdDSoggettoDestinatario(imbustamentoMsg.getImplementazionePdDSoggettoDestinatario());
  1145.             inoltroMSG.setPddContext(pddContext);
  1146.             
  1147.             msgRequest = new GestoreMessaggi(openspcoopstate, true, idMessageRequest,Costanti.OUTBOX,msgDiag,pddContext);

  1149.             // send. Se la porta applicativa funziona in modalita' stateful v11 il messaggio JMS viene arricchito con
  1150.             //       un oggetto di tipo OpenSPCoopStateless

  1152.             if ( !stateless  ) {
  1153.                 if ( oneWayVersione11 ) {
  1154.                     OpenSPCoopStateless statelessSerializzabile = ((OpenSPCoopStateless) openspcoopstate).rendiSerializzabile();
  1155.                     inoltroMSG.setOpenspcoopstate(statelessSerializzabile);
  1156.                     msgRequest.setOneWayVersione11(true);
  1157.                 }
  1158.         
  1159.                 try{
  1160.                     ejbUtils.getNodeSender(this.propertiesReader, this.log).send(inoltroMSG, InoltroBuste.ID_MODULO, msgDiag, 
  1161.                             identitaPdD,Imbustamento.ID_MODULO, idMessageRequest, msgRequest);
  1162.                 } catch (Exception e) {
  1163.                     this.log.error("Spedizione->InoltroBuste non riuscita",e);
  1164.                     msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send(InoltroBuste)");
  1165.                     OpenSPCoop2Message responseMessageError = 
  1166.                             generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1167.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1168.                                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),e, null);
  1169.                     ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  1170.                     openspcoopstate.releaseResource(); 
  1171.                     esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,
  1172.                             "Spedizione->InoltroBuste non riuscita");
  1173.                     esito.setEsitoInvocazione(true); 
  1174.                     return esito;
  1175.                 }
  1176.             }


  1179.             Utilities.printFreeMemory("Imbustamento - Gestione Risposta");

  1181.             /* ------------  Gestione Risposta  ------------- */
  1182.             // se il profilo e' oneWay, AsincronoSimmetrico o AsincronoAsimmetricoRichiesta  viene generata una risposta SOAP 'OK'
  1183.             // inizializzo richiesta
  1184.             if(  generazioneMsgOK ) {
  1185.                 
  1186.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.DATA_PRESA_IN_CARICO, 
  1187.                         DateUtils.getSimpleDateFormatMs().format(DateManager.getDate()));
  1188.                 
  1189.                 msgDiag.mediumDebug("Invio messaggio 'OK' al modulo di RicezioneContenutiApplicativi...");
  1190.                 if(protocolManager.isHttpEmptyResponseOneWay())
  1191.                     msgOK = ejbUtils.sendRispostaApplicativaOK(MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  1192.                             requestInfo.getIntegrationRequestMessageType(), MessageRole.RESPONSE),richiestaDelegata,pd,sa);
  1193.                 else
  1194.                     msgOK = ejbUtils.sendRispostaApplicativaOK(ejbUtils.buildOpenSPCoopOK(requestInfo.getIntegrationRequestMessageType(), idMessageRequest),richiestaDelegata,pd,sa);
  1195.             }















  1211.             /* ---------- Gestione Transazione Modulo ---------------- */

  1213.             // Aggiorno proprietario Messaggio e Scenario di cooperazione
  1214.             msgDiag.mediumDebug("Aggiorno proprietario messaggio...");
  1215.             msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.mdb.InoltroBuste.ID_MODULO);

  1217.             // Commit JDBC

  1219.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta...");
  1220.             openspcoopstate.commit();

  1222.             // Aggiornamento cache messaggi
  1223.             if(msgRequest!=null)
  1224.                 msgRequest.addMessaggiIntoCache_readFromTable(Imbustamento.ID_MODULO, "richiesta");
  1225.             if(msgOK!=null)
  1226.                 msgOK.addMessaggiIntoCache_readFromTable(Imbustamento.ID_MODULO, "messaggio OK");

  1228.             //  Aggiornamento cache proprietario messaggio
  1229.             if(msgRequest!=null)
  1230.                 msgRequest.addProprietariIntoCache_readFromTable(Imbustamento.ID_MODULO, "richiesta",null,false);
  1231.             if(msgOK!=null)
  1232.                 msgOK.addProprietariIntoCache_readFromTable(Imbustamento.ID_MODULO, "messaggio OK",idMessageRequest,false);


  1235.             // Rilascio connessione al DB
  1236.             msgDiag.mediumDebug("Rilascio connessione al database...");
  1237.             openspcoopstate.releaseResource();

  1239.             msgDiag.mediumDebug("Lavoro Terminato.");
  1240.             esito.setEsitoInvocazione(true);
  1241.             esito.setStatoInvocazione(EsitoLib.OK,null);
  1242.             if (stateless) ((OpenSPCoopState)openspcoopstate).setMessageLib(inoltroMSG);
  1243.             return esito; 


  1246.         }catch(Throwable e){
  1247.             this.log.error("ErroreGenerale",e);
  1248.             msgDiag.logErroreGenerico(e, "Generale");
  1249.             
  1250.             OpenSPCoop2Message responseMessageError = 
  1251.                     generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1252.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),e,null);
  1253.             try{
  1254.                 ejbUtils.sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,pd,sa);
  1255.                 esito.setStatoInvocazione(EsitoLib.ERRORE_GESTITO,"ErroreGenerale");
  1256.                 esito.setEsitoInvocazione(true);
  1257.             }catch(Exception er){
  1258.                 msgDiag.logErroreGenerico(er,"ejbUtils.sendErroreGenerale");
  1259.                 ejbUtils.rollbackMessage("Spedizione Errore al Mittente durante una richiesta non riuscita", esito);
  1260.                 esito.setEsitoInvocazione(false);
  1261.                 esito.setStatoInvocazioneErroreNonGestito(e);
  1262.             }    
  1263.             openspcoopstate.releaseResource();
  1264.             return esito;
  1265.         }

  1267.     }
  1268. }
Created with JaCoCo 0.8.8.202204050719