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




  24. package org.openspcoop2.pdd.core;

  26. import java.sql.Timestamp;
  27. import java.util.ArrayList;
  28. import java.util.Date;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import javax.xml.soap.SOAPBody;

  35. import org.openspcoop2.core.config.GestioneErrore;
  36. import org.openspcoop2.core.config.PortaApplicativa;
  37. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  38. import org.openspcoop2.core.config.PortaDelegata;
  39. import org.openspcoop2.core.config.ServizioApplicativo;
  40. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  41. import org.openspcoop2.core.config.constants.TipoBehaviour;
  42. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  43. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  44. import org.openspcoop2.core.constants.TipoPdD;
  45. import org.openspcoop2.core.eccezione.details.DettaglioEccezione;
  46. import org.openspcoop2.core.id.IDServizio;
  47. import org.openspcoop2.core.id.IDServizioApplicativo;
  48. import org.openspcoop2.core.id.IDSoggetto;
  49. import org.openspcoop2.core.integrazione.EsitoRichiesta;
  50. import org.openspcoop2.core.integrazione.utils.EsitoRichiestaXMLUtils;
  51. import org.openspcoop2.core.transazioni.IdTransazioneApplicativoServer;
  52. import org.openspcoop2.core.transazioni.TransazioneApplicativoServer;
  53. import org.openspcoop2.message.OpenSPCoop2Message;
  54. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  55. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  56. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  57. import org.openspcoop2.message.constants.MessageRole;
  58. import org.openspcoop2.message.constants.MessageType;
  59. import org.openspcoop2.message.exception.ParseException;
  60. import org.openspcoop2.message.utils.MessageUtilities;
  61. import org.openspcoop2.pdd.config.ClassNameProperties;
  62. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  63. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  64. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  65. import org.openspcoop2.pdd.config.RichiestaDelegata;
  66. import org.openspcoop2.pdd.config.SoggettoVirtuale;
  67. import org.openspcoop2.pdd.core.behaviour.Behaviour;
  68. import org.openspcoop2.pdd.core.behaviour.BehaviourForwardTo;
  69. import org.openspcoop2.pdd.core.behaviour.BehaviourForwardToConfiguration;
  70. import org.openspcoop2.pdd.core.behaviour.BehaviourForwardToFilter;
  71. import org.openspcoop2.pdd.core.behaviour.BehaviourLoadBalancer;
  72. import org.openspcoop2.pdd.core.behaviour.BehaviourLoader;
  73. import org.openspcoop2.pdd.core.behaviour.IBehaviour;
  74. import org.openspcoop2.pdd.core.behaviour.StatoFunzionalita;
  75. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.ConfigurazioneGestioneConsegnaNotifiche;
  76. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.GestioneConsegnaNotificheUtils;
  77. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MessaggioDaNotificare;
  78. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverBehaviour;
  79. import org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverUtils;
  80. import org.openspcoop2.pdd.core.handlers.HandlerException;
  81. import org.openspcoop2.pdd.core.node.INodeSender;
  82. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  83. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  84. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  85. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  86. import org.openspcoop2.pdd.core.transazioni.GestoreConsegnaMultipla;
  87. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  88. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  89. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  90. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  91. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiBehaviourMessage;
  92. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiMessage;
  93. import org.openspcoop2.pdd.mdb.EsitoLib;
  94. import org.openspcoop2.pdd.mdb.InoltroRisposte;
  95. import org.openspcoop2.pdd.mdb.InoltroRisposteMessage;
  96. import org.openspcoop2.pdd.services.ServicesUtils;
  97. import org.openspcoop2.pdd.services.core.RicezioneBusteMessage;
  98. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativiMessage;
  99. import org.openspcoop2.pdd.services.error.AbstractErrorGenerator;
  100. import org.openspcoop2.pdd.services.error.RicezioneBusteExternalErrorGenerator;
  101. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  102. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  103. import org.openspcoop2.protocol.engine.builder.DettaglioEccezioneOpenSPCoop2Builder;
  104. import org.openspcoop2.protocol.engine.builder.Imbustamento;
  105. import org.openspcoop2.protocol.engine.constants.Costanti;
  106. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  107. import org.openspcoop2.protocol.engine.driver.RollbackRepositoryBuste;
  108. import org.openspcoop2.protocol.sdk.Busta;
  109. import org.openspcoop2.protocol.sdk.Eccezione;
  110. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  111. import org.openspcoop2.protocol.sdk.Integrazione;
  112. import org.openspcoop2.protocol.sdk.ProtocolException;
  113. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  114. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  115. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  116. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  117. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  118. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  119. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  120. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  121. import org.openspcoop2.protocol.sdk.state.IState;
  122. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  123. import org.openspcoop2.protocol.sdk.state.StateMessage;
  124. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  125. import org.openspcoop2.utils.LoggerWrapperFactory;
  126. import org.openspcoop2.utils.UtilsException;
  127. import org.openspcoop2.utils.date.DateManager;
  128. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  129. import org.openspcoop2.utils.resources.Loader;
  130. import org.openspcoop2.utils.transport.http.HttpConstants;
  131. import org.slf4j.Logger;


  134. /**
  135.  * Libreria contenente metodi utili per lo smistamento delle buste 
  136.  * all'interno dei moduli EJB di openspcoop.
  137.  *
  138.  * @author Poli Andrea (apoli@link.it)
  139.  * @author $Author$
  140.  * @version $Rev$, $Date$
  141.  */

  143. public class EJBUtils {

  145.     /** Logger utilizzato per debug. */
  146.     private Logger log = null;

  148.     private IOpenSPCoopState openSPCoopState;

  150.     /** Indicazione sul modulo  */
  151.     private String idModulo = null;
  152.     /** Tipo di Porta */
  153.     private TipoPdD tipoPdD;
  154.     /** Indicazione sul codice porta  */
  155.     private IDSoggetto identitaPdD = null;
  156.     /** Identificativo generato per la richiesta ed utilizzato per collegare la gestione del servizio richiesto, 
  157.     tra i vari nodi dell'infrastruttura openspcoop. */
  158.     private String idSessione;
  159.     /** Identificativo del messaggio in gestione 
  160.     (questo id coincide con l'id della sessione nella richiesta ma non nella risposta) */
  161.     private String idMessage;
  162.     /** Tipo di Messaggio (INBOX/OUTBOX) */
  163.     private String tipo;
  164.     /** Scenario di Cooperazione */
  165.     private String scenarioCooperazione;
  166.     /** MessaggioDiagnostico */
  167.     private MsgDiagnostico msgDiag;
  168.     
  169.     /** Indicazione se siamo in modalita oneway11 */
  170.     private boolean oneWayVersione11 = false;
  171.     /** Indicazione se la porta delegata/applicativa richiesta una modalita stateless (oneway o sincrono) 
  172.      *  Il caso oneway11 possiedera questo booleano con il valore false.
  173.      * */
  174.     private boolean portaDiTipoStateless_esclusoOneWay11;
  175.     /** Indicazione se deve essere gestita la richiesta in caso di errore */
  176.     private boolean rollbackRichiestaInCasoErrore = true;
  177.     /** Indicazione se deve essere gestita la richiesta in caso di errore */
  178.     private boolean rollbackRichiestaInCasoErrore_rollbackHistory = true;
  179.     /** Indicazione se siamo in modalita di routing */
  180.     private boolean routing;
  181.     
  182.     
  183.     /** PropertiesReader */
  184.     private OpenSPCoop2Properties propertiesReader;
  185.     /** ConfigurazionePdDReader */
  186.     private ConfigurazionePdDManager configurazionePdDReader;
  187.     /** Indicazione se la classe viene utilizzata dal router */
  188.     private boolean functionAsRouter = false;
  189.     
  190.     /** Gestione tempi di attraversamento */
  191.     private Timestamp spedizioneMsgIngresso;
  192.     private Timestamp ricezioneMsgRisposta;

  194.     /** Reply on new Connection: buste, escluse le buste di risposta sincrona */
  195.     private boolean replyOnNewConnection;
  196.     /** Utilizzo indirizzo telematico: utilizzo dell'indirizzo telematico */
  197.     private boolean utilizzoIndirizzoTelematico;

  199.     /** Tipologia di porta di domino del soggetto mittente */
  200.     private String implementazionePdDSoggettoMittente;
  201.     /** Tipologia di porta di domino del soggetto destinatario */
  202.     private String implementazionePdDSoggettoDestinatario;
  203.     
  204.     /** ServizioApplicativo erogatore */
  205.     private String servizioApplicativoErogatore;
  206.     
  207.     /** PdDContext */
  208.     private PdDContext pddContext;
  209.     public void setPddContext(PdDContext pddContext) {
  210.         this.pddContext = pddContext;
  211.     }
  212.     
  213.     /** OLD Function Name */
  214.     private String oldFunctionName;

  216.     /** INodeSender */
  217.     private INodeSender nodeSender = null;

  219.     /** ProtocolFactory */
  220.     private IProtocolFactory<?> protocolFactory = null;
  221.     private IProtocolVersionManager protocolManager = null;
  222.     
  223.     /** DettaglioEccezioneOpenSPCoop2Builder */
  224.     private DettaglioEccezioneOpenSPCoop2Builder dettaglioBuilder = null;
  225.     
  226.     /** RicezioneBusteExternalErrorGenerator */
  227.     private RicezioneBusteExternalErrorGenerator generatoreErrorePortaApplicativa = null;
  228.     private IntegrationFunctionError _integrationFunctionErrorPortaApplicativa;
  229.     private IntegrationFunctionError getIntegrationFunctionErrorPortaApplicativa(boolean erroreValidazione) {
  230.         if(this._integrationFunctionErrorPortaApplicativa!=null) {
  231.             return this._integrationFunctionErrorPortaApplicativa;
  232.         }
  233.         else {
  234.             IntegrationFunctionError ife = AbstractErrorGenerator.getIntegrationInternalError(this.pddContext); // default
  235.             if(erroreValidazione) {
  236.                 ife = IntegrationFunctionError.INTERNAL_RESPONSE_ERROR.equals(ife) ? 
  237.                         IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_RESPONSE :
  238.                         IntegrationFunctionError.INVALID_INTEROPERABILITY_PROFILE_REQUEST;
  239.             }
  240.             return ife;
  241.         }
  242.     }
  243.     public void setGeneratoreErrorePortaApplicativa(RicezioneBusteExternalErrorGenerator generatoreErrorePortaApplicativa) {
  244.         this.generatoreErrorePortaApplicativa = generatoreErrorePortaApplicativa;
  245.     }
  246.     public void setIntegrationFunctionErrorPortaApplicativa(IntegrationFunctionError integrationErrorPortaApplicativa) {
  247.         this._integrationFunctionErrorPortaApplicativa = integrationErrorPortaApplicativa;
  248.     }

  250.     public synchronized void initializeNodeSender(OpenSPCoop2Properties propertiesReader,Logger logCore) throws EJBUtilsException{
  251.         if(this.nodeSender!=null)
  252.             return; // inizializzato da un altro thread

  254.         // Inizializzazione NodeSender
  255.         String classTypeNodeSender = null;
  256.         try{
  257.             classTypeNodeSender = ClassNameProperties.getInstance().getNodeSender(propertiesReader.getNodeSender());
  258.             this.nodeSender = (INodeSender) Loader.getInstance().newInstance(classTypeNodeSender);
  259.             AbstractCore.init(this.nodeSender, this.pddContext, this.protocolFactory);
  260.             logCore.info("Inizializzazione gestore NodeSender di tipo "+classTypeNodeSender+" effettuata.");
  261.         }catch(Exception e){
  262.             throw new EJBUtilsException("Riscontrato errore durante il caricamento della classe ["+classTypeNodeSender+
  263.                     "] da utilizzare per la spedizione nell'infrastruttura: "+e.getMessage());
  264.         }
  265.     }

  267.     public INodeSender getNodeSender(OpenSPCoop2Properties propertiesReader,Logger log)throws EJBUtilsException{
  268.         if(this.nodeSender==null)
  269.             this.initializeNodeSender(propertiesReader, log);
  270.         return this.nodeSender;
  271.     }



  275.     /**
  276.      * Costruttore
  277.      *
  278.      * @param identitaPdD Codice del dominio che sta gestendo la richiesta.
  279.      * @param aIDModulo Identificativo del Sender.
  280.      * @param idSessione Identificativo generato per la richiesta ed utilizzato per collegare la gestione del servizio richiesto, 
  281.      *        tra i vari nodi dell'infrastruttura openspcoop (serve per la spedizione verso altri moduli).
  282.      * @param idMessage Identificativo del messaggio in gestione 
  283.      *        (questo id coincide con l'id della sessione nella richiesta ma non nella risposta)
  284.      * @param tipo di Messaggio (INBOX/OUTBOX)
  285.      * @param openspcoop_state
  286.      * 
  287.      */
  288.     public EJBUtils(IDSoggetto identitaPdD,TipoPdD tipoPdD,String aIDModulo,String idSessione,
  289.             String idMessage,String tipo, IOpenSPCoopState openspcoop_state ,MsgDiagnostico msgDiag,boolean functionAsRouter,
  290.             String implementazionePdDSoggettoMittente, String implementazionePdDSoggettoDestinatario,
  291.             String profiloGestione,PdDContext pddContext) throws EJBUtilsException {
  292.         this.identitaPdD = identitaPdD;
  293.         this.tipoPdD = tipoPdD;
  294.         this.idModulo = aIDModulo;
  295.         this.idSessione = idSessione;
  296.         this.idMessage = idMessage; 
  297.         this.tipo = tipo;
  298.         this.openSPCoopState = openspcoop_state;
  299.         this.functionAsRouter = functionAsRouter;
  300.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  301.         if(this.log==null){
  302.             this.log = LoggerWrapperFactory.getLogger(EJBUtils.class);
  303.         }
  304.         this.msgDiag = msgDiag;
  305.         this.propertiesReader = OpenSPCoop2Properties.getInstance();
  306.         if(openspcoop_state==null)
  307.             this.configurazionePdDReader = ConfigurazionePdDManager.getInstance();
  308.         else
  309.             this.configurazionePdDReader = ConfigurazionePdDManager.getInstance(openspcoop_state.getStatoRichiesta(),openspcoop_state.getStatoRisposta());

  311.         this.implementazionePdDSoggettoMittente = implementazionePdDSoggettoMittente;
  312.         this.implementazionePdDSoggettoDestinatario = implementazionePdDSoggettoDestinatario;
  313.         
  314.         this.pddContext = pddContext;
  315.         
  316.         try{
  317.             this.protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  318.             this.protocolManager = this.protocolFactory.createProtocolVersionManager(profiloGestione);
  319.             this.dettaglioBuilder = new DettaglioEccezioneOpenSPCoop2Builder(this.log, this.protocolFactory);
  320.         }catch(Exception e){
  321.             throw new EJBUtilsException(e.getMessage(),e);
  322.         }
  323.         
  324.         // richiede all'interno pddContext e protocolFactory
  325.         this.initializeNodeSender(this.propertiesReader, this.log);
  326.         
  327.     }
  328.     public void setIdMessage(String idMessage) {
  329.         this.idMessage = idMessage;
  330.     }

  332.     private void setEJBSuffixFunctionName(){
  333.         if(this.msgDiag!=null){
  334.             this.oldFunctionName = this.msgDiag.getFunzione();
  335.             this.msgDiag.setFunzione(this.msgDiag.getFunzione()+".EJBUtils");
  336.         }
  337.     }
  338.     private void unsetEJBSuffixFunctionName(){
  339.         if(this.msgDiag!=null && this.oldFunctionName!=null){
  340.             this.msgDiag.setFunzione(this.oldFunctionName);
  341.         }
  342.     }


  345.     /**
  346.      * Aggiorna openspcoop_state
  347.      *
  348.      * 
  349.      * 
  350.      */
  351.     public void updateOpenSPCoopState(IOpenSPCoopState openSPCoopState){
  352.         this.openSPCoopState = openSPCoopState;
  353.     }


  356.     /**
  357.      * Imposta l'identificativo di Sessione
  358.      *
  359.      * @param id identificativo di Sessione
  360.      * 
  361.      */
  362.     public void updateIdSessione(String id){
  363.         this.idSessione = id;
  364.     }
  365.     /**
  366.      * Imposta l'utilizzo della reply su una nuova connessione.
  367.      *
  368.      * @param replyOnNewConnection Utilizzo della reply su una nuova connessione.
  369.      * 
  370.      */
  371.     public void setReplyOnNewConnection(boolean replyOnNewConnection) {
  372.         this.replyOnNewConnection = replyOnNewConnection;
  373.     }
  374.     /**
  375.      * Imposta l'utilizzo di un eventuale indirizzo telematico.
  376.      *
  377.      * @param utilizzoIndirizzoTelematico utilizzo di un eventuale indirizzo telematico.
  378.      * 
  379.      */
  380.     public void setUtilizzoIndirizzoTelematico(boolean utilizzoIndirizzoTelematico) {
  381.         this.utilizzoIndirizzoTelematico = utilizzoIndirizzoTelematico;
  382.     }














  397.     /** ------------------- Metodi utilizzati per rilasciare le risorse con errore all'interno dell'EJB ---------------- */    

  399.     /*  Tutti questi metodi lavorano senza il riferimento all' ctxEJB perche' il rollback JMS viene delegato al chiamante
  400.      * */
  401.     public void rollbackMessage(String motivoRollbackEJB, EsitoLib esito){

  403.         this.setEJBSuffixFunctionName();
  404.         try{

  406.             // Imposto Motivo dell'errore
  407.             GestoreMessaggi msg = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  408.             msg.setOneWayVersione11(this.oneWayVersione11);
  409.             msg.aggiornaErroreProcessamentoMessaggio(motivoRollbackEJB, null);

  411.             esito.setErroreProcessamentoMessaggioAggiornato(true);
  412.             
  413.         }catch(Exception e){

  415.             this.msgDiag.logErroreGenerico(e, "EJBUtils.rollbackMessage(motivoRollbackEJB)");

  417.         }finally{
  418.             this.unsetEJBSuffixFunctionName();
  419.         }
  420.     }

  422.     public void rollbackMessage(String motivoRollbackEJB, String servizioApplicativo, EsitoLib esito){
  423.         rollbackMessage(motivoRollbackEJB, servizioApplicativo, esito, true);
  424.     }
  425.     public void rollbackMessage(String motivoRollbackEJB, String servizioApplicativo, EsitoLib esito, boolean throwExceptionConnectionNull){

  427.         this.setEJBSuffixFunctionName();
  428.         try{

  430.             // Imposto Motivo dell'errore - lavora sempre sulla richiesta
  431.             GestoreMessaggi msg = new GestoreMessaggi(this.openSPCoopState, true ,this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  432.             msg.setOneWayVersione11(this.oneWayVersione11);
  433.             msg.aggiornaErroreProcessamentoMessaggio(motivoRollbackEJB, servizioApplicativo, throwExceptionConnectionNull);

  435.             esito.setErroreProcessamentoMessaggioAggiornato(true);
  436.             
  437.         }catch(Exception e){

  439.             this.msgDiag.logErroreGenerico(e, "EJBUtils.rollbackMessage(motivoRollbackEJB,servizioApplicativo)");

  441.         }finally{
  442.             this.unsetEJBSuffixFunctionName();
  443.         }
  444.     }

  446.     public void rollbackMessage(String motivoRollbackEJB, Timestamp dataRiconsegna, String servizioApplicativo, EsitoLib esito){

  448.         this.setEJBSuffixFunctionName();
  449.         try{

  451.             // Imposto Motivo dell'errore
  452.             GestoreMessaggi msg = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  453.             msg.setOneWayVersione11(this.oneWayVersione11);
  454.             msg.aggiornaErroreProcessamentoMessaggio(motivoRollbackEJB, servizioApplicativo);

  456.             esito.setErroreProcessamentoMessaggioAggiornato(true);
  457.             
  458.             if(dataRiconsegna!=null){
  459.                 msg.aggiornaDataRispedizione(dataRiconsegna,servizioApplicativo);
  460.                 
  461.                 esito.setDataRispedizioneAggiornata(dataRiconsegna);
  462.             }

  464.         }catch(Exception e){

  466.             this.msgDiag.logErroreGenerico(e, "EJBUtils.rollbackMessage(motivoRollbackEJB,dataRiconsegna,servizioApplicativo)");

  468.         }finally{
  469.             this.unsetEJBSuffixFunctionName();
  470.         }
  471.     }


  474.     public void rollbackMessage(String motivoRollbackEJB, Timestamp dataRiconsegna, EsitoLib esito){

  476.         this.setEJBSuffixFunctionName();
  477.         try{

  479.             // Imposto Motivo dell'errore
  480.             GestoreMessaggi msg = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  481.             msg.setOneWayVersione11(this.oneWayVersione11);
  482.             msg.aggiornaErroreProcessamentoMessaggio(motivoRollbackEJB, null);

  484.             esito.setErroreProcessamentoMessaggioAggiornato(true);
  485.             
  486.             if(dataRiconsegna!=null){
  487.                 msg.aggiornaDataRispedizione(dataRiconsegna,null);
  488.                 
  489.                 esito.setDataRispedizioneAggiornata(dataRiconsegna);
  490.             }

  492.         }catch(Exception e){

  494.             this.msgDiag.logErroreGenerico(e, "EJBUtils.rollbackMessage(motivoRollbackEJB,dataRiconsegna)");

  496.         }finally{
  497.             this.unsetEJBSuffixFunctionName();
  498.         }
  499.     }

  501.     /**
  502.      * Rappresenta una situazione in cui un EJB deve mantenere in coda il messaggio che ha provato a gestire, a causa di errori
  503.      * 
  504.      * @param motivoRollbackEJB Motivo dell'errore che ha causato il Rollback sull'EJB
  505.      * 
  506.      */
  507.     public void updateErroreProcessamentoMessage(String motivoRollbackEJB, EsitoLib esito){
  508.         updateErroreProcessamentoMessage(motivoRollbackEJB,null,esito);
  509.     }
  510.     /**
  511.      * Rappresenta una situazione in cui un EJB deve mantenere in coda il messaggio che ha provato a gestire, a causa di errori
  512.      * 
  513.      * @param motivoRollbackEJB Motivo dell'errore che ha causato il Rollback sull'EJB
  514.      * @param dataRispedizione Data per la rispedizione del msg
  515.      * 
  516.      */
  517.     public void updateErroreProcessamentoMessage(String motivoRollbackEJB, java.sql.Timestamp dataRispedizione, EsitoLib esito){

  519.         this.setEJBSuffixFunctionName();
  520.         try{

  522.             // Imposto Motivo dell'errore
  523.             GestoreMessaggi msg = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  524.             msg.setOneWayVersione11(this.oneWayVersione11);
  525.             msg.aggiornaErroreProcessamentoMessaggio(motivoRollbackEJB,null);
  526.             
  527.             esito.setErroreProcessamentoMessaggioAggiornato(true);
  528.             
  529.             if(dataRispedizione!=null){
  530.                 msg.aggiornaDataRispedizione(dataRispedizione,null);
  531.                 
  532.                 esito.setDataRispedizioneAggiornata(dataRispedizione);  
  533.             }

  535.         }catch(Exception e){

  537.             this.msgDiag.logErroreGenerico(e, "EJBUtils.updateErroreProcessamentoMessage");

  539.         }finally{
  540.             this.unsetEJBSuffixFunctionName();
  541.         }
  542.     }









  552.     /** ------------------- Metodi utilizzati per rilasciare le risorse all'interno dell'EJB ---------------- */    



  556.     /**
  557.      * Rilascia un messaggio precedentemente salvato, e 
  558.      * effettua anche un rollback di un OutBox Message utilizzando l'id del Messaggio
  559.      *
  560.      * 
  561.      */
  562.     public void releaseOutboxMessage(boolean isMessaggioRichiesta) throws EJBUtilsException{
  563.         releaseMessage(true,false,null,null,true, isMessaggioRichiesta);
  564.     }

  566.     /**
  567.      * Rilascia un messaggio precedentemente salvato, e 
  568.      * effettua anche un rollback di un OutBox Message utilizzando l'id del Messaggio
  569.      *
  570.      * 
  571.      */
  572.     public void releaseOutboxMessage(boolean cleanHistory, boolean isMessaggioRichiesta) throws EJBUtilsException{
  573.         releaseMessage(true,false,null,null,cleanHistory, isMessaggioRichiesta);
  574.     }

  576.     /**
  577.      * Rilascia un messaggio precedentemente salvato, 
  578.      * e effettua anche un rollback di un OutBox Message utilizzando l'id del Messaggio
  579.      * Inoltre effettua anche un rollback di un Outbox/Inbox Message (tipoRiferimentoMessaggio) utilizzando il riferimentoMessaggio
  580.      *
  581.      * @param tipo Tipo di Messaggio su cui effettuare il Rollback
  582.      * @param id Identificativo del Messaggio su cui effettuare il Rollback
  583.      * 
  584.      */
  585.     public void releaseOutboxMessage(String tipo,String id, boolean isMessaggioRichiesta) throws EJBUtilsException{
  586.         if(Costanti.INBOX.equals(tipo)==false && Costanti.OUTBOX.equals(tipo)==false)
  587.             throw new EJBUtilsException("EJBUtils.releaseOutboxMessage error: Tipo di Messaggio non definito");
  588.         if(id ==null)
  589.             throw new EJBUtilsException("EJBUtils.releaseOutboxMessage error: ID Messaggio non definito");
  590.         releaseMessage(true,false,tipo,id,true, isMessaggioRichiesta);
  591.     }

  593.     /**
  594.      * Rilascia un messaggio precedentemente salvato, e 
  595.      * effettua anche un rollback di un InBox Message utilizzando l'id del Messaggio
  596.      *
  597.      * 
  598.      */
  599.     public void releaseInboxMessage(boolean isMessaggioRichiesta) throws EJBUtilsException{
  600.         releaseMessage(false,true,null,null,true, isMessaggioRichiesta);
  601.     }

  603.     /**
  604.      * Rilascia un messaggio precedentemente salvato, e 
  605.      * effettua anche un rollback di un InBox Message utilizzando l'id del Messaggio
  606.      *
  607.      * 
  608.      */
  609.     public void releaseInboxMessage(boolean cleanHistory, boolean isMessaggioRichiesta) throws EJBUtilsException{
  610.         releaseMessage(false,true,null,null,cleanHistory, isMessaggioRichiesta);
  611.     }

  613.     /**
  614.      * Rilascia un messaggio precedentemente salvato, 
  615.      * e effettua anche un rollback di un OutBox Message utilizzando l'id del Messaggio
  616.      * Inoltre effettua anche un rollback di un Outbox/Inbox Message (tipoRiferimentoMessaggio) utilizzando il riferimentoMessaggio
  617.      *
  618.      * @param tipo Tipo di Messaggio su cui effettuare il Rollback
  619.      * @param id Identificativo del Messaggio su cui effettuare il Rollback
  620.      * 
  621.      */
  622.     public void releaseInboxMessage(String tipo,String id, boolean isMessaggioRichiesta) throws EJBUtilsException{
  623.         if(Costanti.INBOX.equals(tipo)==false && Costanti.OUTBOX.equals(tipo)==false)
  624.             throw new EJBUtilsException("EJBUtils.releaseOutboxMessage error: Tipo di Messaggio non definito");
  625.         if(id ==null)
  626.             throw new EJBUtilsException("EJBUtils.releaseOutboxMessage error: ID Messaggio non definito");
  627.         releaseMessage(false,true,tipo,id,true, isMessaggioRichiesta);
  628.     }

  630.     /**
  631.      * Rilascia un messaggio precedentemente salvato, e se richiesto effettua anche un rollback
  632.      *
  633.      * @param rollbackOutbox indicazione se effettuare un Rollback di un OutBox Message
  634.      * @param rollbackInbox indicazione se effettuare un Rollback di un InBox Message
  635.      * @param tipo Tipo di Messaggio su cui effettuare il Rollback
  636.      * @param id Identificativo del Messaggio su cui effettuare il Rollback
  637.      * 
  638.      */
  639.     private void releaseMessage(boolean rollbackOutbox,boolean rollbackInbox,String tipo,String id,boolean cleanHistory, boolean isMessaggioRichiesta) throws EJBUtilsException{ 

  641.         StateMessage stateMSG = (isMessaggioRichiesta) ? (StateMessage) this.openSPCoopState.getStatoRichiesta() 
  642.                 : (StateMessage) this.openSPCoopState.getStatoRisposta();   

  644.         if (stateMSG instanceof StatelessMessage && !this.oneWayVersione11){
  645.             return;
  646.         }
  647.         
  648.         RollbackRepositoryBuste rollbackBuste = null;
  649.         RollbackRepositoryBuste rollbackBusteRifMessaggio = null;
  650.         GestoreMessaggi msg = null;
  651.         try{

  653.             /* ------- Gestione Msg --------------- */

  655.             // Rollback del messaggio
  656.             if(rollbackOutbox){
  657.                 rollbackBuste = new RollbackRepositoryBuste(this.idMessage, stateMSG, this.oneWayVersione11);
  658.                 rollbackBuste.rollbackBustaIntoOutBox(cleanHistory);
  659.             }else if(rollbackInbox){
  660.                 rollbackBuste = new RollbackRepositoryBuste(this.idMessage, stateMSG, this.oneWayVersione11);
  661.                 rollbackBuste.rollbackBustaIntoInBox(cleanHistory);
  662.             }

  664.             // Rollback sul RiferimentoMessaggio
  665.             if(tipo!=null && id!=null){
  666.                 rollbackBusteRifMessaggio = new RollbackRepositoryBuste(id, stateMSG, this.oneWayVersione11);
  667.                 if(Costanti.OUTBOX.equals(tipo))
  668.                     rollbackBusteRifMessaggio.rollbackBustaIntoOutBox();
  669.                 else
  670.                     rollbackBusteRifMessaggio.rollbackBustaIntoInBox();     
  671.             }

  673.             // Imposto ProprietarioMessaggioRichiesta per eliminazione
  674.             msg = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  675.             msg.setOneWayVersione11(this.oneWayVersione11);
  676.             msg.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);

  678.             /* ------ Commit delle modifiche ------ */
  679.             this.openSPCoopState.commit();

  681.             // Aggiornamento cache proprietario messaggio
  682.             String idBustaRichiestaCorrelata = null;
  683.             if(this.idMessage.equals(this.idSessione)==false)
  684.                 idBustaRichiestaCorrelata = this.idSessione;
  685.             msg.addProprietariIntoCache_readFromTable("EJBUtils."+this.idModulo, "releaseMessage",idBustaRichiestaCorrelata,this.functionAsRouter);

  687.         }catch (Exception e) {  
  688.             stateMSG.closePreparedStatement();
  689.             // Rilancio l'eccezione
  690.             throw new EJBUtilsException("EJBUtils.releaseMessage error: "+e.getMessage(),e);
  691.         }   
  692.     }





  698.     /** ------------------- Metodi per la spedizione di risposte Applicative Errore---------------- */

  700.     /**
  701.      * Spedisce un Messaggio di risposta Applicativo  al modulo di openspcoop che gli compete.
  702.      * La spedizione viene naturalmente effettuata solo se l'idModuloInAttesa nella richiesta delegata e' diverso da null 
  703.      * o se e' stata definita una ricezione di contenuti asincroni.
  704.      *
  705.      * @param responseMessageError Message di errore applicativo
  706.      * @param richiestaDelegata Dati che caratterizzano la richiesta.
  707.      * 
  708.      */
  709.     public void sendRispostaApplicativaErrore(OpenSPCoop2Message responseMessageError, 
  710.             RichiestaDelegata richiestaDelegata,
  711.             PortaDelegata pd,ServizioApplicativo sa)throws EJBUtilsException{
  712.         sendRispostaApplicativaErrore(responseMessageError,richiestaDelegata,true,pd,sa);
  713.     }

  715.     /**
  716.      * Spedisce un Messaggio di risposta Applicativo  al modulo di openspcoop che gli compete.
  717.      * La spedizione viene naturalmente effettuata solo se l'idModuloInAttesa nella richiesta delegata e' diverso da null 
  718.      * o se e' stata definita una ricezione di contenuti asincroni.
  719.      *
  720.      * @param responseMessageError Message di errore applicativo
  721.      * @param richiestaDelegata Dati che caratterizzano la richiesta.
  722.      * @param rollbackRichiesta Indicazione se effettuare il rollback della richiesta
  723.      * 
  724.      */
  725.     public void sendRispostaApplicativaErrore(OpenSPCoop2Message responseMessageError, 
  726.             RichiestaDelegata richiestaDelegata,boolean rollbackRichiesta,
  727.             PortaDelegata pd,ServizioApplicativo sa) throws EJBUtilsException{ 

  729.         String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  730.         
  731.         if (this.openSPCoopState instanceof OpenSPCoopStateless)
  732.             ((OpenSPCoopStateless)this.openSPCoopState).setRispostaMsg(responseMessageError);

  734.         StateMessage statoRichiesta = (StateMessage) this.openSPCoopState.getStatoRichiesta();
  735.         StateMessage statoRisposta = (StateMessage) this.openSPCoopState.getStatoRisposta();

  737.         String correlazioneApplicativa = null;
  738.         if(richiestaDelegata!=null)
  739.             correlazioneApplicativa = richiestaDelegata.getIdCorrelazioneApplicativa();
  740.         
  741.         String correlazioneApplicativaRisposta = null;
  742.         if(richiestaDelegata!=null)
  743.             correlazioneApplicativaRisposta = richiestaDelegata.getIdCorrelazioneApplicativaRisposta();
  744.         
  745.         String nomePorta = null;
  746.         if(richiestaDelegata!=null && richiestaDelegata.getIdPortaDelegata()!=null)
  747.             nomePorta = richiestaDelegata.getIdPortaDelegata().getNome();
  748.         
  749.         RollbackRepositoryBuste rollbackBuste = null;
  750.         RollbackRepositoryBuste rollbackBusteRifMessaggio = null;
  751.         GestoreMessaggi msgRequest = null;
  752.         GestoreMessaggi msgResponse = null;
  753.         GestoreMessaggi msgSbloccoRicezioneContenutiApplicativi = null; // Evenutuale sblocco se presente ricezioneContenutiApplicativi per profili oneway/sincroni

  755.         if(richiestaDelegata==null) {
  756.             throw new EJBUtilsException("Param richiestaDelegata is null");
  757.         }
  758.         
  759.         // Aggiungo costante servizio applicativo
  760.         this.msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, richiestaDelegata.getServizioApplicativo());
  761.         
  762.         this.setEJBSuffixFunctionName();
  763.         try{


  766.             /* ------- Raccolta dati ------ */
  767.             String idModuloInAttesa = richiestaDelegata.getIdModuloInAttesa();


  770.             /* IMPOSTATA A FALSE IN AUTOMATICO PER FAR TORNARE GLI ERRORI SEMPRE SULLA SOLITA CONNESSIONE */
  771.             // Se riservira' basta scommentare la riga sottostante.
  772.             //boolean consegnaRispostaAsincrona = richiestaDelegata.getUtilizzoConsegnaAsincrona() &&  this.configurazionePdDReader.existsConsegnaRispostaAsincrona(richiestaDelegata);
  773.             boolean consegnaRispostaAsincrona = false;


  776.             /* ------- Gestione MsgRichiesta --------------- */


  779.             // RollbackApplicativo elimino tutti gli accessi.
  780.             // (uso l'ID della sessione, poiche' tutti i dati 'protocollo' sono salvati con l'ID della richiesta e non della risposta)
  781.             // Il rollback della richiesta serve in caso di errori.
  782.             if(rollbackRichiesta){
  783.                 rollbackBusteRifMessaggio = new RollbackRepositoryBuste(this.idSessione, statoRichiesta, this.oneWayVersione11);
  784.                 rollbackBusteRifMessaggio.rollbackBustaIntoOutBox(this.rollbackRichiestaInCasoErrore_rollbackHistory);
  785.             }else{
  786.                 // se sono in un flusso di richiesta (imbustamento/inoltroBuste devo cmq eliminare l'accesso da pdd)
  787.                 rollbackBusteRifMessaggio = new RollbackRepositoryBuste(this.idSessione, statoRichiesta, this.oneWayVersione11);
  788.                 rollbackBusteRifMessaggio.clearAccessiIntoOutBox(false,false,true);
  789.             }

  791.             if(this.idSessione.equals(this.idMessage)==false){
  792.                 // Siamo in SbustamentoRisposte...
  793.                 // Rollback del messaggio di risposta
  794.                 rollbackBuste = new RollbackRepositoryBuste(this.idMessage, statoRichiesta, this.oneWayVersione11);
  795.                 rollbackBuste.rollbackBustaIntoInBox();
  796.             }

  798.             // Imposto ProprietarioMessaggioRichiesta per eliminazione
  799.             msgRequest = new GestoreMessaggi(this.openSPCoopState, true , this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  800.             msgRequest.setOneWayVersione11(this.oneWayVersione11);
  801.             msgRequest.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);








  810.             /* ------- Gestione MsgRisposta --------------- */


  813.             // Creo stato di risposta
  814.             String idRisposta = null;
  815.             if( (consegnaRispostaAsincrona) || (idModuloInAttesa != null) ){

  817.                 // --- Creo lo stato del messaggio,visto che sto' spedendo una risposta generata da OpenSPCoop, 
  818.                 // creando anche un IDResponse)
  819.                 Imbustamento imbustatore = new Imbustamento(this.log,this.protocolFactory, this.openSPCoopState.getStatoRichiesta());

  821.                 idRisposta = 
  822.                     imbustatore.buildID(this.identitaPdD, idTransazione, 
  823.                             this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  824.                             this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  825.                             RuoloMessaggio.RISPOSTA);
  826.                 if(idRisposta == null){
  827.                     throw new Exception("Identificativo non costruito.");
  828.                 }  

  830.                 // oraRegistrazione
  831.                 Timestamp oraRegistrazioneMessaggio = DateManager.getTimestamp();

  833.                 msgResponse = new GestoreMessaggi(this.openSPCoopState, false, idRisposta,Costanti.INBOX,this.msgDiag,this.pddContext);
  834.                 msgResponse.registraMessaggio(responseMessageError,oraRegistrazioneMessaggio, saveMessageStateless(pd),
  835.                         correlazioneApplicativa,correlazioneApplicativaRisposta);
  836.                 msgResponse.aggiornaRiferimentoMessaggio(this.idSessione);
  837.                 
  838.                 // --- Aggiorno Proprietario
  839.                 if( consegnaRispostaAsincrona ){
  840.                     // Aggiorno proprietario Messaggio, consegna asincrona: CONSEGNA_BUSTE_SOAP
  841.                     msgResponse.aggiornaProprietarioMessaggio(ConsegnaContenutiApplicativi.ID_MODULO);
  842.                 }else{
  843.                     if(idModuloInAttesa != null){
  844.                         // Aggiorno proprietario Messaggio, consegna sincrona: ACCETTAZIONEXXX
  845.                         msgResponse.aggiornaProprietarioMessaggio(idModuloInAttesa);
  846.                     }
  847.                 }

  849.                 // --- Lettura dati di configurazione 
  850.                 boolean servizioApplicativoConConnettore = false;
  851.                 boolean getMessageAbilitato = false;
  852.                 boolean sbustamentoSoap = false;
  853.                 boolean sbustamentoInformazioniProtocollo = true;
  854.                 try{
  855.                     servizioApplicativoConConnettore = this.configurazionePdDReader.consegnaRispostaAsincronaConConnettore(sa);
  856.                     getMessageAbilitato = this.configurazionePdDReader.consegnaRispostaAsincronaConGetMessage(sa);
  857.                     sbustamentoSoap = this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamento(sa);
  858.                     sbustamentoInformazioniProtocollo = this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamentoInformazioniProtocollo(sa);
  859.                 }catch(DriverConfigurazioneNotFound de){}

  861.                 if( (getMessageAbilitato==false) && (servizioApplicativoConConnettore==false) && (idModuloInAttesa==null)){
  862.                     this.msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"consegnaNonDefinita");
  863.                     return; 
  864.                 }

  866.                 String tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_INTEGRATION_MANAGER;

  868.                 // --- Spedizione al successivo modulo 
  869.                 if( consegnaRispostaAsincrona ){
  870.                     if(servizioApplicativoConConnettore){
  871.                         // spedizione al modulo ConsegnaContenutiApplicativi
  872.                         richiestaDelegata.setScenario(Costanti.SCENARIO_CONSEGNA_CONTENUTI_APPLICATIVI);
  873.                         sendToConsegnaContenutiApplicativi_rispostaConsegnataModalitaAsincrona(richiestaDelegata,idRisposta, msgResponse);
  874.                         tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE;
  875.                     }else{
  876.                         this.msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"integrationManager.messaggioDisponibile");
  877.                     }
  878.                 }else{
  879.                     if(idModuloInAttesa != null){
  880.                         // spedizione al modulo RicezioneContenutiApplicativiXXX
  881.                         sendToRicezioneContenutiApplicativi(idModuloInAttesa,idRisposta,
  882.                                 richiestaDelegata.getIdCollaborazione(),
  883.                                 richiestaDelegata.getProfiloCollaborazione(),richiestaDelegata.getProfiloCollaborazioneValue());
  884.                         tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_CONNECTION_REPLY;
  885.                     }
  886.                 }

  888.                 // ---- Registra SIL Destinatario del Messaggio
  889.                 msgResponse.registraDestinatarioMessaggio(richiestaDelegata.getServizioApplicativo(),
  890.                         sbustamentoSoap,sbustamentoInformazioniProtocollo,getMessageAbilitato,tipoConsegna,oraRegistrazioneMessaggio,
  891.                         nomePorta, false, false,
  892.                         null, null, false);

  894.             } // end Gestione Risposta

  896.             /* ------- Gestione msgSbloccoRicezioneContenutiApplicativi --------------- */
  897.             String idSbloccoRicezioneContenutiApplicativi = null;
  898.             if(consegnaRispostaAsincrona && idModuloInAttesa != null){
  899.                 //  Creo stato per msgSbloccoRicezioneContenutiApplicativi
  900.                 Imbustamento imbustatore = new Imbustamento(this.log,this.protocolFactory, this.openSPCoopState.getStatoRichiesta());
  901.                 idSbloccoRicezioneContenutiApplicativi= 
  902.                     imbustatore.buildID(this.identitaPdD, idTransazione, 
  903.                             this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  904.                             this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  905.                             RuoloMessaggio.RISPOSTA);
  906.                 if(idSbloccoRicezioneContenutiApplicativi == null){
  907.                     throw new Exception("Identificativo non costruito.");
  908.                 }  
  909.                 msgSbloccoRicezioneContenutiApplicativi = new GestoreMessaggi( this.openSPCoopState, false, idSbloccoRicezioneContenutiApplicativi,Costanti.INBOX,this.msgDiag,this.pddContext);
  910.                 if(this.protocolManager.isHttpEmptyResponseOneWay())
  911.                     msgSbloccoRicezioneContenutiApplicativi.registraMessaggio(MessageUtilities.buildEmptyMessage(responseMessageError.getFactory(), responseMessageError.getMessageType(), MessageRole.RESPONSE),correlazioneApplicativa,correlazioneApplicativaRisposta);
  912.                 else
  913.                     msgSbloccoRicezioneContenutiApplicativi.registraMessaggio(this.buildOpenSPCoopOK(responseMessageError.getMessageType(),this.idSessione),correlazioneApplicativa,correlazioneApplicativaRisposta);
  914.                 msgSbloccoRicezioneContenutiApplicativi.aggiornaRiferimentoMessaggio(this.idSessione);
  915.                 //  --- Aggiorno Proprietario
  916.                 msgSbloccoRicezioneContenutiApplicativi.aggiornaProprietarioMessaggio(idModuloInAttesa);
  917.                 //  --- Spedizione al modulo RicezioneContenutiApplicativiXXX
  918.                 sendToRicezioneContenutiApplicativi(idModuloInAttesa,idSbloccoRicezioneContenutiApplicativi,
  919.                         richiestaDelegata.getIdCollaborazione(),
  920.                         richiestaDelegata.getProfiloCollaborazione(),richiestaDelegata.getProfiloCollaborazioneValue());
  921.             }


  924.             /* ------ Commit/Close connessione al DB ------ */
  925.             this.openSPCoopState.commit();

  927.             // Aggiornamento cache messaggio
  928.             if(msgSbloccoRicezioneContenutiApplicativi !=null)
  929.                 msgSbloccoRicezioneContenutiApplicativi.addMessaggiIntoCache_readFromTable(this.idModulo, "sendRispostaApplicativaErrore [sblocco]");
  930.             if(msgResponse !=null)
  931.                 msgResponse.addMessaggiIntoCache_readFromTable(this.idModulo, "sendRispostaApplicativaErrore [risposta]");

  933.             // Aggiornamento cache proprietario messaggio
  934.             if(msgRequest!=null){
  935.                 String idRichiestaCorrelata = null;
  936.                 if(this.idMessage.equals(this.idSessione)==false)
  937.                     idRichiestaCorrelata = this.idSessione;
  938.                 msgRequest.addProprietariIntoCache_readFromTable(this.idModulo, "sendRispostaApplicativaErrore [richiesta]",idRichiestaCorrelata,this.functionAsRouter);
  939.             }
  940.             if(msgSbloccoRicezioneContenutiApplicativi !=null)
  941.                 msgSbloccoRicezioneContenutiApplicativi.addProprietariIntoCache_readFromTable(this.idModulo, "sendRispostaApplicativaErrore [sblocco]",this.idSessione,this.functionAsRouter);
  942.             if(msgResponse !=null)
  943.                 msgResponse.addProprietariIntoCache_readFromTable(this.idModulo, "sendRispostaApplicativaErrore [risposta]",this.idSessione,this.functionAsRouter);

  945.         }catch (Exception e) {  
  946.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendRispostaApplicativaErrore");
  947.             statoRichiesta.closePreparedStatement();
  948.             statoRisposta.closePreparedStatement();
  949.             throw new EJBUtilsException("EJBUtils.sendRispostaApplicativaErrore error: "+e.getMessage(),e);
  950.         }
  951.         finally{
  952.             this.unsetEJBSuffixFunctionName();
  953.         }   
  954.     }
















  971.     /** ------------------- Metodi per la spedizione di risposte Applicative ---------------- */

  973.     /**
  974.      * Spedisce un Messaggio di risposta Applicativo  al modulo di openspcoop che gli compete.
  975.      * La spedizione viene naturalmente effettuata solo se l'idModuloInAttesa nella richiesta delegata e' diverso da null 
  976.      * o se e' stata definita una ricezione di contenuti asincroni.
  977.      *
  978.      * @param richiestaDelegata Dati che caratterizzano la richiesta.
  979.      * 
  980.      */
  981.     public GestoreMessaggi sendRispostaApplicativa(RichiestaDelegata richiestaDelegata,
  982.             PortaDelegata pd,ServizioApplicativo sa)throws EJBUtilsException{ 
  983.         return sendRispostaApplicativa(null,richiestaDelegata,this.idMessage,pd,sa);
  984.     }


  987.     /**
  988.      * Spedisce un Messaggio di risposta Applicativo  al modulo di openspcoop che gli compete.
  989.      * La spedizione viene naturalmente effettuata solo se l'idModuloInAttesa nella richiesta delegata  e' diverso da null 
  990.      * o se e' stata definita una ricezione di contenuti asincroni.
  991.      *
  992.      * @param msg Messaggio SOAP che contiene un messaggio di ok applicativo
  993.      * @param richiestaDelegata Dati che caratterizzano la richiesta.
  994.      * 
  995.      */
  996.     public GestoreMessaggi sendRispostaApplicativaOK(OpenSPCoop2Message msg, RichiestaDelegata richiestaDelegata,
  997.             PortaDelegata pd,ServizioApplicativo sa)throws EJBUtilsException { 
  998.         return sendRispostaApplicativa(msg,richiestaDelegata,null,pd,sa);
  999.     }

  1001.     /**
  1002.      * Spedisce un Messaggio di risposta Applicativo  al modulo di openspcoop che gli compete.
  1003.      * La spedizione viene naturalmente effettuata solo se l'idModuloInAttesa nella richiesta delegata  e' diverso da null 
  1004.      * o se e' stata definita una ricezione di contenuti asincroni.
  1005.      *
  1006.      * @param msg Messaggio SOAP che contiene un messaggio di ok applicativo
  1007.      * @param richiestaDelegata Dati che caratterizzano la richiesta.
  1008.      * @param idModuloInAttesa identificativo del modulo 'RicezioneContenutiApplicativiXXX'. 
  1009.      * @param idBustaRisposta Identificativo del messaggio di risposta
  1010.      * @return Messaggio di risposta 
  1011.      * 
  1012.      */
  1013.     private GestoreMessaggi sendRispostaApplicativa(OpenSPCoop2Message msg, RichiestaDelegata richiestaDelegata, String idBustaRisposta,
  1014.             PortaDelegata pd,ServizioApplicativo sa) throws EJBUtilsException{ 

  1016.         String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1017.         
  1018.         StateMessage statoRisposta = (StateMessage) this.openSPCoopState.getStatoRisposta();
  1019.         
  1020.         GestoreMessaggi msgResponse = null;
  1021.         GestoreMessaggi msgSbloccoRicezioneContenutiApplicativi = null; // Evenutuale sblocco se presente ricezioneContenutiApplicativi per profili oneway/sincroni

  1023.         String correlazioneApplicativa = null;
  1024.         if(richiestaDelegata!=null)
  1025.             correlazioneApplicativa = richiestaDelegata.getIdCorrelazioneApplicativa();
  1026.         
  1027.         String correlazioneApplicativaRisposta = null;
  1028.         if(richiestaDelegata!=null)
  1029.             correlazioneApplicativaRisposta = richiestaDelegata.getIdCorrelazioneApplicativaRisposta();
  1030.         
  1031.         String nomePorta = null;
  1032.         if(richiestaDelegata!=null && richiestaDelegata.getIdPortaDelegata()!=null)
  1033.             nomePorta = richiestaDelegata.getIdPortaDelegata().getNome();
  1034.         
  1035.         if(richiestaDelegata==null) {
  1036.             throw new EJBUtilsException("Param richiestaDelegata is null");
  1037.         }
  1038.         
  1039.         // Aggiungo costante servizio applicativo
  1040.         this.msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, richiestaDelegata.getServizioApplicativo());
  1041.         
  1042.         this.setEJBSuffixFunctionName();
  1043.         try{

  1045.             /* ------- Raccolta dati ------ */
  1046.             String idModuloInAttesa = richiestaDelegata.getIdModuloInAttesa();
  1047.             boolean existsConsegnaRispostaAsincrona = false;
  1048.             try{
  1049.                 existsConsegnaRispostaAsincrona = this.configurazionePdDReader.existsConsegnaRispostaAsincrona(sa);
  1050.             }catch(DriverConfigurazioneNotFound de){}
  1051.             boolean consegnaRispostaAsincrona = richiestaDelegata.getUtilizzoConsegnaAsincrona() &&  existsConsegnaRispostaAsincrona;


  1054.             /* ------- Gestione MsgRisposta --------------- */
  1055.             String idRisposta = idBustaRisposta;
  1056.             if( (consegnaRispostaAsincrona) || (idModuloInAttesa != null) ){

  1058.                 // oraRegistrazione
  1059.                 Timestamp oraRegistrazioneMessaggio = DateManager.getTimestamp();

  1061.                 // --- Creo lo stato del messaggio,se sto' spedendo una risposta generata da OpenSPCoop, creando anche un IDResponse)
  1062.                 if(idRisposta == null){
  1063.                     // Creo ID Risposta
  1064.                     
  1065.                     Imbustamento imbustatore = new Imbustamento(this.log,this.protocolFactory, this.openSPCoopState.getStatoRichiesta());
  1066.                     idRisposta = 
  1067.                         imbustatore.buildID(this.identitaPdD, idTransazione, 
  1068.                                 this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  1069.                                 this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  1070.                                 RuoloMessaggio.RISPOSTA);
  1071.                     if(idRisposta == null){
  1072.                         throw new Exception("Identificativo non costruito.");
  1073.                     }  
  1074.                     msgResponse = new GestoreMessaggi(this.openSPCoopState, false , idRisposta,Costanti.INBOX,this.msgDiag,this.pddContext);
  1075.                     msgResponse.registraMessaggio(msg,oraRegistrazioneMessaggio, saveMessageStateless(pd),correlazioneApplicativa,correlazioneApplicativaRisposta);
  1076.                 }else{
  1077.                     // Carico lo stato di un messaggio, esistente
  1078.                     msgResponse = new GestoreMessaggi(this.openSPCoopState, false ,idRisposta,Costanti.INBOX,this.msgDiag,this.pddContext);
  1079.                     oraRegistrazioneMessaggio = msgResponse.getOraRegistrazioneMessaggio();
  1080.                 }

  1082.                 // --- Aggiorno informazioni sul messaggio
  1083.                 msgResponse.aggiornaRiferimentoMessaggio(this.idSessione);

  1085.                 // --- Aggiorno Proprietario
  1086.                 if( consegnaRispostaAsincrona ){
  1087.                     // Aggiorno proprietario Messaggio, consegna asincrona: CONSEGNA_BUSTE_SOAP
  1088.                     msgResponse.aggiornaProprietarioMessaggio(ConsegnaContenutiApplicativi.ID_MODULO);
  1089.                 }else{
  1090.                     if(idModuloInAttesa != null){
  1091.                         // Aggiorno proprietario Messaggio, consegna sincrona: ACCETTAZIONEXXX
  1092.                         msgResponse.aggiornaProprietarioMessaggio(idModuloInAttesa);
  1093.                     }
  1094.                 }

  1096.                 //  --- Lettura dati di configurazione 
  1097.                 boolean servizioApplicativoConConnettore = false;
  1098.                 boolean getMessageAbilitato = false;
  1099.                 boolean sbustamentoSoap = false;
  1100.                 boolean sbustamentoInformazioniProtocollo = true;
  1101.                 try{
  1102.                     servizioApplicativoConConnettore = this.configurazionePdDReader.consegnaRispostaAsincronaConConnettore(sa);
  1103.                     getMessageAbilitato = this.configurazionePdDReader.consegnaRispostaAsincronaConGetMessage(sa);
  1104.                     sbustamentoSoap = this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamento(sa);
  1105.                     sbustamentoInformazioniProtocollo = this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamentoInformazioniProtocollo(sa);
  1106.                 }catch(DriverConfigurazioneNotFound de){}

  1108.                 if( (getMessageAbilitato==false) && (servizioApplicativoConConnettore==false) && (idModuloInAttesa==null)){
  1109.                     this.msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"consegnaNonDefinita");
  1110.                     return msgResponse; 
  1111.                 }else if( (servizioApplicativoConConnettore==false) && (idModuloInAttesa==null)){
  1112.                     this.msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"integrationManager.messaggioDisponibile");
  1113.                 }

  1115.                 String tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_INTEGRATION_MANAGER;


  1118.                 // --- Spedizione al successivo modulo 
  1119.                 try{
  1120.                     if( consegnaRispostaAsincrona ){
  1121.                         if(servizioApplicativoConConnettore){
  1122.                             // spedizione al modulo ConsegnaContenutiApplicativi
  1123.                             richiestaDelegata.setScenario(Costanti.SCENARIO_CONSEGNA_CONTENUTI_APPLICATIVI);
  1124.                             sendToConsegnaContenutiApplicativi_rispostaConsegnataModalitaAsincrona(richiestaDelegata,idRisposta, msgResponse);
  1125.                             tipoConsegna=GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE;
  1126.                         }else{
  1127.                             this.msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"integrationManager.messaggioDisponibile");
  1128.                         }
  1129.                     }else{
  1130.                         if(idModuloInAttesa != null){
  1131.                             // spedizione al modulo RicezioneContenutiApplicativiXXX
  1132.                             sendToRicezioneContenutiApplicativi(idModuloInAttesa,idRisposta,
  1133.                                     richiestaDelegata.getIdCollaborazione(),
  1134.                                     richiestaDelegata.getProfiloCollaborazione(),richiestaDelegata.getProfiloCollaborazioneValue());
  1135.                             tipoConsegna=GestoreMessaggi.CONSEGNA_TRAMITE_CONNECTION_REPLY;
  1136.                         }
  1137.                     }
  1138.                 }catch(Exception e){
  1139.                     throw e; // rilancio eccezione;
  1140.                 }

  1142.                 // --- Registra SIL Destinatario del Messaggio
  1143.                 msgResponse.registraDestinatarioMessaggio(richiestaDelegata.getServizioApplicativo(),
  1144.                         sbustamentoSoap,sbustamentoInformazioniProtocollo,getMessageAbilitato,tipoConsegna,oraRegistrazioneMessaggio,
  1145.                         nomePorta, false, false,
  1146.                         null, null, false);
  1147.             } // end Gestione Risposta






  1154.             /* ------- Gestione msgSbloccoRicezioneContenutiApplicativi --------------- */
  1155.             if(consegnaRispostaAsincrona && idModuloInAttesa != null){
  1156.                 //  Creo stato per msgSbloccoRicezioneContenutiApplicativi
  1157.                 Imbustamento imbustatore = new Imbustamento(this.log,this.protocolFactory,this.openSPCoopState.getStatoRichiesta());
  1158.                 String idSbloccoRicezioneContenutiApplicativi= 
  1159.                     imbustatore.buildID(this.identitaPdD, idTransazione, 
  1160.                             this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  1161.                             this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  1162.                             RuoloMessaggio.RISPOSTA);
  1163.                 if(idSbloccoRicezioneContenutiApplicativi == null){
  1164.                     throw new Exception("Identificativo non costruito.");
  1165.                 }  
  1166.                 msgSbloccoRicezioneContenutiApplicativi = new GestoreMessaggi(this.openSPCoopState, false, idSbloccoRicezioneContenutiApplicativi,Costanti.INBOX,this.msgDiag,this.pddContext);
  1167.                 RequestInfo requestInfo = (RequestInfo) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  1168.                 MessageType msgTypeSblocco = requestInfo.getIntegrationRequestMessageType();
  1169.                 if(msgTypeSblocco==null){
  1170.                     throw new Exception("Versione messaggio non definita");
  1171.                 }
  1172.                 if(this.protocolManager.isHttpEmptyResponseOneWay())
  1173.                     msgSbloccoRicezioneContenutiApplicativi.registraMessaggio(MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), msgTypeSblocco, MessageRole.RESPONSE),correlazioneApplicativa,correlazioneApplicativaRisposta);
  1174.                 else
  1175.                     msgSbloccoRicezioneContenutiApplicativi.registraMessaggio(this.buildOpenSPCoopOK(msgTypeSblocco,this.idSessione),correlazioneApplicativa,correlazioneApplicativaRisposta);
  1176.                 msgSbloccoRicezioneContenutiApplicativi.aggiornaRiferimentoMessaggio(this.idSessione);
  1177.                 //  --- Aggiorno Proprietario
  1178.                 msgSbloccoRicezioneContenutiApplicativi.aggiornaProprietarioMessaggio(idModuloInAttesa);
  1179.                 //  --- Spedizione al modulo RicezioneContenutiApplicativiXXX
  1180.                 sendToRicezioneContenutiApplicativi(idModuloInAttesa,idSbloccoRicezioneContenutiApplicativi,
  1181.                         richiestaDelegata.getIdCollaborazione(),
  1182.                         richiestaDelegata.getProfiloCollaborazione(),richiestaDelegata.getProfiloCollaborazioneValue());
  1183.             }

  1185.             // Ritorno gestore della risposta
  1186.             return msgResponse;

  1188.         }catch (Exception e) {  
  1189.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendRispostaApplicativa");
  1190.             
  1191.             if(msgResponse!=null)
  1192.                 statoRisposta.closePreparedStatement();
  1193.             //  msgResponse.closePreparedStatement();

  1195.             // Rilancio l'eccezione
  1196.             throw new EJBUtilsException("EJBUtils.sendRispostaApplicativa error: "+e.getMessage(),e);
  1197.         } finally{
  1198.             this.unsetEJBSuffixFunctionName();
  1199.         }

  1201.     }













  1215.     /** ------------------- Metodo per la spedizione al nodo 'RicezioneContenutiApplicativi' ---------------- */

  1217.     /**
  1218.      * Spedisce una risposta applicativa  
  1219.      * al modulo di openspcoop RicezioneContenutiApplicativiXXX, 
  1220.      * inserendolo all'interno di  un messaggio di tipo {@link org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativiMessage} e 
  1221.      * spedendolo nella coda 'toRicezioneContenutiApplicativiXXX'.
  1222.      *
  1223.      * @param idModuloInAttesa identificativo del modulo 'RicezioneContenutiApplicativiXXX'.
  1224.      * @param idRisposta Identificativo del messaggio di risposta
  1225.      * 
  1226.      */
  1227.     public void sendToRicezioneContenutiApplicativi(String idModuloInAttesa,String idRisposta, String idCollaborazione, 
  1228.             ProfiloDiCollaborazione profiloCollaborazione, String profiloCollaborazioneValue) throws EJBUtilsException{

  1230.         if (this.openSPCoopState instanceof OpenSPCoopStateless) {
  1231.             RicezioneContenutiApplicativiMessage accettazioneMSG = new RicezioneContenutiApplicativiMessage();
  1232.             accettazioneMSG.setIdBustaRisposta(idRisposta);
  1233.             accettazioneMSG.setIdCollaborazione(idCollaborazione);
  1234.             accettazioneMSG.setProfiloCollaborazione(profiloCollaborazione,profiloCollaborazioneValue);
  1235.             accettazioneMSG.setPddContext(this.pddContext);
  1236.             ((OpenSPCoopStateless)this.openSPCoopState).setMessageLib(accettazioneMSG);
  1237.             return;
  1238.         }
  1239.         
  1240.         if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.propertiesReader.getNodeReceiver())){ 
  1241.             try{
  1242.                 // Creazione RicezioneContenutiApplicativiMessage
  1243.                 this.msgDiag.highDebug("[EJBUtils] Creazione ObjectMessage for send via JMS.");
  1244.                 RicezioneContenutiApplicativiMessage accettazioneMSG = new RicezioneContenutiApplicativiMessage();
  1245.                 accettazioneMSG.setIdBustaRisposta(idRisposta);
  1246.                 accettazioneMSG.setIdCollaborazione(idCollaborazione);
  1247.                 accettazioneMSG.setProfiloCollaborazione(profiloCollaborazione, profiloCollaborazioneValue);
  1248.                 accettazioneMSG.setPddContext(this.pddContext);

  1250.                 if (this.openSPCoopState instanceof OpenSPCoopStateless)
  1251.                     ((OpenSPCoopStateless)this.openSPCoopState).setMessageLib(accettazioneMSG);

  1253.                 else { //send modalita Stateful
  1254.                     // NOTA: usare realmente JMSSender e non l'interfaccia INodeSender, perche' questo punto riguarda INodeReceiver!!
  1255.                     String idT = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, this.pddContext);
  1256.                     JMSSender senderJMS = new JMSSender(this.identitaPdD,this.idModulo,this.log,idT);
  1257.                     if(senderJMS.send(idModuloInAttesa,
  1258.                             accettazioneMSG,this.idSessione) == false){
  1259.                         this.msgDiag.logErroreGenerico(senderJMS.getErrore(), "EJBUtils.sendToRicezioneContenutiApplicativi.senderJMS");
  1260.                         throw new Exception("[EJBUtils]  SendJMSError: "+senderJMS.getErrore());
  1261.                     }
  1262.                     this.msgDiag.highDebug("[EJBUtils]  ObjectMessage send via JMS.");
  1263.                 }
  1264.             } catch (Exception e) { 
  1265.                 this.msgDiag.logErroreGenerico(e, "EJBUtils.sendToRicezioneContenutiApplicativi");
  1266.                 throw new EJBUtilsException("EJBUtils.sendToRicezioneContenutiApplicativi error: "+e.getMessage(),e);
  1267.             }
  1268.         }
  1269.     }













  1283.     /** ------------------- Metodo per la spedizione al nodo 'ConsegnaContenutiApplicativi' ---------------- */

  1285.     /**
  1286.      * Spedisce una risposta applicativa  
  1287.      * al modulo di openspcoop ConsegnaContenutiApplicativi, 
  1288.      * inserendolo all'interno di  un messaggio di tipo {@link org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiMessage} e 
  1289.      * spedendolo nella coda 'toConsegnaContenutiApplicativi'.
  1290.      *
  1291.      * @param richiestaDelegata RichiestaDelegata
  1292.      * @param idBustaConsegna Identificatore del messaggio da consegnare
  1293.      * 
  1294.      */
  1295.     public void sendToConsegnaContenutiApplicativi_rispostaConsegnataModalitaAsincrona(RichiestaDelegata richiestaDelegata, String idBustaConsegna, GestoreMessaggi gm) throws EJBUtilsException{

  1297.         // La richiesta delegata avra' sempre e soltanto un servizio applicativo, quello che ha invocato la porta delegata
  1298.         try{

  1300.             // Creazione RicezioneContenutiApplicativiMessage
  1301.             this.msgDiag.highDebug("[EJBUtils]  Creazione ObjectMessage for send nell'infrastruttura.");
  1302.             ConsegnaContenutiApplicativiMessage consegnaMSG = new ConsegnaContenutiApplicativiMessage();
  1303.             consegnaMSG.setRichiestaDelegata(richiestaDelegata);
  1304.             consegnaMSG.setOneWayVersione11(this.oneWayVersione11);
  1305.             consegnaMSG.setStateless(this.portaDiTipoStateless_esclusoOneWay11);
  1306.             consegnaMSG.setImplementazionePdDSoggettoMittente(this.implementazionePdDSoggettoMittente);
  1307.             consegnaMSG.setImplementazionePdDSoggettoDestinatario(this.implementazionePdDSoggettoDestinatario);
  1308.             consegnaMSG.setPddContext(this.pddContext);

  1310.             // Costrusce una busta opportuna per la gestione asincrona
  1311.             Busta busta = new Busta(this.protocolFactory.getProtocol());
  1312.             busta.setTipoMittente(richiestaDelegata.getIdSoggettoFruitore().getTipo());
  1313.             busta.setMittente(richiestaDelegata.getIdSoggettoFruitore().getNome());
  1314.             busta.setIdentificativoPortaMittente(richiestaDelegata.getIdSoggettoFruitore().getCodicePorta());
  1315.             busta.setTipoDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getTipo());
  1316.             busta.setDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getNome());
  1317.             busta.setIdentificativoPortaDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getCodicePorta());
  1318.             busta.setTipoServizio(richiestaDelegata.getIdServizio().getTipo());
  1319.             busta.setServizio(richiestaDelegata.getIdServizio().getNome());
  1320.             busta.setVersioneServizio(richiestaDelegata.getIdServizio().getVersione());
  1321.             busta.setAzione(richiestaDelegata.getIdServizio().getAzione());
  1322.             busta.setID(idBustaConsegna);
  1323.             busta.setRiferimentoMessaggio(this.idSessione);
  1324.             
  1325.             busta.setProfiloDiCollaborazione(richiestaDelegata.getProfiloCollaborazione());
  1326.             
  1327.             boolean idCollaborazione = false;
  1328.             switch (this.protocolFactory.createProtocolVersionManager(richiestaDelegata.getProfiloGestione()).getCollaborazione(busta)) {
  1329.             case ABILITATA:
  1330.                 idCollaborazione = true;
  1331.                 break;
  1332.             case DISABILITATA:
  1333.                 idCollaborazione = false;
  1334.                 break;
  1335.             default:
  1336.                 idCollaborazione = this.propertiesReader.isGestioneElementoCollaborazione(this.implementazionePdDSoggettoDestinatario);
  1337.                 break;
  1338.             }
  1339.             
  1340.             if( idCollaborazione ){
  1341.                 busta.setCollaborazione(richiestaDelegata.getIdCollaborazione());
  1342.             }
  1343.             consegnaMSG.setBusta(busta);

  1345.             this.nodeSender.send(consegnaMSG, org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi.ID_MODULO, this.msgDiag, 
  1346.                     this.identitaPdD,this.idModulo, idBustaConsegna, gm);

  1348.         } catch (Exception e) {
  1349.             this.log.error("Spedizione->ConsegnaContenutiApplicativi(RichiestaDelegata) non riuscita",e);   
  1350.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendToConsegnaContenutiApplicativi(RichiestaDelegata)");
  1351.             throw new EJBUtilsException("EJBUtils.sendToConsegnaContenutiApplicativi error: "+e.getMessage(),e);
  1352.         }
  1353.     }

  1355.     /**
  1356.      * Spedisce una risposta applicativa  
  1357.      * al modulo di openspcoop ConsegnaContenutiApplicativi, 
  1358.      * inserendolo all'interno di  un messaggio di tipo {@link org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiMessage} e 
  1359.      * spedendolo nella coda 'toConsegnaContenutiApplicativi'.
  1360.      *
  1361.      * @param richiestaDelegata RichiestaDelegata
  1362.      * @param busta Busta che raccoglie i dati dell'invocazione di servizio
  1363.      * @param gestoreMessaggi il Gestore Messaggi utilizzato per la registrazione dei destinatari del messaggio
  1364.      * 
  1365.      */
  1366.     public void sendToConsegnaContenutiApplicativi_gestioneMessaggio(RichiestaDelegata richiestaDelegata,Busta busta,
  1367.             GestoreMessaggi gestoreMessaggi,
  1368.             ServizioApplicativo sa) throws EJBUtilsException{

  1370.         try{

  1372.             if(richiestaDelegata!=null) {
  1373.                 this.msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, richiestaDelegata.getServizioApplicativo());
  1374.             }
  1375.             
  1376.             if(richiestaDelegata==null) {
  1377.                 throw new EJBUtilsException("Param richiestaDelegata is null");
  1378.             }
  1379.             
  1380.             String nomePorta = null;
  1381.             if(richiestaDelegata.getIdPortaDelegata()!=null)
  1382.                 nomePorta = richiestaDelegata.getIdPortaDelegata().getNome();
  1383.             
  1384.             //  Aggiorno dati di consegna
  1385.             this.msgDiag.setServizioApplicativo(richiestaDelegata.getServizioApplicativo());

  1387.             gestoreMessaggi.aggiornaRiferimentoMessaggio(busta.getRiferimentoMessaggio());
  1388.             boolean servizioApplicativoRicezioneAsincronaConConnettore = this.configurazionePdDReader.consegnaRispostaAsincronaConConnettore(sa);
  1389.             boolean getMessageAbilitato = this.configurazionePdDReader.consegnaRispostaAsincronaConGetMessage(sa);
  1390.             if( getMessageAbilitato==false && servizioApplicativoRicezioneAsincronaConConnettore==false ){
  1391.                 throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"consegnaNonDefinita");
  1392.             }
  1393.             boolean sbustamentoSoap= this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamento(sa);
  1394.             boolean sbustamentoInformazioniProtocollo = this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamentoInformazioniProtocollo(sa);
  1395.             String tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_INTEGRATION_MANAGER;
  1396.             if(servizioApplicativoRicezioneAsincronaConConnettore)
  1397.                 tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE;

  1399.             // oraRegistrazione
  1400.             Timestamp oraRegistrazioneMessaggio = gestoreMessaggi.getOraRegistrazioneMessaggio();

  1402.             gestoreMessaggi.registraDestinatarioMessaggio(richiestaDelegata.getServizioApplicativo(),
  1403.                     sbustamentoSoap,sbustamentoInformazioniProtocollo,getMessageAbilitato,tipoConsegna,oraRegistrazioneMessaggio,
  1404.                     nomePorta, false, false,
  1405.                     null, null, false);

  1407.             // Aggiungo costante servizio applicativo
  1408.             this.msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, richiestaDelegata.getServizioApplicativo());
  1409.             
  1410.             if(servizioApplicativoRicezioneAsincronaConConnettore){

  1412.                 // La richiesta delegata avra' sempre e soltanto un servizio applicativo, quello che ha invocato la porta delegata
  1413.                 try{

  1415.                     // Creazione RicezioneContenutiApplicativiMessage
  1416.                     this.msgDiag.highDebug("[EJBUtils] Creazione ObjectMessage for send nell'infrastruttura.");
  1417.                     ConsegnaContenutiApplicativiMessage consegnaMSG = new ConsegnaContenutiApplicativiMessage();
  1418.                     consegnaMSG.setRichiestaDelegata(richiestaDelegata);
  1419.                     consegnaMSG.setBusta(busta);
  1420.                     consegnaMSG.setOneWayVersione11(this.oneWayVersione11);
  1421.                     consegnaMSG.setStateless(this.portaDiTipoStateless_esclusoOneWay11);
  1422.                     consegnaMSG.setImplementazionePdDSoggettoMittente(this.implementazionePdDSoggettoMittente);
  1423.                     consegnaMSG.setImplementazionePdDSoggettoDestinatario(this.implementazionePdDSoggettoDestinatario);
  1424.                     consegnaMSG.setPddContext(this.pddContext);

  1426.                     if (this.openSPCoopState instanceof OpenSPCoopStateless)
  1427.                         ((OpenSPCoopStateless)this.openSPCoopState).setMessageLib(consegnaMSG);

  1429.                     else { //send modalita Stateful
  1430.                         this.nodeSender.send(consegnaMSG, org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi.ID_MODULO, this.msgDiag, 
  1431.                                 this.identitaPdD,this.idModulo, busta.getID(), gestoreMessaggi);
  1432.                     }
  1433.                 } catch (Exception e) { 
  1434.                     throw e;
  1435.                 }
  1436.             }
  1437.             else{

  1439.                 // CONNETTORE non presente
  1440.                 // un connettore deve per forza essere presente se:
  1441.                 // - profilo asincrono e ricevuta applicativa abilitata
  1442.                 if(richiestaDelegata.isRicevutaAsincrona() && 
  1443.                         (ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ||
  1444.                                 ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ) ){       
  1445.                     throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"gestioneProfiloAsincrono.servizioNonUtilizzabile");
  1446.                 }else{
  1447.                     this.msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"integrationManager.messaggioDisponibile");
  1448.                 }
  1449.             }

  1451.         } catch (EJBUtilsConsegnaException e) { 
  1452.             throw e;
  1453.         } catch (Exception e) {
  1454.             this.log.error("Spedizione->ConsegnaContenutiApplicativi_gestoreMessaggi(RichiestaDelegata) non riuscita",e);   
  1455.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendToConsegnaContenutiApplicativi_gestoreMessaggi(RichiestaDelegata)");
  1456.             throw new EJBUtilsException("EJBUtils.sendToConsegnaContenutiApplicativi error: "+e.getMessage(),e);
  1457.         }
  1458.     }


  1461.     /**
  1462.      * Spedisce una risposta applicativa  
  1463.      * al modulo di openspcoop ConsegnaContenutiApplicativi, 
  1464.      * inserendolo all'interno di  un messaggio di tipo {@link org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativiMessage} e 
  1465.      * spedendolo nella coda 'toConsegnaContenutiApplicativi'.
  1466.      * Utilizza la definizione dell'invocazione servizio se il tipo di consegna e':
  1467.      * <ul>
  1468.      *  <li>OneWay_InvocazioneServizio
  1469.      *  <li>Sincrono_InvocazioneServizio
  1470.      *  <li>AsincronoSimmetrico_InvocazioneServizio
  1471.      *  <li>AsincronoAsimmetrico_InvocazioneServizio
  1472.      * </ul>
  1473.      * Utilizza invece la definizione della consegna contenuti asincroni, se il tipo e': AsincronoAsimmetrico_Polling
  1474.      * Se il tipo e' diverso da quelli elencati, viene sollevata una eccezione.
  1475.      *
  1476.      * @param richiestaApplicativa RichiestaApplicativa
  1477.      * @param busta Busta che raccoglie i dati dell'invocazione di servizio
  1478.      * @param gestoreMessaggi il Gestore Messaggi utilizzato per la registrazione dei destinatari del messaggio
  1479.      * 
  1480.      */
  1481.     private boolean gestioneStatelessConIntegrationManager = false;
  1482.     public boolean isGestioneStatelessConIntegrationManager() {
  1483.         return this.gestioneStatelessConIntegrationManager;
  1484.     }
  1485.     private boolean gestioneSolamenteConIntegrationManager = false;
  1486.     public boolean isGestioneSolamenteConIntegrationManager() {
  1487.         return this.gestioneSolamenteConIntegrationManager;
  1488.     }
  1489.     public Behaviour sendToConsegnaContenutiApplicativi(RequestInfo requestInfo,
  1490.             RichiestaApplicativa richiestaApplicativa,Busta busta,
  1491.             GestoreMessaggi gestoreMessaggi,PortaApplicativa pa,RepositoryBuste repositoryBuste) throws EJBUtilsException{
  1492.         return sendToConsegnaContenutiApplicativi(requestInfo,richiestaApplicativa, busta, gestoreMessaggi, pa, repositoryBuste, null);
  1493.     }
  1494.     public Behaviour sendToConsegnaContenutiApplicativi(RequestInfo requestInfo,
  1495.             RichiestaApplicativa richiestaApplicativa,Busta busta,
  1496.             GestoreMessaggi gestoreMessaggi,PortaApplicativa pa,RepositoryBuste repositoryBuste,
  1497.             RichiestaDelegata localForwardRichiestaDelegata) throws EJBUtilsException{

  1499.         try{
  1500.         
  1501.             Behaviour behaviour = null;
  1502.             
  1503.             
  1504.             boolean soggettoVirtuale = false;
  1505.             if(richiestaApplicativa!=null &&
  1506.                     richiestaApplicativa.getIDServizio()!=null &&
  1507.                             richiestaApplicativa.getIDServizio().getSoggettoErogatore()!=null){     
  1508.                 soggettoVirtuale = this.configurazionePdDReader.isSoggettoVirtuale( richiestaApplicativa.getIDServizio().getSoggettoErogatore(), requestInfo );
  1509.             }
  1510.             
  1511.             
  1512.             /* ----- Indicazione Stateless ----- */
  1513.             boolean stateless = false;
  1514.             if(!soggettoVirtuale) {
  1515.                 if(localForwardRichiestaDelegata!=null){
  1516.                     stateless = this.portaDiTipoStateless_esclusoOneWay11;
  1517.                 }else{
  1518.                     stateless = this.configurazionePdDReader.isModalitaStateless(pa, busta.getProfiloDiCollaborazione());
  1519.                 }
  1520.             }
  1521.             
  1522.             if(pa!=null){
  1523.                 this.msgDiag.addKeyword(CostantiPdD.KEY_PORTA_APPLICATIVA, pa.getNome());
  1524.             }
  1525.             
  1526.             
  1527.             /* ----- Recupero eventuale processo di behaviour ----- */
  1528.             boolean registraNuoviMessaggiViaBehaviour = false;
  1529.             @SuppressWarnings("unused")
  1530.             int sizeNuoviMessaggiViaBehaviour = -1;
  1531.             BehaviourForwardToFilter singleFilterBehaviour = null;
  1532.             boolean behaviourResponseTo = false;
  1533.             IDServizioApplicativo behaviour_idSA_SyncResponder = null;
  1534.             MessaggioDaNotificare tipiMessaggiNotificabili = null;
  1535.             IBehaviour behaviourImpl = null;
  1536.             // pa is null nel caso di soggetto virtuale
  1537.             if(pa!=null && pa.getBehaviour()!=null && pa.getBehaviour().getNome()!=null && !"".equals(pa.getBehaviour().getNome())){
  1538.                 
  1539.                 behaviourImpl = BehaviourLoader.newInstance(pa.getBehaviour(), this.msgDiag,
  1540.                         this.pddContext, this.protocolFactory,
  1541.                         this.openSPCoopState!=null ? this.openSPCoopState.getStatoRichiesta() : null);
  1542.                 
  1543.                 gestoreMessaggi.setPortaDiTipoStateless(stateless);
  1544.                 behaviour = behaviourImpl.behaviour(gestoreMessaggi, busta, pa, requestInfo);
  1545.                                 
  1546.                 behaviourResponseTo = behaviour!=null && behaviour.isResponseTo();
  1547.                 
  1548.                 if(behaviour!=null) {
  1549.                     behaviour_idSA_SyncResponder = behaviour.getApplicativeSyncResponder();
  1550.                 }
  1551.                 
  1552.                 if(behaviour!=null && behaviour.getForwardTo()!=null){
  1553.                     if(behaviour.getForwardTo().size()>1){
  1554.                         registraNuoviMessaggiViaBehaviour = true;
  1555.                         if(behaviourResponseTo==false){
  1556.                             throw new Exception("La consegna di messaggi multipli via custom behaviour (tipo:"+pa.getBehaviour().getNome()+
  1557.                                     ") e' permessa solo se viene abilita anche la funzione 'responseTo'");
  1558.                         }
  1559.                         for (int i=0; i<behaviour.getForwardTo().size(); i++) {
  1560.                             BehaviourForwardTo forwardTo = behaviour.getForwardTo().get(i);
  1561.                             if(forwardTo.getDescription()==null){
  1562.                                 forwardTo.setDescription("ForwardTo["+i+"]");
  1563.                             }
  1564.                             if(forwardTo.getMessage()==null){
  1565.                                 throw new Exception("La consegna di messaggi multipli via custom behaviour (tipo:"+pa.getBehaviour().getNome()+
  1566.                                         ") richiede che vengano definiti tutti i messaggi da inoltrare. Trovato un elemento ForwardTo ("+
  1567.                                         forwardTo.getDescription()+") che non contiene alcun messaggio");
  1568.                             }
  1569.                         }
  1570.                     }
  1571.                     else if(behaviour.getForwardTo().size()==1){
  1572.                         
  1573.                         BehaviourForwardTo forwardTo = behaviour.getForwardTo().get(0);
  1574.                         if(forwardTo.getDescription()==null){
  1575.                             forwardTo.setDescription("ForwardTo");
  1576.                         }
  1577.                         
  1578.                         if(forwardTo.getMessage()!=null){
  1579.                             if(behaviourResponseTo){
  1580.                                 registraNuoviMessaggiViaBehaviour = true;
  1581.                             }
  1582.                             else{
  1583.                                 // e' stata effettuata solamente una trasformazione del messaggio
  1584.                                 // Se siamo stateless non devo fare niente, l'oggetto in memoria contiene gia' la modifica.
  1585.                                 // Altrimenti se stiamo stateful viene comunque applicata l'eliminazione del vecchio messaggio
  1586.                                 // ed il salvataggio del nuovo modificato.
  1587.                                 if(!stateless){
  1588.                                     registraNuoviMessaggiViaBehaviour = true;
  1589.                                 }
  1590.                             }
  1591.                         }
  1592.                         else{                           
  1593.                             singleFilterBehaviour = behaviour.getForwardTo().get(0).getFilter();
  1594.                         }
  1595.                     }
  1596.                 }
  1597.                 
  1598.                 if(registraNuoviMessaggiViaBehaviour){

  1600.                     String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1601.                     IOpenSPCoopState stateGestoreMessaggiBehaviour_newConnection_old = null;
  1602.                     OpenSPCoopStateless stateGestoreMessaggiBehaviour_newConnection = null;
  1603.                     OpenSPCoopStateless stateGestoreMessaggiBehaviour_onlyUseConnectionFalse = null;
  1604.                     boolean oldUseConnection = false;
  1605.                     try{
  1606.                         if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  1607.                             boolean createNew = true;
  1608.                             if( (gestoreMessaggi.getOpenspcoopstate() instanceof OpenSPCoopStateless)) {
  1609.                                 OpenSPCoopStateless check = (OpenSPCoopStateless) gestoreMessaggi.getOpenspcoopstate();
  1610.                                 if(check.getConnectionDB()!=null && check.getConnectionDB().isClosed()==false) {
  1611.                                     createNew = false;
  1612.                                     stateGestoreMessaggiBehaviour_onlyUseConnectionFalse = (OpenSPCoopStateless) gestoreMessaggi.getOpenspcoopstate();
  1613.                                     oldUseConnection = check.isUseConnection();
  1614.                                     stateGestoreMessaggiBehaviour_onlyUseConnectionFalse.setUseConnection(true);
  1615.                                 }
  1616.                             }
  1617.                             
  1618.                             if(createNew) {
  1619.                                 
  1620.                                 stateGestoreMessaggiBehaviour_newConnection_old = gestoreMessaggi.getOpenspcoopstate();
  1621.                                 
  1622.                                 stateGestoreMessaggiBehaviour_newConnection = new OpenSPCoopStateless();
  1623.                                 stateGestoreMessaggiBehaviour_newConnection.setUseConnection(true);
  1624.                                 stateGestoreMessaggiBehaviour_newConnection.setTempiAttraversamentoPDD(((OpenSPCoopStateless)this.openSPCoopState).getTempiAttraversamentoPDD());
  1625.                                 stateGestoreMessaggiBehaviour_newConnection.setDimensioneMessaggiAttraversamentoPDD(((OpenSPCoopStateless)this.openSPCoopState).getDimensioneMessaggiAttraversamentoPDD());
  1626.                                 stateGestoreMessaggiBehaviour_newConnection.setIDCorrelazioneApplicativa(((OpenSPCoopStateless)this.openSPCoopState).getIDCorrelazioneApplicativa());
  1627.                                 stateGestoreMessaggiBehaviour_newConnection.setIDCorrelazioneApplicativaRisposta(((OpenSPCoopStateless)this.openSPCoopState).getIDCorrelazioneApplicativaRisposta());
  1628.                                 stateGestoreMessaggiBehaviour_newConnection.setPddContext(((OpenSPCoopStateless)this.openSPCoopState).getPddContext());
  1629.                                 stateGestoreMessaggiBehaviour_newConnection.initResource(this.identitaPdD, "EJBUtils.behaviour_"+pa.getBehaviour().getNome(), idTransazione);
  1630.                                 gestoreMessaggi.updateOpenSPCoopState(stateGestoreMessaggiBehaviour_newConnection);
  1631.                                 
  1632.                             }
  1633.                         }
  1634.                     
  1635.                         sizeNuoviMessaggiViaBehaviour = behaviour.getForwardTo().size();
  1636.                             
  1637.                         // elimino l'attuale messaggio
  1638.                         if(localForwardRichiestaDelegata!=null){
  1639.                             
  1640.                             if(stateless){
  1641.                                 repositoryBuste.eliminaUtilizzoPdDFromInBox(busta.getID(),false);
  1642.                             }
  1643.                             else{
  1644.                                 repositoryBuste.eliminaUtilizzoPdDFromInBox(busta.getID(),true);
  1645.                             }
  1646.                             
  1647.                             gestoreMessaggi.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  1648.                             
  1649.                         }
  1650.                         else{
  1651.                             
  1652.                             if(stateless){
  1653.                                 repositoryBuste.eliminaUtilizzoPdDFromInBox(busta.getID(),repositoryBuste.isRegistrazioneInCorso());
  1654.                             }
  1655.                             else{
  1656.                                 repositoryBuste.eliminaUtilizzoPdDFromInBox(busta.getID(),true);
  1657.                             }
  1658.                         
  1659.                             // Forzo oneway1.1 per farlo registrare anche se siamo in stateless puro
  1660.                             boolean originalValue = gestoreMessaggi.isOneWayVersione11();
  1661.                             gestoreMessaggi.setOneWayVersione11(true);
  1662.                             gestoreMessaggi.logicDeleteMessage();
  1663.                             gestoreMessaggi.setOneWayVersione11(originalValue);
  1664.                             
  1665.                         }
  1666.                         
  1667.                         // Applico modifiche effettuate dal modulo Consegna
  1668.                         if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  1669.                             if(stateGestoreMessaggiBehaviour_newConnection!=null) {
  1670.                                 if(stateGestoreMessaggiBehaviour_newConnection.resourceReleased()){
  1671.                                     // il modulo di consegna rilascia la risorsa
  1672.                                     stateGestoreMessaggiBehaviour_newConnection.updateResource(idTransazione);
  1673.                                 }
  1674.                                 stateGestoreMessaggiBehaviour_newConnection.commit();
  1675.                             }
  1676.                             else if(stateGestoreMessaggiBehaviour_onlyUseConnectionFalse!=null) {
  1677.                                 stateGestoreMessaggiBehaviour_onlyUseConnectionFalse.commit();
  1678.                             }
  1679.                         }
  1680.                         
  1681.                     }finally{
  1682.                         if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  1683.                             if(stateGestoreMessaggiBehaviour_newConnection!=null){
  1684.                                 stateGestoreMessaggiBehaviour_newConnection.releaseResource();
  1685.                                 gestoreMessaggi.updateOpenSPCoopState(stateGestoreMessaggiBehaviour_newConnection_old);
  1686.                             }
  1687.                             else if(stateGestoreMessaggiBehaviour_onlyUseConnectionFalse!=null) {
  1688.                                 stateGestoreMessaggiBehaviour_onlyUseConnectionFalse.setUseConnection(oldUseConnection);
  1689.                             }
  1690.                         }
  1691.                     }
  1692.                 }
  1693.                 else{
  1694.                     // se non devo registrare alcun messaggio, e sono in stateless, ma e' stata configurata una replyTo
  1695.                     // ritorno errore, poiche' deve essere configurato un messaggio da inoltrare.
  1696.                     if(stateless && behaviourResponseTo){
  1697.                         throw new Exception("La definizione dell'elemento 'responseTo', via custom behaviour (tipo:"+pa.getBehaviour().getNome()+
  1698.                                 "), in una porta applicativa stateless richiede la definizione almeno di un elemento forwardTo contenente un messaggio da inoltrare.");
  1699.                     }
  1700.                 }
  1701.                 
  1702.             }
  1703.             
  1704.             
  1705.             /* ----- Check Tipo ----- */
  1706.             if(richiestaApplicativa==null) {
  1707.                 throw new Exception("Tipo di consegna sconosciuta (RichiestaApplicativa non definita)");
  1708.             }
  1709.             if( (Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) == false) &&
  1710.                     (Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) == false) && 
  1711.                     (Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) == false) &&
  1712.                     (Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) == false) &&
  1713.                     (Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(richiestaApplicativa.getScenario()) == false)   ){
  1714.                 throw new Exception("Tipo di consegna sconosciuta");
  1715.             }
  1716.             

  1718.             /* ----- Raccolta servizi applicativi collegati alla porta applicativa ----- */
  1719.             String [] serviziApplicativiConfigurazione = null;
  1720.             SoggettoVirtuale soggettiRealiMappatiInUnSoggettoVirtuale = null;
  1721.             IDSoggetto soggettoDestinatario = richiestaApplicativa.getIDServizio().getSoggettoErogatore();
  1722.             if( Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(richiestaApplicativa.getScenario())  ){
  1723.                 // Lettura da ricezione contenuti asincroni
  1724.                 serviziApplicativiConfigurazione  = this.configurazionePdDReader.getServiziApplicativi(pa);
  1725.                 if(serviziApplicativiConfigurazione == null){
  1726.                     throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"servizioApplicativoNonDefinito");
  1727.                 }
  1728.             }else{
  1729.                 // lettura da invocazione servizio
  1730.                 if(soggettoVirtuale){       
  1731.                     SoggettoVirtuale soggettiVirtuali = this.configurazionePdDReader.getServiziApplicativiSoggettiVirtuali(richiestaApplicativa);
  1732.                     if(soggettiVirtuali == null){
  1733.                         throw new EJBUtilsConsegnaException("(SoggettoVirtuale) "+this.msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"servizioApplicativoNonDefinito"),
  1734.                                 this.msgDiag.getLivello(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"servizioApplicativoNonDefinito"),
  1735.                                 this.msgDiag.getCodice(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"servizioApplicativoNonDefinito"));
  1736.                     }
  1737.                     boolean GESTISCI_BEHAVIOUR = true;
  1738.                     List<String> idServiziApplicativiVirtuali = soggettiVirtuali.getIdServiziApplicativi(GESTISCI_BEHAVIOUR,gestoreMessaggi,busta, requestInfo,
  1739.                             this.pddContext, this.protocolFactory,
  1740.                             this.openSPCoopState!=null ? this.openSPCoopState.getStatoRichiesta() : null);
  1741.                     if(idServiziApplicativiVirtuali.size()>0){
  1742.                         serviziApplicativiConfigurazione = idServiziApplicativiVirtuali.toArray(new String[1]);
  1743.                     }
  1744.                     soggettiRealiMappatiInUnSoggettoVirtuale = soggettiVirtuali;
  1745.                 }else{
  1746.                     serviziApplicativiConfigurazione  = this.configurazionePdDReader.getServiziApplicativi(pa);
  1747.                     if(serviziApplicativiConfigurazione == null){ 
  1748.                         throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"servizioApplicativoNonDefinito");
  1749.                     }
  1750.                 }
  1751.             }


  1754.             /* ----- Controllo esistenza di almeno un servizio applicativo ----- */
  1755.             if( serviziApplicativiConfigurazione==null || serviziApplicativiConfigurazione.length < 1){
  1756.                 throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"servizioApplicativoNonDefinito");
  1757.             }
  1758.             List<String> serviziApplicativiAbilitati = new ArrayList<>();
  1759.             List<IDServizioApplicativo> idServiziApplicativiAbilitati = new ArrayList<IDServizioApplicativo>();
  1760.             for (int i = 0; i < serviziApplicativiConfigurazione.length; i++) {
  1761.                 IDServizioApplicativo idSA = new IDServizioApplicativo();
  1762.                 idSA.setIdSoggettoProprietario(soggettoDestinatario);
  1763.                 idSA.setNome(serviziApplicativiConfigurazione[i]);
  1764.                 serviziApplicativiAbilitati.add(serviziApplicativiConfigurazione[i]);
  1765.                 idServiziApplicativiAbilitati.add(idSA);
  1766.             }
  1767.             if(singleFilterBehaviour!=null){
  1768.                 // Dentro qua non si passa se siamo in modalità soggetto virtuale
  1769.                 // Il behaviuor sul filtro è gestito direttamente dentro il metodo soggettiVirtuali.getIdServiziApplicativi() sopra
  1770.                 idServiziApplicativiAbilitati = singleFilterBehaviour.aggiornaDestinatariAbilitati(idServiziApplicativiAbilitati);
  1771.                 serviziApplicativiAbilitati = new ArrayList<>();
  1772.                 for (IDServizioApplicativo idServizioApplicativo : idServiziApplicativiAbilitati) {
  1773.                     serviziApplicativiAbilitati.add(idServizioApplicativo.getNome());
  1774.                 }
  1775.             }
  1776.             if( serviziApplicativiAbilitati.size() < 1 && (behaviour_idSA_SyncResponder==null) ){
  1777.                 throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"behaviour.servizioApplicativoNonDefinito");
  1778.             }

  1780.             

  1782.             /* ----- Controllo che servizi applicativi multipli siano collegati solo a profilo OneWay (a meno di abilitare il behaviour personalizzato) ----- */
  1783.             // Questo per poter ritornare una risposta
  1784.             if(registraNuoviMessaggiViaBehaviour==false || behaviourResponseTo==false){
  1785.                 if(behaviour_idSA_SyncResponder==null) {
  1786.                     if( (Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario()) == false) &&
  1787.                             (serviziApplicativiAbilitati.size() > 1)){
  1788.                         throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"gestioneProfiloNonOneway.consegnaVersoNServiziApplicativi");
  1789.                     }else if( (Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(richiestaApplicativa.getScenario())) && (this.oneWayVersione11==false) && 
  1790.                             (this.openSPCoopState instanceof OpenSPCoopStateless) &&
  1791.                             (serviziApplicativiAbilitati.size() > 1) )  {
  1792.                         for (String nomeServizioApplicativo : serviziApplicativiAbilitati) {
  1793.                             IDServizioApplicativo idSA = new IDServizioApplicativo();
  1794.                             idSA.setNome(nomeServizioApplicativo);
  1795.                             idSA.setIdSoggettoProprietario(richiestaApplicativa.getIDServizio().getSoggettoErogatore());
  1796.                             ServizioApplicativo sappl = this.configurazionePdDReader.getServizioApplicativo(idSA,requestInfo);
  1797.                             boolean servizioApplicativoConConnettore = this.configurazionePdDReader.invocazioneServizioConConnettore(sappl);
  1798.                             boolean getMessageAbilitato = this.configurazionePdDReader.invocazioneServizioConGetMessage(sappl);
  1799.                             if(servizioApplicativoConConnettore || (getMessageAbilitato==false)){
  1800.                                 throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"gestioneStateless.consegnaVersoNServiziApplicativi");
  1801.                             }
  1802.                         }
  1803.                     }
  1804.                 }
  1805.             }
  1806.             
  1807.             boolean EFFETTUA_SPEDIZIONE_CONSEGNA_CONTENUTI = true;
  1808.             boolean ATTENDI_ESITO_TRANSAZIONE_SINCRONA_PRIMA_DI_SPEDIRE = true; 

  1810.             /* ----- Registro destinatari messaggi e spedizione messaggi ----- */
  1811.             if(behaviour_idSA_SyncResponder==null && (behaviour==null || !registraNuoviMessaggiViaBehaviour)){
  1812.                 
  1813.                 List<String> serviziApplicativiAbilitatiById = DriverConfigurazioneDB.normalizeConnettoriMultpliById(serviziApplicativiAbilitati, pa);
  1814.                 if(serviziApplicativiAbilitatiById!=null && !serviziApplicativiAbilitatiById.isEmpty()) {
  1815.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_CONNETTORI_BY_ID, serviziApplicativiAbilitatiById);
  1816.                 }
  1817.                 
  1818.                 _sendMessageToServiziApplicativi(serviziApplicativiAbilitati, soggettiRealiMappatiInUnSoggettoVirtuale, 
  1819.                         richiestaApplicativa, localForwardRichiestaDelegata, gestoreMessaggi, busta, pa, repositoryBuste,
  1820.                         null,null,stateless,this.openSPCoopState,false,
  1821.                         null,
  1822.                         EFFETTUA_SPEDIZIONE_CONSEGNA_CONTENUTI,!ATTENDI_ESITO_TRANSAZIONE_SINCRONA_PRIMA_DI_SPEDIRE,
  1823.                         behaviour!=null ? behaviour.getLoadBalancer() : null, false,
  1824.                         null,
  1825.                         requestInfo);
  1826.             }
  1827.             else{
  1828.                 
  1829.                 boolean attendiEsitoTransazioneSincronaPrimaDiSpedire = false;
  1830.                 
  1831.                 if(behaviour_idSA_SyncResponder!=null) {
  1832.                     
  1833.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_SINCRONA, "true");
  1834.                     
  1835.                     attendiEsitoTransazioneSincronaPrimaDiSpedire = true;
  1836.                     
  1837.                     // TODO CHECK QUA O SOPRA RIGUARDANTE IL CASO INTEGRATINO MANAGER ???? NON PERMESSO ESSENDO SINCRONO???
  1838.                     
  1839.                     List<String> sa_list = new ArrayList<>();
  1840.                     sa_list.add(behaviour_idSA_SyncResponder.getNome());
  1841.                     _sendMessageToServiziApplicativi(sa_list, soggettiRealiMappatiInUnSoggettoVirtuale, 
  1842.                             richiestaApplicativa, localForwardRichiestaDelegata, gestoreMessaggi, busta, pa, repositoryBuste,
  1843.                             null,null,stateless,this.openSPCoopState,false,
  1844.                             null,
  1845.                             EFFETTUA_SPEDIZIONE_CONSEGNA_CONTENUTI,!ATTENDI_ESITO_TRANSAZIONE_SINCRONA_PRIMA_DI_SPEDIRE,
  1846.                             null, false,
  1847.                             null,
  1848.                             requestInfo);
  1849.                 }
  1850.                 
  1851.                 List<BehaviourForwardTo> forwardTo = behaviour.getForwardTo();
  1852.                 for (int i=0; i<forwardTo.size(); i++) {
  1853.                     
  1854.                     BehaviourForwardTo behaviourForwardTo = forwardTo.get(i);
  1855.                     
  1856.                     // check servizi applicativi
  1857.                     List<String> serviziApplicativiAbilitatiForwardTo = new ArrayList<>();
  1858.                     List<IDServizioApplicativo> idServiziApplicativiAbilitatiForwardTo = new ArrayList<IDServizioApplicativo>();
  1859.                     serviziApplicativiAbilitatiForwardTo.addAll(serviziApplicativiAbilitati);
  1860.                     idServiziApplicativiAbilitatiForwardTo.addAll(idServiziApplicativiAbilitati);
  1861.                     if(behaviourForwardTo.getFilter()!=null){
  1862.                         idServiziApplicativiAbilitatiForwardTo = behaviourForwardTo.getFilter().aggiornaDestinatariAbilitati(idServiziApplicativiAbilitati);
  1863.                         serviziApplicativiAbilitatiForwardTo = new ArrayList<>();
  1864.                         for (IDServizioApplicativo idServizioApplicativo : idServiziApplicativiAbilitatiForwardTo) {
  1865.                             serviziApplicativiAbilitatiForwardTo.add(idServizioApplicativo.getNome());
  1866.                         }
  1867.                     }   
  1868.                     if( serviziApplicativiAbilitatiForwardTo.size() < 1 && (behaviour_idSA_SyncResponder==null) ){
  1869.                         throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"behaviour.servizioApplicativoNonDefinito");
  1870.                     }
  1871.                     
  1872.                     List<String> serviziApplicativiAbilitatiForwardToNormalizedById = DriverConfigurazioneDB.normalizeConnettoriMultpliById(serviziApplicativiAbilitatiForwardTo, pa);
  1873.                     if(serviziApplicativiAbilitatiForwardToNormalizedById!=null && !serviziApplicativiAbilitatiForwardToNormalizedById.isEmpty()) {
  1874.                         this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_CONNETTORI_BY_ID, serviziApplicativiAbilitatiForwardToNormalizedById);
  1875.                     }
  1876.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_CONNETTORI, serviziApplicativiAbilitatiForwardTo.size());
  1877.                     if(serviziApplicativiAbilitatiForwardTo!=null && !serviziApplicativiAbilitatiForwardTo.isEmpty()) {
  1878.                         this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONSEGNA_MULTIPLA_CONNETTORI_BY_SA, serviziApplicativiAbilitatiForwardTo);
  1879.                     }
  1880.                                         
  1881.                     if(behaviourImpl instanceof MultiDeliverBehaviour) {
  1882.                         MultiDeliverBehaviour multi = (MultiDeliverBehaviour) behaviourImpl;
  1883.                         if(TipoBehaviour.CONSEGNA_CON_NOTIFICHE.equals(multi.getBt())) {
  1884.                             tipiMessaggiNotificabili = org.openspcoop2.pdd.core.behaviour.built_in.multi_deliver.MultiDeliverUtils.readMessaggiNotificabili(pa, serviziApplicativiAbilitatiForwardTo);
  1885.                         }
  1886.                     }
  1887.                     
  1888.                     String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  1889.                     OpenSPCoopStateless stateBehaviour_newConnection = null;
  1890.                     OpenSPCoopStateless stateBehaviour_onlyUseConnectionFalse = null;
  1891.                     boolean oldUseConnection = false;
  1892.                     try{
  1893.                         if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  1894.                             boolean createNew = true;
  1895.                             if( (this.openSPCoopState instanceof OpenSPCoopStateless)) {
  1896.                                 OpenSPCoopStateless check = (OpenSPCoopStateless) this.openSPCoopState;
  1897.                                 if(check.getConnectionDB()!=null && check.getConnectionDB().isClosed()==false) {
  1898.                                     createNew = false;
  1899.                                     stateBehaviour_onlyUseConnectionFalse = (OpenSPCoopStateless) this.openSPCoopState;
  1900.                                     oldUseConnection = check.isUseConnection();
  1901.                                     stateBehaviour_onlyUseConnectionFalse.setUseConnection(true);
  1902.                                 }
  1903.                             }
  1904.                             
  1905.                             if(createNew) {
  1906.                                 stateBehaviour_newConnection = new OpenSPCoopStateless();
  1907.                                 stateBehaviour_newConnection.setUseConnection(true);
  1908.                                 stateBehaviour_newConnection.setTempiAttraversamentoPDD(((OpenSPCoopStateless)this.openSPCoopState).getTempiAttraversamentoPDD());
  1909.                                 stateBehaviour_newConnection.setDimensioneMessaggiAttraversamentoPDD(((OpenSPCoopStateless)this.openSPCoopState).getDimensioneMessaggiAttraversamentoPDD());
  1910.                                 stateBehaviour_newConnection.setIDCorrelazioneApplicativa(((OpenSPCoopStateless)this.openSPCoopState).getIDCorrelazioneApplicativa());
  1911.                                 stateBehaviour_newConnection.setIDCorrelazioneApplicativaRisposta(((OpenSPCoopStateless)this.openSPCoopState).getIDCorrelazioneApplicativaRisposta());
  1912.                                 stateBehaviour_newConnection.setPddContext(((OpenSPCoopStateless)this.openSPCoopState).getPddContext());
  1913.                                 stateBehaviour_newConnection.initResource(this.identitaPdD, "EJBUtils.behaviour_"+pa.getBehaviour().getNome(), idTransazione);
  1914.                             }
  1915.                         }
  1916.                     
  1917.                         // registrazione messaggio
  1918.                         //  Utilizzo le utility di Memorizzazione Stateless
  1919.                         Busta bustaNewMessaggio = behaviourForwardTo.getBusta();
  1920.                         if(bustaNewMessaggio==null){
  1921.                             bustaNewMessaggio = busta.newInstance();
  1922.                             bustaNewMessaggio.setID(CostantiPdD.PREFIX_MESSAGGIO_CONNETTORE_MULTIPLO+i+CostantiPdD.SEPARATOR_MESSAGGIO_CONNETTORE_MULTIPLO+busta.getID());
  1923.                         }
  1924.                         bustaNewMessaggio.setRiferimentoMessaggio(busta.getID()); // per il timer
  1925.                         bustaNewMessaggio.addProperty(CostantiPdD.KEY_DESCRIZIONE_BEHAVIOUR, behaviourForwardTo.getDescription());
  1926.                         IOpenSPCoopState stateNuoviMessaggi = this.openSPCoopState;
  1927.                         if(stateBehaviour_newConnection!=null){
  1928.                             stateNuoviMessaggi = stateBehaviour_newConnection;
  1929.                         }
  1930.                         else if(stateBehaviour_onlyUseConnectionFalse!=null) {
  1931.                             stateNuoviMessaggi = stateBehaviour_onlyUseConnectionFalse;
  1932.                         }
  1933.                         GestoreMessaggi gestoreNewMessaggio = new GestoreMessaggi(stateNuoviMessaggi,true, bustaNewMessaggio.getID(),
  1934.                                 Costanti.INBOX,this.msgDiag,this.pddContext);
  1935.                         RepositoryBuste repositoryBusteNewMessaggio = new RepositoryBuste(stateNuoviMessaggi.getStatoRichiesta(),true, this.protocolFactory);
  1936.                         
  1937.                         OpenSPCoop2Message messaggioDaNotificare = behaviourForwardTo.getMessage();
  1938.                         if(tipiMessaggiNotificabili!=null && MessaggioDaNotificare.RISPOSTA.equals(tipiMessaggiNotificabili)) {
  1939.                             // verrà salvata dopo, la richiesta salvata deve essere un messaggio trascurabile
  1940.                             messaggioDaNotificare = messaggioDaNotificare.getFactory().createEmptyMessage(MessageType.BINARY, MessageRole.NONE);
  1941.                         }
  1942.                         
  1943.                         Timestamp oraRegistrazione = _forceSaveMessage(this.propertiesReader, gestoreNewMessaggio, null, bustaNewMessaggio, richiestaApplicativa, repositoryBusteNewMessaggio,
  1944.                                 messaggioDaNotificare,stateNuoviMessaggi,
  1945.                                 this.pddContext, this.identitaPdD); // per eventuale thread riconsegna in caso di errore
  1946.     //                  if(stateless){
  1947.     //                      ((OpenSPCoopStateless)this.openSPCoopState).setRichiestaMsg(behaviourForwardTo.getMessage());
  1948.     //                  }
  1949.                                             
  1950.                         // Inoltro messaggio
  1951.                         _sendMessageToServiziApplicativi(serviziApplicativiAbilitatiForwardTo, soggettiRealiMappatiInUnSoggettoVirtuale, 
  1952.                                 richiestaApplicativa, localForwardRichiestaDelegata, gestoreNewMessaggio, bustaNewMessaggio, pa, repositoryBusteNewMessaggio,
  1953.                                 busta.getID(),behaviourForwardTo.getConfig(), stateless, stateNuoviMessaggi, (stateBehaviour_newConnection!=null),
  1954.                                 behaviourForwardTo.getMessage(),
  1955.                                 !EFFETTUA_SPEDIZIONE_CONSEGNA_CONTENUTI, attendiEsitoTransazioneSincronaPrimaDiSpedire,
  1956.                                 null, true,
  1957.                                 oraRegistrazione,
  1958.                                 requestInfo);
  1959.                         
  1960.                         // Applico modifiche effettuate dal modulo Consegna
  1961.                         if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  1962.                             if(stateBehaviour_newConnection!=null) {
  1963.                                 if(stateBehaviour_newConnection.resourceReleased()){
  1964.                                     // il modulo di consegna rilascia la risorsa
  1965.                                     stateBehaviour_newConnection.updateResource(idTransazione);
  1966.                                 }
  1967.                                 stateBehaviour_newConnection.commit();
  1968.                             }
  1969.                             else if(stateBehaviour_onlyUseConnectionFalse!=null) {
  1970.                                 stateBehaviour_onlyUseConnectionFalse.commit();
  1971.                             }
  1972.                         }
  1973.                         
  1974.                     }finally{
  1975.                         if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  1976.                             if(stateBehaviour_newConnection!=null){
  1977.                                 stateBehaviour_newConnection.releaseResource();
  1978.                             }
  1979.                             else if(stateBehaviour_onlyUseConnectionFalse!=null) {
  1980.                                 stateBehaviour_onlyUseConnectionFalse.setUseConnection(oldUseConnection);
  1981.                             }
  1982.                         }
  1983.                     }
  1984.                 }
  1985.                     
  1986.             }

  1988.             
  1989.             return behaviour;
  1990.             
  1991.         } catch (EJBUtilsConsegnaException e) { 
  1992.             throw e;
  1993.         } catch (Exception e) {
  1994.             this.log.error("Spedizione->ConsegnaContenutiApplicativi(RichiestaApplicativa) non riuscita",e);
  1995.             this.log.error("EJBUtils.sendToConsegnaContenutiApplicativi(RichiestaApplicativa)",e);
  1996.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendToConsegnaContenutiApplicativi(RichiestaApplicativa)");
  1997.             throw new EJBUtilsException("EJBUtils.sendToConsegnaContenutiApplicativi error: "+e.getMessage(),e);
  1998.         }
  1999.     }


  2002.     @SuppressWarnings("deprecation")
  2003.     private static void overwriteIdSoggetto(IDServizio idServizio, IDSoggetto idSoggetto){
  2004.         idServizio.setSoggettoErogatore(idSoggetto);
  2005.     }

  2007.     private void _sendMessageToServiziApplicativi(List<String> serviziApplicativi, SoggettoVirtuale soggettiRealiMappatiInUnSoggettoVirtuale,
  2008.             RichiestaApplicativa richiestaApplicativaParam, RichiestaDelegata localForwardRichiestaDelegata,
  2009.             GestoreMessaggi gestoreMessaggi, Busta busta, PortaApplicativa pa, RepositoryBuste repositoryBuste,
  2010.             String idBustaPreBehaviourNewMessage,BehaviourForwardToConfiguration behaviourForwardToConfiguration,
  2011.             boolean stateless,IOpenSPCoopState state,boolean releseaResource,
  2012.             OpenSPCoop2Message requestMessageNullable,
  2013.             boolean spedizioneConsegnaContenuti, boolean attendiEsitoTransazioneSincronaPrimaDiSpedire,
  2014.             BehaviourLoadBalancer loadBalancer, boolean presaInCarico,
  2015.             Timestamp dataRegistrazioneMessaggio,
  2016.             RequestInfo requestInfo) throws Exception{
  2017.         
  2018.         // Eventuale indicazione per la registrazione via stateless
  2019.         boolean registrazioneMessaggioPerStatelessEffettuata = false;
  2020.         
  2021.         boolean gestioneSolamenteConIntegrationManager = true;
  2022.         
  2023.         Map<String, Boolean> mapServizioApplicativoConConnettore = new HashMap<String, Boolean>();
  2024.         Map<String, Boolean> mapSbustamentoSoap = new HashMap<String, Boolean>();
  2025.         Map<String, Boolean> mapSbustamentoInformazioniProtocollo = new HashMap<String, Boolean>();
  2026.         Map<String, Boolean> mapGetMessage = new HashMap<String, Boolean>();
  2027.         Map<String, String> mapTipoConsegna = new HashMap<>();
  2028.         Map<String, Timestamp> mapOraRegistrazione = new HashMap<String, Timestamp>();
  2029.         Map<String, ConsegnaContenutiApplicativiMessage> mapConsegnaContenutiApplicativiMessage = new HashMap<String, ConsegnaContenutiApplicativiMessage>();
  2030.         
  2031.         RichiestaApplicativa richiestaApplicativa = null;
  2032.         if(richiestaApplicativaParam!=null) {
  2033.             richiestaApplicativa = (RichiestaApplicativa) richiestaApplicativaParam.clone();
  2034.         }
  2035.         
  2036.         String nomePorta = null;
  2037.         if(richiestaApplicativa!=null && richiestaApplicativa.getIdPortaApplicativa()!=null){
  2038.             nomePorta = richiestaApplicativa.getIdPortaApplicativa().getNome();
  2039.         }
  2040.         
  2041.         // Fase di Registrazione
  2042.         for (String servizioApplicativo : serviziApplicativi) {

  2044.             // effettuo correzioni dovute al Soggetto Virtuale
  2045.             if(soggettiRealiMappatiInUnSoggettoVirtuale!=null){
  2046.                 
  2047.                 String oldDominio = richiestaApplicativa.getIDServizio().getSoggettoErogatore().getCodicePorta();
  2048.                 overwriteIdSoggetto(richiestaApplicativa.getIDServizio(), soggettiRealiMappatiInUnSoggettoVirtuale.getSoggettoReale(servizioApplicativo));
  2049.                 richiestaApplicativa.getIDServizio().getSoggettoErogatore().setCodicePorta(oldDominio);
  2050.                 
  2051.                 richiestaApplicativa.setIdPortaApplicativa(soggettiRealiMappatiInUnSoggettoVirtuale.getIDPortaApplicativa(servizioApplicativo));
  2052.                 
  2053.                 servizioApplicativo = soggettiRealiMappatiInUnSoggettoVirtuale.getNomeServizioApplicativo(servizioApplicativo);
  2054.             }
  2055.             
  2056.             this.msgDiag.highDebug("[EJBUtils] Creazione ObjectMessage for send nell'infrastruttura.");
  2057.             ConsegnaContenutiApplicativiMessage consegnaMSG = new ConsegnaContenutiApplicativiMessage();
  2058.             consegnaMSG.setBusta(busta);
  2059.             consegnaMSG.setOneWayVersione11(this.oneWayVersione11);
  2060.             consegnaMSG.setStateless(this.portaDiTipoStateless_esclusoOneWay11);
  2061.             consegnaMSG.setImplementazionePdDSoggettoMittente(this.implementazionePdDSoggettoMittente);
  2062.             consegnaMSG.setImplementazionePdDSoggettoDestinatario(this.implementazionePdDSoggettoDestinatario);
  2063.             consegnaMSG.setPddContext(this.pddContext);
  2064.             consegnaMSG.setRichiestaDelegata(localForwardRichiestaDelegata);
  2065.             
  2066.             String coda = null;
  2067.             String priorita = null;
  2068.             boolean schedulingNonAttivo = false;
  2069.             if(presaInCarico) {
  2070.                 coda = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_CODA_DEFAULT;
  2071.                 priorita = CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_PRIORITA_DEFAULT;
  2072.             }
  2073.             
  2074.             boolean gestioneTramiteConnettoriMultipli = false;
  2075.             if(idBustaPreBehaviourNewMessage!=null || behaviourForwardToConfiguration!=null) {
  2076.                 gestioneTramiteConnettoriMultipli = true;
  2077.                 ConsegnaContenutiApplicativiBehaviourMessage behaviourMsg = new ConsegnaContenutiApplicativiBehaviourMessage();
  2078.                 behaviourMsg.setIdMessaggioPreBehaviour(idBustaPreBehaviourNewMessage);
  2079.                 behaviourMsg.setBehaviourForwardToConfiguration(behaviourForwardToConfiguration);
  2080.                 IdTransazioneApplicativoServer idTransazioneApplicativoServer = new IdTransazioneApplicativoServer();
  2081.                 idTransazioneApplicativoServer.setIdTransazione(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, this.pddContext));
  2082.                 idTransazioneApplicativoServer.setServizioApplicativoErogatore(servizioApplicativo);
  2083.                 if(pa!=null && pa.getServizioApplicativoList()!=null) {
  2084.                     for (PortaApplicativaServizioApplicativo pasa : pa.getServizioApplicativoList()) {
  2085.                         if(pasa.getNome().equals(servizioApplicativo)) {
  2086.                             if(pasa.getDatiConnettore()!=null) {
  2087.                                 idTransazioneApplicativoServer.setConnettoreNome(pasa.getDatiConnettore().getNome());
  2088.                                 if(presaInCarico) {
  2089.                                     if(pasa.getDatiConnettore().getCoda()!=null) {
  2090.                                         coda = pasa.getDatiConnettore().getCoda();
  2091.                                     }
  2092.                                     if(pasa.getDatiConnettore().getPriorita()!=null) {
  2093.                                         priorita = pasa.getDatiConnettore().getPriorita();
  2094.                                     }
  2095.                                     if(org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO.equals(pasa.getDatiConnettore().getScheduling())) {
  2096.                                         schedulingNonAttivo = true;
  2097.                                     }
  2098.                                 }
  2099.                             }
  2100.                             ConfigurazioneGestioneConsegnaNotifiche configGestioneConsegna = MultiDeliverUtils.read(pasa); 
  2101.                             GestioneErrore gestioneErroreBehaviour = GestioneConsegnaNotificheUtils.toGestioneErrore(configGestioneConsegna);       
  2102.                             behaviourMsg.setGestioneErrore(gestioneErroreBehaviour);
  2103.                             break;
  2104.                         }
  2105.                     }
  2106.                 }
  2107.                 behaviourMsg.setIdTransazioneApplicativoServer(idTransazioneApplicativoServer);
  2108.                 consegnaMSG.setBehaviour(behaviourMsg);
  2109.                 
  2110.                 // aggiorno pddContext per evitare che eventuali salvataggi influenzino la transazione
  2111.                 consegnaMSG.setPddContext(this.pddContext!=null ? (PdDContext) this.pddContext.clone() : null);
  2112.             }
  2113.             
  2114.             if(loadBalancer!=null) {
  2115.                 consegnaMSG.setLoadBalancer(loadBalancer);
  2116.             }
  2117.             
  2118.             // Aggiungo costante servizio applicativo
  2119.             this.msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, servizioApplicativo);
  2120.             
  2121.             // identificativo Porta Applicativa
  2122.             richiestaApplicativa.setServizioApplicativo(servizioApplicativo);
  2123.             
  2124.             IDServizioApplicativo idSA = new IDServizioApplicativo();
  2125.             idSA.setNome(servizioApplicativo);
  2126.             idSA.setIdSoggettoProprietario(richiestaApplicativa.getIDServizio().getSoggettoErogatore());
  2127.             ServizioApplicativo sappl = this.configurazionePdDReader.getServizioApplicativo(idSA, requestInfo);

  2129.             if(!presaInCarico) {
  2130.                 // altrimenti il diagnostico deve finire nella parte "presa in carico"
  2131.                 this.msgDiag.setServizioApplicativo(servizioApplicativo);
  2132.             }

  2134.             // Raccolgo dati per la registrazione
  2135.             boolean servizioApplicativoConConnettore = true; // la ricezione contenuti asincroni lo deve obbligatoriamente contenere
  2136.             boolean getMessageAbilitato = false; // servizio getMessage non utilizzabile per ricezione contenuti asincroni
  2137.             boolean sbustamento_soap = false;
  2138.             boolean sbustamento_informazioni_protocollo = true;
  2139.             if( Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(richiestaApplicativa.getScenario())  ){
  2140.                 // RICEZIONE CONTENUTI ASINCRONI: lettura parametri
  2141.                 sbustamento_soap = this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamento(sappl);
  2142.                 sbustamento_informazioni_protocollo = 
  2143.                     this.configurazionePdDReader.consegnaRispostaAsincronaConSbustamentoInformazioniProtocollo(sappl);
  2144.                 servizioApplicativoConConnettore = this.configurazionePdDReader.consegnaRispostaAsincronaConConnettore(sappl);
  2145.             }else{
  2146.                 // INVOCAZIONE SERVIZIO: lettura parametri
  2147.                 servizioApplicativoConConnettore = this.configurazionePdDReader.invocazioneServizioConConnettore(sappl);
  2148.                 sbustamento_soap = this.configurazionePdDReader.invocazioneServizioConSbustamento(sappl);
  2149.                 sbustamento_informazioni_protocollo =
  2150.                     this.configurazionePdDReader.invocazioneServizioConSbustamentoInformazioniProtocollo(sappl);
  2151.                 getMessageAbilitato = this.configurazionePdDReader.invocazioneServizioConGetMessage(sappl);
  2152.             }
  2153.             // refresh info di sbustamento in base alla configurazione del behaviour
  2154.             if(behaviourForwardToConfiguration!=null){
  2155.                 if(behaviourForwardToConfiguration.getSbustamentoInformazioniProtocollo()!=null){
  2156.                     if(StatoFunzionalita.ABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoInformazioniProtocollo())){
  2157.                         sbustamento_informazioni_protocollo = true;
  2158.                     }
  2159.                     else if(StatoFunzionalita.DISABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoInformazioniProtocollo())){
  2160.                         sbustamento_informazioni_protocollo = false;
  2161.                     }
  2162.                 }
  2163.                 if(behaviourForwardToConfiguration.getSbustamentoSoap()!=null){
  2164.                     if(StatoFunzionalita.ABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoSoap())){
  2165.                         sbustamento_soap = true;
  2166.                     }
  2167.                     else if(StatoFunzionalita.DISABILITATA.equals(behaviourForwardToConfiguration.getSbustamentoSoap())){
  2168.                         sbustamento_soap = false;
  2169.                     }
  2170.                 }
  2171.             }
  2172.             if(localForwardRichiestaDelegata!=null){
  2173.                 // Se vi e' stato un local forward, il protocollo non sussiste.
  2174.                 sbustamento_informazioni_protocollo = false;
  2175.             }
  2176.             // check di incoerenza
  2177.             if( getMessageAbilitato==false && servizioApplicativoConConnettore==false ){
  2178.                 throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"consegnaNonDefinita");
  2179.             }
  2180.             if((state instanceof OpenSPCoopStateless) && (this.oneWayVersione11==false) && getMessageAbilitato && servizioApplicativoConConnettore
  2181.                     && (idBustaPreBehaviourNewMessage==null)){
  2182.                 throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"gestioneStateless.integrationManager");
  2183.             }
  2184.             if(!servizioApplicativoConConnettore){
  2185.                 // CONNETTORE non presente
  2186.                 // un connettore deve per forza essere presente se:
  2187.                 // - profilo sincrono
  2188.                 // - profilo asincrono e ricevuta applicativa abilitata
  2189.                 // - profilo asincrono asimmetrico richiesta e ricevuta applicativa abilitata
  2190.                 // - polling asincrono asimmetrico (richiesta-stato)
  2191.                 if(idBustaPreBehaviourNewMessage==null){
  2192.                     if(ProfiloDiCollaborazione.SINCRONO.equals(busta.getProfiloDiCollaborazione())){
  2193.                         throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"trasmissioneSincrona.servizioNonUtilizzabile");
  2194.                     }
  2195.                     else if(richiestaApplicativa.isRicevutaAsincrona() && 
  2196.                             (ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ||
  2197.                                     ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) ) ){       
  2198.                         throw new EJBUtilsConsegnaException(this.msgDiag,MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"gestioneProfiloAsincrono.servizioNonUtilizzabile");
  2199.                     }else if( Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(richiestaApplicativa.getScenario())  ){
  2200.                         throw new EJBUtilsConsegnaException("(Polling AsincronoAsimmetrico) "+this.msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"trasmissioneSincrona.servizioNonUtilizzabile"),
  2201.                                 this.msgDiag.getLivello(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"trasmissioneSincrona.servizioNonUtilizzabile"),
  2202.                                 this.msgDiag.getCodice(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"trasmissioneSincrona.servizioNonUtilizzabile"));
  2203.                     }
  2204.                 }
  2205.             }
  2206.             
  2207.             // Registrazione dati per la gestione del Messaggio
  2208.             String tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_INTEGRATION_MANAGER;
  2209.             if(servizioApplicativoConConnettore)
  2210.                 tipoConsegna = GestoreMessaggi.CONSEGNA_TRAMITE_CONNETTORE;

  2212.             
  2213.             // oraRegistrazione
  2214.                         
  2215.             Timestamp oraRegistrazioneMessaggio = null;
  2216.             if(dataRegistrazioneMessaggio!=null) {
  2217.                 oraRegistrazioneMessaggio = dataRegistrazioneMessaggio;
  2218.             }
  2219.             else {
  2220.                 oraRegistrazioneMessaggio = gestoreMessaggi.getOraRegistrazioneMessaggio();
  2221.             }

  2223.             
  2224.             // Registro Destinatario
  2225.             if(idBustaPreBehaviourNewMessage!=null){
  2226.                 // Forzo oneway1.1 per farlo registrare anche se siamo in stateless puro
  2227.                 gestoreMessaggi.setOneWayVersione11(true);
  2228.             }
  2229.             gestoreMessaggi.registraDestinatarioMessaggio(servizioApplicativo,
  2230.                     sbustamento_soap,sbustamento_informazioni_protocollo,
  2231.                     getMessageAbilitato,tipoConsegna,oraRegistrazioneMessaggio, nomePorta,
  2232.                     attendiEsitoTransazioneSincronaPrimaDiSpedire, (servizioApplicativoConConnettore && !spedizioneConsegnaContenuti),
  2233.                     coda, priorita, schedulingNonAttivo);
  2234.             
  2235.             mapServizioApplicativoConConnettore.put(servizioApplicativo, servizioApplicativoConConnettore);
  2236.             mapSbustamentoSoap.put(servizioApplicativo, sbustamento_soap);
  2237.             mapSbustamentoInformazioniProtocollo.put(servizioApplicativo, sbustamento_informazioni_protocollo);
  2238.             mapGetMessage.put(servizioApplicativo, getMessageAbilitato);
  2239.             mapTipoConsegna.put(servizioApplicativo, tipoConsegna);
  2240.             mapOraRegistrazione.put(servizioApplicativo, oraRegistrazioneMessaggio);
  2241.             mapConsegnaContenutiApplicativiMessage.put(servizioApplicativo, consegnaMSG);
  2242.             
  2243.             if(getMessageAbilitato && !servizioApplicativoConConnettore && !gestioneTramiteConnettoriMultipli) {
  2244.                 ConsegnaContenutiApplicativiBehaviourMessage behaviourMsg = new ConsegnaContenutiApplicativiBehaviourMessage();
  2245.                 //behaviourMsg.setIdMessaggioPreBehaviour(idBustaPreBehaviourNewMessage);
  2246.                 //behaviourMsg.setBehaviourForwardToConfiguration(behaviourForwardToConfiguration);
  2247.                 IdTransazioneApplicativoServer idTransazioneApplicativoServer = new IdTransazioneApplicativoServer();
  2248.                 idTransazioneApplicativoServer.setIdTransazione(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, this.pddContext));
  2249.                 idTransazioneApplicativoServer.setServizioApplicativoErogatore(servizioApplicativo);
  2250.                 idTransazioneApplicativoServer.setConnettoreNome(CostantiConfigurazione.NOME_CONNETTORE_DEFAULT);
  2251.                 behaviourMsg.setIdTransazioneApplicativoServer(idTransazioneApplicativoServer);
  2252.                 consegnaMSG.setBehaviour(behaviourMsg);     
  2253.                 // aggiorno pddContext per evitare che eventuali salvataggi influenzino la transazione
  2254.                 consegnaMSG.setPddContext(this.pddContext!=null ? (PdDContext) this.pddContext.clone() : null);
  2255.                 if(this.pddContext!=null) {
  2256.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.MESSAGE_BOX, "true");
  2257.                 }
  2258.             }
  2259.         }
  2260.         
  2261.         
  2262.         // Applico modifiche della registrazione
  2263.         boolean registrazioneDestinatarioEffettuataPerViaBehaviour = false;
  2264.         if(idBustaPreBehaviourNewMessage!=null){
  2265.             if (stateless && !this.propertiesReader.isServerJ2EE() ) {
  2266.                 state.commit();
  2267.                 if(releseaResource) {
  2268.                     state.releaseResource();
  2269.                 }
  2270.                 registrazioneDestinatarioEffettuataPerViaBehaviour = true;
  2271.             }
  2272.         }
  2273.         
  2274.         
  2275.         // Effettuo spedizione
  2276.         
  2277.         EJBUtilsMessaggioInConsegna messaggiInConsegna = new EJBUtilsMessaggioInConsegna();
  2278.             
  2279.         messaggiInConsegna.setServiziApplicativi(serviziApplicativi);
  2280.         messaggiInConsegna.setSoggettiRealiMappatiInUnSoggettoVirtuale(soggettiRealiMappatiInUnSoggettoVirtuale);
  2281.         messaggiInConsegna.setRichiestaApplicativa(richiestaApplicativa);
  2282.         
  2283.         messaggiInConsegna.setMapServizioApplicativoConConnettore(mapServizioApplicativoConConnettore);
  2284.         messaggiInConsegna.setMapSbustamentoSoap(mapSbustamentoSoap);
  2285.         messaggiInConsegna.setMapSbustamentoInformazioniProtocollo(mapSbustamentoInformazioniProtocollo);
  2286.         messaggiInConsegna.setMapGetMessage(mapGetMessage);
  2287.         messaggiInConsegna.setMapTipoConsegna(mapTipoConsegna);
  2288.         messaggiInConsegna.setMapOraRegistrazione(mapOraRegistrazione);
  2289.         messaggiInConsegna.setMapConsegnaContenutiApplicativiMessage(mapConsegnaContenutiApplicativiMessage);
  2290.         
  2291.         messaggiInConsegna.setRegistrazioneMessaggioPerStatelessEffettuata(registrazioneMessaggioPerStatelessEffettuata);
  2292.         messaggiInConsegna.setGestioneSolamenteConIntegrationManager(gestioneSolamenteConIntegrationManager);
  2293.         messaggiInConsegna.setRegistrazioneDestinatarioEffettuataPerViaBehaviour(registrazioneDestinatarioEffettuataPerViaBehaviour);
  2294.         messaggiInConsegna.setStateless(stateless);
  2295.         messaggiInConsegna.setOneWayVersione11(this.oneWayVersione11);
  2296.         
  2297.         messaggiInConsegna.setIdBustaPreBehaviourNewMessage(idBustaPreBehaviourNewMessage);
  2298.         messaggiInConsegna.setBusta(busta);
  2299.         messaggiInConsegna.setNomePorta(nomePorta);
  2300.         
  2301.         messaggiInConsegna.setRequestMessageNullable(requestMessageNullable);
  2302.         
  2303.         messaggiInConsegna.setOraRegistrazioneMessaggio(dataRegistrazioneMessaggio);
  2304.         
  2305.         if(attendiEsitoTransazioneSincronaPrimaDiSpedire) {
  2306.             this.pddContext.addObject(CostantiPdD.TIMER_RICONSEGNA_CONTENUTI_APPLICATIVI_MESSAGGI_SPEDIRE, messaggiInConsegna);
  2307.         }
  2308.         else {
  2309.             EJBUtilsMessaggioInConsegnaEsito esito = sendMessages(this.log, this.msgDiag, state, this.idSessione, 
  2310.                     repositoryBuste, gestoreMessaggi, this.nodeSender, 
  2311.                     this.protocolFactory, this.identitaPdD, nomePorta, messaggiInConsegna,
  2312.                     spedizioneConsegnaContenuti,
  2313.                     this.pddContext,
  2314.                     this.configurazionePdDReader);
  2315.         
  2316.             this.gestioneSolamenteConIntegrationManager = esito.isGestioneSolamenteConIntegrationManager();
  2317.             this.gestioneStatelessConIntegrationManager = esito.isGestioneStatelessConIntegrationManager();
  2318.         }
  2319.         
  2320.     }
  2321.     
  2322.     public static EJBUtilsMessaggioInConsegnaEsito sendMessages(Logger log, MsgDiagnostico msgDiag, IOpenSPCoopState state, String idSessioneParam,
  2323.             RepositoryBuste repositoryBuste, GestoreMessaggi gestoreMessaggi, INodeSender nodeSender, 
  2324.             IProtocolFactory<?> protocolFactory,IDSoggetto identitaPdD, String idModulo,
  2325.             EJBUtilsMessaggioInConsegna message,
  2326.             boolean spedizioneConsegnaContenuti,
  2327.             PdDContext pddContext,
  2328.             ConfigurazionePdDManager configurazionePdDManager) throws Exception {
  2329.         
  2330.         RequestInfo requestInfo = null;
  2331.         if(pddContext!=null && pddContext.containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  2332.             requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  2333.         }
  2334.         
  2335.         EJBUtilsMessaggioInConsegnaEsito esito = new EJBUtilsMessaggioInConsegnaEsito();
  2336.         
  2337.         OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  2338.         
  2339.         List<String> serviziApplicativi = message.getServiziApplicativi();
  2340.         SoggettoVirtuale soggettiRealiMappatiInUnSoggettoVirtuale = message.getSoggettiRealiMappatiInUnSoggettoVirtuale();
  2341.         RichiestaApplicativa richiestaApplicativa = message.getRichiestaApplicativa();
  2342.         
  2343.         Map<String, Boolean> mapServizioApplicativoConConnettore = message.getMapServizioApplicativoConConnettore();
  2344.         Map<String, Boolean> mapSbustamentoSoap = message.getMapSbustamentoSoap();
  2345.         Map<String, Boolean> mapSbustamentoInformazioniProtocollo = message.getMapSbustamentoInformazioniProtocollo();
  2346.         Map<String, Boolean> mapGetMessage = message.getMapGetMessage();
  2347.         Map<String, String> mapTipoConsegna = message.getMapTipoConsegna();
  2348.         Map<String, Timestamp> mapOraRegistrazione = message.getMapOraRegistrazione();
  2349.         Map<String, ConsegnaContenutiApplicativiMessage> mapConsegnaContenutiApplicativiMessage = message.getMapConsegnaContenutiApplicativiMessage();
  2350.         
  2351.         boolean registrazioneMessaggioPerStatelessEffettuata = message.isRegistrazioneMessaggioPerStatelessEffettuata();
  2352.         boolean gestioneSolamenteConIntegrationManager = message.isGestioneSolamenteConIntegrationManager();
  2353.         boolean registrazioneDestinatarioEffettuataPerViaBehaviour = message.isRegistrazioneDestinatarioEffettuataPerViaBehaviour();
  2354.         boolean stateless = message.isStateless();
  2355.         boolean oneWayVersione11 = message.isOneWayVersione11();
  2356.         
  2357.         String idBustaPreBehaviourNewMessage = message.getIdBustaPreBehaviourNewMessage();
  2358.         Busta busta = message.getBusta();
  2359.         String nomePorta = message.getNomePorta();
  2360.         
  2361.         OpenSPCoop2Message requestMessageNullable = message.getRequestMessageNullable();
  2362.         
  2363.         Date dataRegistrazioneMessaggio = message.getOraRegistrazioneMessaggio();
  2364.         
  2365.         // Fase di Consegna
  2366.         for (String servizioApplicativo : serviziApplicativi) {
  2367.             
  2368.             // effettuo correzioni dovute al Soggetto Virtuale
  2369.             if(soggettiRealiMappatiInUnSoggettoVirtuale!=null){
  2370.                 
  2371.                 String oldDominio = richiestaApplicativa.getIDServizio().getSoggettoErogatore().getCodicePorta();
  2372.                 overwriteIdSoggetto(richiestaApplicativa.getIDServizio(), soggettiRealiMappatiInUnSoggettoVirtuale.getSoggettoReale(servizioApplicativo));
  2373.                 richiestaApplicativa.getIDServizio().getSoggettoErogatore().setCodicePorta(oldDominio);
  2374.                 
  2375.                 richiestaApplicativa.setIdPortaApplicativa(soggettiRealiMappatiInUnSoggettoVirtuale.getIDPortaApplicativa(servizioApplicativo));
  2376.                 
  2377.                 servizioApplicativo = soggettiRealiMappatiInUnSoggettoVirtuale.getNomeServizioApplicativo(servizioApplicativo);
  2378.             }
  2379.             
  2380.             boolean servizioApplicativoConConnettore = mapServizioApplicativoConConnettore.get(servizioApplicativo);
  2381.             boolean sbustamento_soap = mapSbustamentoSoap.get(servizioApplicativo);
  2382.             boolean sbustamento_informazioni_protocollo = mapSbustamentoInformazioniProtocollo.get(servizioApplicativo);
  2383.             boolean getMessageAbilitato = mapGetMessage.get(servizioApplicativo);
  2384.             String tipoConsegna = mapTipoConsegna.get(servizioApplicativo);
  2385.             Timestamp oraRegistrazioneMessaggio = mapOraRegistrazione.get(servizioApplicativo);
  2386.             ConsegnaContenutiApplicativiMessage consegnaMSG = mapConsegnaContenutiApplicativiMessage.get(servizioApplicativo);
  2387.                     
  2388.             // Aggiungo costante servizio applicativo
  2389.             msgDiag.addKeyword(CostantiPdD.KEY_SA_EROGATORE, servizioApplicativo);
  2390.             
  2391.             // identificativo Porta Applicativa
  2392.             richiestaApplicativa.setServizioApplicativo(servizioApplicativo);
  2393.                         
  2394.             // Preparo TransazioneApplicativoServer transazioneApplicativoServer
  2395.             TransazioneApplicativoServer transazioneApplicativoServer = null;
  2396.             if(consegnaMSG.getBehaviour()!=null && consegnaMSG.getBehaviour().getIdTransazioneApplicativoServer()!=null) {
  2397.                 
  2398.                 transazioneApplicativoServer = new TransazioneApplicativoServer();
  2399.                 transazioneApplicativoServer.setIdTransazione(consegnaMSG.getBehaviour().getIdTransazioneApplicativoServer().getIdTransazione());
  2400.                 transazioneApplicativoServer.setServizioApplicativoErogatore(consegnaMSG.getBehaviour().getIdTransazioneApplicativoServer().getServizioApplicativoErogatore());
  2401.                 transazioneApplicativoServer.setConnettoreNome(consegnaMSG.getBehaviour().getIdTransazioneApplicativoServer().getConnettoreNome());
  2402.                 if(dataRegistrazioneMessaggio!=null) {
  2403.                     transazioneApplicativoServer.setDataRegistrazione(dataRegistrazioneMessaggio);
  2404.                 }
  2405.                 else {
  2406.                     transazioneApplicativoServer.setDataRegistrazione(DateManager.getDate());
  2407.                 }
  2408.                 transazioneApplicativoServer.setProtocollo(protocolFactory.getProtocol());
  2409.                 transazioneApplicativoServer.setDataAccettazioneRichiesta(DateManager.getDate());
  2410.                 if(requestMessageNullable!=null) {
  2411.                     transazioneApplicativoServer.setRichiestaUscitaBytes(requestMessageNullable.getOutgoingMessageContentLength());
  2412.                 }
  2413.                 transazioneApplicativoServer.setIdentificativoMessaggio(consegnaMSG.getBusta().getID());
  2414.                 transazioneApplicativoServer.setClusterIdPresaInCarico(propertiesReader.getClusterId(false));
  2415.                 transazioneApplicativoServer.setConsegnaTrasparente(servizioApplicativoConConnettore);
  2416.                 transazioneApplicativoServer.setConsegnaIntegrationManager(getMessageAbilitato);
  2417.             
  2418.                 if(transazioneApplicativoServer!=null) {
  2419.                     
  2420.                     try {
  2421.                         GestoreConsegnaMultipla.getInstance().safeCreate(transazioneApplicativoServer, richiestaApplicativa.getIdPortaApplicativa(), state, requestInfo, pddContext);
  2422.                     }catch(Throwable t) {
  2423.                         log.error("["+transazioneApplicativoServer.getIdTransazione()+"]["+transazioneApplicativoServer.getServizioApplicativoErogatore()+"] Errore durante il salvataggio delle informazioni relative al servizio applicativo: "+t.getMessage(),t);
  2424.                     }
  2425.                     
  2426.                 }
  2427.             }
  2428.             
  2429.             if(transazioneApplicativoServer==null) {
  2430.                 // altrimenti il diagnostico deve finire nella parte "presa in carico"
  2431.                 msgDiag.setServizioApplicativo(servizioApplicativo);
  2432.             }
  2433.             
  2434.             // Spedisco al modulo ConsegnaContenutiApplicativi, solo se e' presente una definizione di servizio-applicativo
  2435.             if(servizioApplicativoConConnettore){
  2436.                 
  2437.                 gestioneSolamenteConIntegrationManager = false;
  2438.                 
  2439.                 consegnaMSG.setRichiestaApplicativa(richiestaApplicativa);

  2441.                 if(spedizioneConsegnaContenuti) {
  2442.                     if (!stateless || 
  2443.                             (propertiesReader.isServerJ2EE() && idBustaPreBehaviourNewMessage!=null) 
  2444.                         ) {
  2445.                         if ( oneWayVersione11 ) {
  2446.                             OpenSPCoopStateless statelessSerializzabile = ((OpenSPCoopStateless) state).rendiSerializzabile();
  2447.                             consegnaMSG.setOpenspcoopstate(statelessSerializzabile);
  2448.                         }
  2449.                 
  2450.                         try{
  2451.                             String idSessione = idSessioneParam;
  2452.                             if(idBustaPreBehaviourNewMessage!=null){
  2453.                                 idSessione = busta.getID();
  2454.                             }
  2455.                             nodeSender.send(consegnaMSG, org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi.ID_MODULO, msgDiag, 
  2456.                                     identitaPdD, idModulo, idSessione, gestoreMessaggi);
  2457.                         } catch (Exception e) { 
  2458.                             msgDiag.logErroreGenerico(e, "EJBUtils.sendToConsegnaContenutiApplicativi(RichiestaApplicativa).senderJMS");
  2459.                             throw e;
  2460.                         }
  2461.                     }
  2462.     
  2463.                     else {
  2464.                         ((OpenSPCoopStateless)state).setMessageLib(consegnaMSG);
  2465.                         ((OpenSPCoopStateless)state).setDestinatarioRequestMsgLib(ConsegnaContenutiApplicativi.ID_MODULO);
  2466.                                 
  2467.                         if(idBustaPreBehaviourNewMessage!=null){                        
  2468.                             ConsegnaContenutiApplicativi lib = new ConsegnaContenutiApplicativi(log);
  2469.                             EsitoLib result = lib.onMessage(state, configurazionePdDManager);
  2470.                             log.debug("Invocato ConsegnaContenutiApplicativi per ["+busta.getID()+"] con esito: "+result.getStatoInvocazione(),result.getErroreNonGestito());
  2471.                         }
  2472.                     }
  2473.                 }
  2474.                 else {
  2475.                     
  2476.                     if(transazioneApplicativoServer!=null) {
  2477.                         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"queue.messaggioSchedulato");
  2478.                     }
  2479.                     
  2480.                 }
  2481.                 
  2482.             }else{
  2483.                 
  2484.                 if( !registrazioneDestinatarioEffettuataPerViaBehaviour && (state instanceof OpenSPCoopStateless) && (oneWayVersione11==false) ){
  2485.                     esito.setGestioneStatelessConIntegrationManager(true);
  2486.                     if(idBustaPreBehaviourNewMessage==null && registrazioneMessaggioPerStatelessEffettuata==false){
  2487.                         //  Memorizzazione Stateless
  2488.                         _forceSaveMessage(propertiesReader, gestoreMessaggi, gestoreMessaggi.getOraRegistrazioneMessaggio(), busta, richiestaApplicativa, repositoryBuste,
  2489.                                 ((OpenSPCoopStateless)state).getRichiestaMsg(),state,
  2490.                                 pddContext, identitaPdD);
  2491.                         registrazioneMessaggioPerStatelessEffettuata=true;
  2492.                     }
  2493.                     // Forzo oneway1.1 per farlo registrare anche se siamo in stateless puro
  2494.                     gestoreMessaggi.setOneWayVersione11(true);
  2495.                     gestoreMessaggi.registraDestinatarioMessaggio(servizioApplicativo,
  2496.                             sbustamento_soap,sbustamento_informazioni_protocollo,
  2497.                             getMessageAbilitato,tipoConsegna,oraRegistrazioneMessaggio,
  2498.                             nomePorta, false, false,
  2499.                             null, null, false);
  2500.                     gestoreMessaggi.setOneWayVersione11(false);
  2501.                 }

  2503.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_CONSEGNA_CONTENUTI_APPLICATIVI,"integrationManager.messaggioDisponibile");
  2504.                 
  2505.             }
  2506.         }
  2507.         
  2508.         esito.setGestioneSolamenteConIntegrationManager(gestioneSolamenteConIntegrationManager);
  2509.         
  2510.         return esito;

  2512.     }


  2515.     private static java.sql.Timestamp _forceSaveMessage(OpenSPCoop2Properties propertiesReader, GestoreMessaggi gestoreMessaggi, Timestamp oraRegistrazione,
  2516.             Busta busta,RichiestaApplicativa richiestaApplicativa,RepositoryBuste repositoryBuste,
  2517.             OpenSPCoop2Message message,IOpenSPCoopState state,
  2518.             PdDContext pddContext, IDSoggetto identitaPdD) throws Exception{
  2519.         
  2520.         if( state.resourceReleased()) {
  2521.             ((OpenSPCoopState)state).setUseConnection(true);
  2522.             String idTransazione = (String) pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  2523.             ((OpenSPCoopState)state).initResource(identitaPdD, "EJBUtils.saveMessage", idTransazione);
  2524.             gestoreMessaggi.updateOpenSPCoopState(state);
  2525.             repositoryBuste.updateState(state.getStatoRichiesta());
  2526.         }
  2527.         
  2528.         java.sql.Timestamp oraRegistrazioneT = gestoreMessaggi.registraInformazioniMessaggio_statelessEngine(oraRegistrazione, 
  2529.                 ConsegnaContenutiApplicativi.ID_MODULO,busta.getRiferimentoMessaggio(),
  2530.                 richiestaApplicativa.getIdCorrelazioneApplicativa(),null);
  2531.         boolean consumeMessage= true;
  2532.         gestoreMessaggi.registraMessaggio_statelessEngine(message, !consumeMessage, oraRegistrazioneT); // senno il dump poi successivo non funziona
  2533.         String key = "INSERT RegistrazioneBustaForHistory"+Costanti.INBOX+"_"+busta.getID();
  2534.         if(repositoryBuste.isRegistrataIntoInBox(busta.getID())){
  2535.             repositoryBuste.aggiornaBustaIntoInBox(busta,propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),true);
  2536.             repositoryBuste.impostaUtilizzoPdD(busta.getID(), Costanti.INBOX);
  2537.         }
  2538.         else if(((StateMessage)state.getStatoRichiesta()).getPreparedStatement().containsKey(key)){
  2539.             repositoryBuste.aggiornaBustaIntoInBox(busta,propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),true);
  2540.             repositoryBuste.impostaUtilizzoPdD(busta.getID(), Costanti.INBOX);
  2541.         }else{
  2542.             repositoryBuste.registraBustaIntoInBox(busta,propertiesReader.getRepositoryIntervalloScadenzaMessaggi(), true);
  2543.             if(!(state instanceof OpenSPCoopStateful)){
  2544.                 if(busta.sizeProperties()>0){
  2545.                     Map<String, String> bustaProperties = new HashMap<>();
  2546.                     String[]propertyNames = busta.getPropertiesNames();
  2547.                     if(propertyNames!=null){
  2548.                         for (int i = 0; i < propertyNames.length; i++) {
  2549.                             String keyP = propertyNames[i];
  2550.                             String valueP = busta.getProperty(key);
  2551.                             if(keyP!=null && valueP!=null){
  2552.                                 bustaProperties.put(keyP, valueP);
  2553.                             }
  2554.                         }
  2555.                     }
  2556.                     repositoryBuste.aggiornaProprietaBustaIntoInBox(bustaProperties, busta.getID());
  2557.                 }
  2558.             }
  2559.         }
  2560.         return oraRegistrazioneT;
  2561.     }














  2576.     /** ------------------- Metodi per la spedizione di risposte con errori ---------------- */

  2578.     /* ---- PROCESSAMENTO --- */
  2579.     
  2580.     public void sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2581.             ErroreIntegrazione errore,String idCorrelazioneApplicativa,
  2582.             String servizioApplicativoFruitore,
  2583.             Throwable eProcessamento, ParseException parseException)throws EJBUtilsException,ProtocolException{ 
  2584.         Eccezione ecc = new Eccezione(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento(errore.getDescrizione(this.protocolFactory)),
  2585.                 false,this.idModulo,this.protocolFactory);
  2586.         List<Eccezione> errs = new ArrayList<>();
  2587.         errs.add(ecc);
  2588.         this._sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,busta,errs,errore,idCorrelazioneApplicativa,null,servizioApplicativoFruitore,eProcessamento,parseException,null);
  2589.     }
  2590.     public void sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2591.             ErroreIntegrazione errore,
  2592.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  2593.             String servizioApplicativoFruitore,
  2594.             Throwable eProcessamento, ParseException parseException)throws EJBUtilsException,ProtocolException{ 
  2595.         Eccezione ecc = new Eccezione(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento(errore.getDescrizione(this.protocolFactory)),false,this.idModulo,this.protocolFactory);
  2596.         List<Eccezione> errs = new ArrayList<>();
  2597.         errs.add(ecc);
  2598.         this._sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,busta,errs,errore,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,eProcessamento,parseException,null);
  2599.     }
  2600.     public void sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2601.             List<Eccezione> errs,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  2602.             String servizioApplicativoFruitore,
  2603.             Throwable eProcessamento, ParseException parseException)throws EJBUtilsException,ProtocolException{ 
  2604.         this._sendAsRispostaBustaErroreProcessamento(idModuloInAttesa, busta, errs, null, 
  2605.                 idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, eProcessamento, parseException, null);
  2606.     }
  2607.     
  2608.     public void sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2609.             String idCorrelazioneApplicativa,
  2610.             String servizioApplicativoFruitore,
  2611.             OpenSPCoop2Message errorMessageParam, String errorDetail)throws EJBUtilsException,ProtocolException{ 
  2612.         Eccezione ecc = new Eccezione(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento(errorDetail),
  2613.                 false,this.idModulo,this.protocolFactory);
  2614.         List<Eccezione> errs = new ArrayList<>();
  2615.         errs.add(ecc);
  2616.         this._sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,busta,errs,null,idCorrelazioneApplicativa,null,servizioApplicativoFruitore,null,null,errorMessageParam);
  2617.     }
  2618.     public void sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2619.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  2620.             String servizioApplicativoFruitore,
  2621.             OpenSPCoop2Message errorMessageParam, String errorDetail)throws EJBUtilsException,ProtocolException{ 
  2622.         Eccezione ecc = new Eccezione(ErroriCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreProcessamento(errorDetail),false,this.idModulo,this.protocolFactory);
  2623.         List<Eccezione> errs = new ArrayList<>();
  2624.         errs.add(ecc);
  2625.         this._sendAsRispostaBustaErroreProcessamento(idModuloInAttesa,busta,errs,null,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,null,null,errorMessageParam);
  2626.     }
  2627.     public void sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2628.             List<Eccezione> errs,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  2629.             String servizioApplicativoFruitore,
  2630.             OpenSPCoop2Message errorMessageParam)throws EJBUtilsException,ProtocolException{ 
  2631.         this._sendAsRispostaBustaErroreProcessamento(idModuloInAttesa, busta, errs, null, 
  2632.                 idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore, null,null,errorMessageParam);
  2633.     }
  2634.     
  2635.     private void _sendAsRispostaBustaErroreProcessamento(String idModuloInAttesa,Busta busta,
  2636.             List<Eccezione> errs, ErroreIntegrazione errore, 
  2637.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  2638.             String servizioApplicativoFruitore,
  2639.             Throwable eProcessamento, ParseException parseException,
  2640.             OpenSPCoop2Message errorMessageParam)throws EJBUtilsException,ProtocolException{ 

  2642.         if(this.pddContext==null) {
  2643.             throw new EJBUtilsException("PddContext undefined");
  2644.         }
  2645.         
  2646.         String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);

  2648.         //Costruisco busta Errore 
  2649.         Imbustamento imbustatore = new Imbustamento(this.log,this.protocolFactory,this.openSPCoopState.getStatoRichiesta());

  2651.         String id_bustaErrore = 
  2652.             imbustatore.buildID(this.identitaPdD, idTransazione, 
  2653.                     this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  2654.                     this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  2655.                     RuoloMessaggio.RISPOSTA);

  2657.         //ErroreProcessamentoProtocollo: Header
  2658.         busta = this.generatoreErrorePortaApplicativa.getImbustamentoErrore().buildMessaggioErroreProtocollo_Processamento(errs,busta,id_bustaErrore,this.propertiesReader.getTipoTempoBusta(this.implementazionePdDSoggettoMittente));

  2660.         // Fix Bug 131: eccezione di processamento
  2661.         this.generatoreErrorePortaApplicativa.getImbustamentoErrore().gestioneListaEccezioniMessaggioErroreProtocolloProcessamento(busta);
  2662.         // Fix Bug 131
  2663.         
  2664.         if( !( this.identitaPdD.getNome().equals(busta.getMittente()) && 
  2665.                 this.identitaPdD.getTipo().equals(busta.getTipoMittente()) ) ){
  2666.             // Il mittente della busta che sara' spedita e' il router
  2667.             busta.setMittente(this.identitaPdD.getNome());
  2668.             busta.setTipoMittente(this.identitaPdD.getTipo());
  2669.             busta.setIdentificativoPortaMittente(this.identitaPdD.getCodicePorta());
  2670.             busta.setIndirizzoMittente(null);
  2671.         }

  2673.         //ErroreProcessamentoProtocollo: error Msg
  2674.         OpenSPCoop2Message errorMsg = null;
  2675.         if(errorMessageParam!=null) {
  2676.             errorMsg = errorMessageParam;
  2677.         }
  2678.         else {
  2679.             if(errore==null) {
  2680.                 DettaglioEccezione dettaglioEccezione = this.dettaglioBuilder.buildDettaglioEccezioneFromBusta(this.identitaPdD,this.tipoPdD,this.idModulo, 
  2681.                         this.servizioApplicativoErogatore, busta, eProcessamento);
  2682.                 errorMsg = this.generatoreErrorePortaApplicativa.buildErroreProcessamento(this.pddContext, this.getIntegrationFunctionErrorPortaApplicativa(false), dettaglioEccezione);
  2683.             }
  2684.             else {
  2685.                 errorMsg = this.generatoreErrorePortaApplicativa.buildErroreProcessamento(this.pddContext, this.getIntegrationFunctionErrorPortaApplicativa(false), errore, eProcessamento);
  2686.             }           
  2687.             if(errorMsg == null){
  2688.                 throw new EJBUtilsException("EJBUtils.sendRispostaErroreProcessamentoProtocollo error: Costruzione Msg Errore Protocollo fallita.");
  2689.             }
  2690.         }
  2691.         IntegrationFunctionError integrationFunctionErrorPortaApplicativa = getIntegrationFunctionErrorPortaApplicativa(false);
  2692.         if(integrationFunctionErrorPortaApplicativa!=null && 
  2693.                 (
  2694.                         IntegrationFunctionError.SERVICE_UNAVAILABLE.equals(integrationFunctionErrorPortaApplicativa)
  2695.                         ||
  2696.                         IntegrationFunctionError.ENDPOINT_REQUEST_TIMED_OUT.equals(integrationFunctionErrorPortaApplicativa)
  2697.                 )
  2698.             ) {
  2699.             // Retry-After
  2700.             boolean isEnabled = this.propertiesReader.isEnabledServiceUnavailableRetryAfterPAConnectionFailed();
  2701.             Integer retryAfterSeconds = this.propertiesReader.getServiceUnavailableRetryAfterSecondsPAConnectionFailed();
  2702.             Integer retryAfterBackOffSeconds = this.propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPAConnectionFailed();
  2703.             if( isEnabled &&
  2704.                 retryAfterSeconds!=null && retryAfterSeconds>0) {
  2705.                 int seconds = retryAfterSeconds;
  2706.                 if(retryAfterBackOffSeconds!=null && retryAfterBackOffSeconds>0) {
  2707.                     seconds = seconds + ServicesUtils.getRandom().nextInt(retryAfterBackOffSeconds);
  2708.                 }
  2709.                 errorMsg.forceTransportHeader(HttpConstants.RETRY_AFTER, seconds+"");
  2710.             }
  2711.         }
  2712.         if(eProcessamento!=null && eProcessamento instanceof HandlerException){
  2713.             HandlerException he = (HandlerException) eProcessamento;
  2714.             he.customized(errorMsg);
  2715.         }
  2716.         if(parseException!=null){
  2717.             errorMsg.setParseException(parseException);
  2718.             if(this.pddContext!=null) {
  2719.                 if(MessageRole.REQUEST.equals(parseException.getMessageRole())){
  2720.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  2721.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  2722.                     errorMsg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  2723.                     errorMsg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  2724.                 }
  2725.                 else if(MessageRole.RESPONSE.equals(parseException.getMessageRole())){
  2726.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  2727.                     this.pddContext.addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  2728.                     errorMsg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  2729.                     errorMsg.addContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, parseException);
  2730.                 }
  2731.             }
  2732.         }
  2733.         sendAsRispostaBustaErrore(idModuloInAttesa,busta,errorMsg,false,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);
  2734.     }

  2736.     
  2737.     /* ---- VALIDAZIONE --- */

  2739.     public void sendAsRispostaBustaErroreValidazione(String idModuloInAttesa,Busta busta,Eccezione eccezione,
  2740.             String idCorrelazioneApplicativa,String servizioApplicativoFruitore)throws EJBUtilsException,ProtocolException{ 
  2741.         List<Eccezione> v = new ArrayList<>();
  2742.         v.add(eccezione);
  2743.         this._sendAsRispostaBustaErroreValidazione(idModuloInAttesa,busta,v,idCorrelazioneApplicativa,null,servizioApplicativoFruitore);
  2744.     }
  2745.     public void sendAsRispostaBustaErroreValidazione(String idModuloInAttesa,Busta busta,Eccezione eccezione,
  2746.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException,ProtocolException{ 
  2747.         List<Eccezione> v = new ArrayList<>();
  2748.         v.add(eccezione);
  2749.         this._sendAsRispostaBustaErroreValidazione(idModuloInAttesa,busta,v,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);
  2750.     }
  2751.     public void sendAsRispostaBustaErroreValidazione(String idModuloInAttesa,Busta busta,List<Eccezione> eccezioni,
  2752.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException,ProtocolException{ 
  2753.         this._sendAsRispostaBustaErroreValidazione(idModuloInAttesa, busta, eccezioni,  
  2754.                 idCorrelazioneApplicativa, idCorrelazioneApplicativaRisposta, servizioApplicativoFruitore);
  2755.     }
  2756.     private void _sendAsRispostaBustaErroreValidazione(String idModuloInAttesa,Busta busta,
  2757.             List<Eccezione> eccezioni,
  2758.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException,ProtocolException{ 

  2760.         //Costruisco busta Errore 
  2761.         Imbustamento imbustatore = new Imbustamento(this.log,this.protocolFactory,this.openSPCoopState.getStatoRichiesta());
  2762.         String id_bustaErrore = 
  2763.             imbustatore.buildID(this.identitaPdD, 
  2764.                     (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE), 
  2765.                     this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  2766.                     this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  2767.                     RuoloMessaggio.RISPOSTA);

  2769.         // CodiceErrore (da fare prima di imbustamentoErrore che svuola la lista eccezioni)
  2770.         CodiceErroreCooperazione codiceErroreCooperazione = null;
  2771.         String descrizioneErroreCooperazione = null;
  2772.         if(eccezioni!=null && eccezioni.size()>0) {
  2773.             Eccezione eccezioneDaInviare = Eccezione.getEccezioneValidazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), this.protocolFactory);
  2774.             if(eccezioni.size()>1){
  2775.                 ITraduttore traduttore = this.protocolFactory.createTraduttore();
  2776.                 StringBuilder bfDescrizione = new StringBuilder();
  2777.                 for(int k=0; k<eccezioni.size();k++){
  2778.                     Eccezione error = eccezioni.get(k);
  2779.                     if(error.getDescrizione(this.protocolFactory)!=null) {
  2780.                         bfDescrizione.append("["+traduttore.toString(error.getCodiceEccezione(),error.getSubCodiceEccezione())+"] "+error.getDescrizione(this.protocolFactory)+"\n");
  2781.                     }
  2782.                 }
  2783.                 if(bfDescrizione.length()>0)
  2784.                     eccezioneDaInviare.setDescrizione(bfDescrizione.toString());
  2785.             }else{
  2786.                 eccezioneDaInviare = eccezioni.get(0);
  2787.             }
  2788.             codiceErroreCooperazione = eccezioneDaInviare.getCodiceEccezione();
  2789.             descrizioneErroreCooperazione = eccezioneDaInviare.getDescrizione(this.protocolFactory);
  2790.         }
  2791.         
  2792.         //ErroreValidazioneProtocollo: Header
  2793.         busta = this.generatoreErrorePortaApplicativa.getImbustamentoErrore().
  2794.                 buildMessaggioErroreProtocollo_Validazione(eccezioni,busta,id_bustaErrore,this.propertiesReader.getTipoTempoBusta(this.implementazionePdDSoggettoMittente));    
  2795.         if( !( this.identitaPdD.getNome().equals(busta.getMittente()) && 
  2796.                 this.identitaPdD.getTipo().equals(busta.getTipoMittente()) ) ){
  2797.             // Il mittente della busta che sara' spedita e' il router
  2798.             busta.setMittente(this.identitaPdD.getNome());
  2799.             busta.setTipoMittente(this.identitaPdD.getTipo());
  2800.             busta.setIdentificativoPortaMittente(this.identitaPdD.getCodicePorta());
  2801.             busta.setIndirizzoMittente(null);
  2802.         }

  2804.         //ErroreValidazioneProtocollo: Msg
  2805.         OpenSPCoop2Message msg = null;
  2806.         if(codiceErroreCooperazione!=null && descrizioneErroreCooperazione!=null) {
  2807.             msg = this.generatoreErrorePortaApplicativa.buildErroreIntestazione(this.pddContext, this.getIntegrationFunctionErrorPortaApplicativa(true), codiceErroreCooperazione, descrizioneErroreCooperazione);
  2808.         }
  2809.         else {
  2810.             msg = this.generatoreErrorePortaApplicativa.buildErroreIntestazione(this.pddContext, this.getIntegrationFunctionErrorPortaApplicativa(true));
  2811.         }
  2812.         if(msg == null){
  2813.             throw new EJBUtilsException("EJBUtils.sendRispostaErroreValidazioneProtocollo error: Costruzione messaggio Errore Protocollo fallita.");
  2814.         }

  2816.         sendAsRispostaBustaErrore(idModuloInAttesa,busta,msg,false,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);
  2817.     }

  2819.     /**
  2820.      * Spedisce una busta che segnala la ricezione di una busta malformata al mittente della busta
  2821.      *
  2822.      * @param busta Busta
  2823.      * @param eccezioni Eccezioni di validazione 
  2824.      * 
  2825.      */
  2826.     public void sendAsRispostaBustaErrore_inoltroSegnalazioneErrore(Busta busta,List<Eccezione> eccezioni)throws EJBUtilsException,ProtocolException{ 
  2827.         
  2828.         //String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  2829.         // Fix devo utilizzare un id di transazione differente
  2830.         String idTransazione = null;
  2831.         try {
  2832.             idTransazione = UniqueIdentifierManager.newUniqueIdentifier().getAsString();
  2833.         }catch(Exception e) {
  2834.             throw new EJBUtilsException(e.getMessage(),e);
  2835.         }

  2837.         //Costruisco busta Errore 
  2838.         Imbustamento imbustatore = new Imbustamento(this.log, this.protocolFactory,this.openSPCoopState.getStatoRichiesta());
  2839.         String id_bustaErrore = 
  2840.             imbustatore.buildID(this.identitaPdD, idTransazione, 
  2841.                     this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  2842.                     this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  2843.                     RuoloMessaggio.RISPOSTA);

  2845.         // CodiceErrore (da fare prima di imbustamentoErrore che svuola la lista eccezioni)
  2846.         CodiceErroreCooperazione codiceErroreCooperazione = null;
  2847.         String descrizioneErroreCooperazione = null;
  2848.         if(eccezioni!=null && eccezioni.size()>0) {
  2849.             Eccezione eccezioneDaInviare = Eccezione.getEccezioneValidazione(ErroriCooperazione.ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.getErroreCooperazione(), this.protocolFactory);
  2850.             if(eccezioni.size()>1){
  2851.                 ITraduttore traduttore = this.protocolFactory.createTraduttore();
  2852.                 StringBuilder bfDescrizione = new StringBuilder();
  2853.                 for(int k=0; k<eccezioni.size();k++){
  2854.                     Eccezione error = eccezioni.get(k);
  2855.                     if(error.getDescrizione(this.protocolFactory)!=null) {
  2856.                         bfDescrizione.append("["+traduttore.toString(error.getCodiceEccezione(),error.getSubCodiceEccezione())+"] "+error.getDescrizione(this.protocolFactory)+"\n");
  2857.                     }
  2858.                 }
  2859.                 if(bfDescrizione.length()>0)
  2860.                     eccezioneDaInviare.setDescrizione(bfDescrizione.toString());
  2861.             }else{
  2862.                 eccezioneDaInviare = eccezioni.get(0);
  2863.             }
  2864.             codiceErroreCooperazione = eccezioneDaInviare.getCodiceEccezione();
  2865.             descrizioneErroreCooperazione = eccezioneDaInviare.getDescrizione(this.protocolFactory);
  2866.         }
  2867.         
  2868.         //ErroreValidazioneProtocollo: Header
  2869.         // L'inoltro di segnalazione avviene in SbustamentoRisposte quindi devo riferire l'implemenazione della PdD del Soggetto Destinatario
  2870.         busta = this.generatoreErrorePortaApplicativa.getImbustamentoErrore().
  2871.                 buildMessaggioErroreProtocollo_Validazione(eccezioni,busta,id_bustaErrore,this.propertiesReader.getTipoTempoBusta(this.implementazionePdDSoggettoDestinatario));    

  2873.         //ErroreValidazioneProtocollo: Msg
  2874.         OpenSPCoop2Message msg = null;
  2875.         if(codiceErroreCooperazione!=null && descrizioneErroreCooperazione!=null) {
  2876.             msg = this.generatoreErrorePortaApplicativa.buildErroreIntestazione(this.pddContext, this.getIntegrationFunctionErrorPortaApplicativa(false), codiceErroreCooperazione, descrizioneErroreCooperazione);
  2877.         }
  2878.         else {
  2879.             msg = this.generatoreErrorePortaApplicativa.buildErroreIntestazione(this.pddContext, this.getIntegrationFunctionErrorPortaApplicativa(false));
  2880.         }
  2881.         if(msg == null){
  2882.             throw new EJBUtilsException("EJBUtils.sendRispostaErroreProtocollo_BustaRispostaMalformata error: Costruzione Msg Errore Protocollo fallita.");
  2883.         }

  2885.         sendAsRispostaBustaErrore(null,busta,msg,true,null,null,null);
  2886.     }

  2888.     /**
  2889.      * Spedisce una busta di Risposta al modulo di OpenSPCoop piu' indicato, a seconda che
  2890.      * la busta debba essere spedita sulla reply della connessione HTTP 
  2891.      * (nodo RicezioneBuste, la spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null)
  2892.      * o su di una nuova connessione (nodo InoltroRisposte)
  2893.      * La spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null.
  2894.      *
  2895.      * @param idModuloInAttesa identificativo del modulo 'RicezioneBusteXXX'. 
  2896.      * @param busta Busta 
  2897.      * @param msg Msg Applicativo (SOAP) da inserire nella busta di risposta.
  2898.      * @param segnalazioneBustaRispostaMalformata Indicazione se la busta inviata segnala la precedente ricezione di una busta
  2899.      *        di risposta malformata (in tal caso la richiesta non viene eliminata, non esistentone una)
  2900.      * 
  2901.      */
  2902.     private void sendAsRispostaBustaErrore(String idModuloInAttesa,Busta busta,OpenSPCoop2Message msg,
  2903.             boolean segnalazioneBustaRispostaMalformata,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException{ 

  2905.         StateMessage statoRichiesta = (StateMessage) this.openSPCoopState.getStatoRichiesta();
  2906.         StateMessage statoRisposta = (StateMessage) this.openSPCoopState.getStatoRisposta();        


  2909.         RollbackRepositoryBuste rollbackBuste = null;
  2910.         RepositoryBuste repositoryBuste = null;
  2911.         GestoreMessaggi msgRequest = null;
  2912.         GestoreMessaggi msgResponse = null;
  2913.         this.setEJBSuffixFunctionName();
  2914.         try{
  2915.             
  2916.                         
  2917.             
  2918.             /* ------- Gestione MsgRichiesta --------------- */
  2919.             boolean addIntoCache = false;
  2920.             if(this.rollbackRichiestaInCasoErrore){
  2921.                 // RollbackApplicativo
  2922.                 // (uso l'ID della sessione, poiche' tutti i dati 'protocollo' sono salvati con l'ID della richiesta e non della risposta)
  2923.                 rollbackBuste = new RollbackRepositoryBuste(this.idSessione, statoRichiesta, this.oneWayVersione11);
  2924.                 if(this.routing){
  2925.                     rollbackBuste.rollbackBustaIntoOutBox(this.rollbackRichiestaInCasoErrore_rollbackHistory);
  2926.                 }else{
  2927.                     rollbackBuste.rollbackBustaIntoInBox(this.rollbackRichiestaInCasoErrore_rollbackHistory);
  2928.                 }
  2929.         
  2930.                 // Imposto ProprietarioMessaggioRichiesta per eliminazione, se il messaggio da spedire esiste.
  2931.                 if( (segnalazioneBustaRispostaMalformata==false) && (this.idMessage!=null)){
  2932.                     msgRequest = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  2933.                     msgRequest.setOneWayVersione11(this.oneWayVersione11);
  2934.                     if(msgRequest.existsMessage_noCache()){
  2935.                         msgRequest.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  2936.                         addIntoCache = true;
  2937.                     }else{
  2938.                         addIntoCache = false;
  2939.                     }
  2940.                 }
  2941.             }else{
  2942.                 msgRequest = new GestoreMessaggi(this.openSPCoopState, true, this.idMessage,this.tipo,this.msgDiag,this.pddContext);
  2943.                 addIntoCache = false;
  2944.             }
  2945.             


  2948.             /* ------- Gestione MsgRisposta --------------- */

  2950.             // Esamina tipo di risposta (indirizzo di spedizione)
  2951.             boolean httpReply = true;
  2952.             if( this.replyOnNewConnection )
  2953.                 httpReply = false;
  2954.             if( busta.getIndirizzoDestinatario()!=null &&
  2955.                     this.utilizzoIndirizzoTelematico)
  2956.                 httpReply = false;
  2957.             if( segnalazioneBustaRispostaMalformata )
  2958.                 httpReply = false;

  2960.             // Devo generare una risposta solo se devo inviarla verso una nuova connessione,
  2961.             // o se esiste un nodo a cui inviare la risposta (idModuloInAttesa)
  2962.             if( (httpReply==false) || (idModuloInAttesa != null) ){

  2964.                 boolean salvaSuDatabasePerStateless = false;
  2965.                 if(httpReply==false){
  2966.                     salvaSuDatabasePerStateless = true; // Il messaggio inviato su una nuova connessione è come fosse una richiesta
  2967.                 }
  2968.                 
  2969.                 // Salvataggio busta da inviare
  2970.                 repositoryBuste = new RepositoryBuste(statoRisposta, salvaSuDatabasePerStateless, this.protocolFactory);
  2971.                 repositoryBuste.registraBustaIntoOutBox(busta, this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi()); 
  2972.                 Integrazione infoIntegrazione = new Integrazione();
  2973.                 infoIntegrazione.setIdModuloInAttesa(idModuloInAttesa);
  2974.                 infoIntegrazione.setScenario(this.scenarioCooperazione);
  2975.                 repositoryBuste.aggiornaInfoIntegrazioneIntoOutBox(busta.getID(),infoIntegrazione);


  2978.                 // --- Genero una risposta 
  2979.                 msgResponse = new GestoreMessaggi(this.openSPCoopState, salvaSuDatabasePerStateless ,busta.getID(),Costanti.OUTBOX,this.msgDiag,this.pddContext);
  2980.                 if(httpReply==false){
  2981.                     msgResponse.setOneWayVersione11(this.oneWayVersione11);
  2982.                 }
  2983.                 // --- creazione nuovo stato
  2984.                 if(this.openSPCoopState instanceof OpenSPCoopStateless){
  2985.                     msgResponse.registraMessaggio(msg,((OpenSPCoopStateless)this.openSPCoopState).getTempiAttraversamentoPDD().getRicezioneMsgIngresso(),idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta);
  2986.                 }else{
  2987.                     msgResponse.registraMessaggio(msg,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta);
  2988.                 }
  2989.                 // ---- aggiorno riferimentoMessaggio
  2990.                 msgResponse.aggiornaRiferimentoMessaggio(this.idSessione);
  2991.                 
  2992.                 // --- Aggiornamento Proprietario messaggio: aggiorna il destinatario del messageLib se siamo in stateless mode
  2993.                 if(httpReply==false){
  2994.                     // Aggiorno proprietario Messaggio: INOLTRO RISPOSTE    
  2995.                     msgResponse.aggiornaProprietarioMessaggio(InoltroRisposte.ID_MODULO);  

  2997.                 }else{
  2998.                     if(idModuloInAttesa != null){          
  2999.                         // Aggiorno proprietario Messaggio: RICEZIONE BUSTE 
  3000.                         msgResponse.aggiornaProprietarioMessaggio(idModuloInAttesa);
  3001.                     }
  3002.                 }

  3004.                 // --- Spedizione al successivo modulo
  3005.                 try{
  3006.                     if(httpReply==false){
  3007.                         // spedizione al modulo InoltroRisposte
  3008.                         sendToInoltroRisposte(busta,segnalazioneBustaRispostaMalformata,null, msgResponse,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,true);        
  3009.                     }else{
  3010.                         if(idModuloInAttesa != null){
  3011.                             // spedizione al modulo RicezioneBusteXXX
  3012.                             sendBustaToRicezioneBuste(idModuloInAttesa,busta,null);
  3013.                         }
  3014.                     }
  3015.                 }catch(Exception e){
  3016.                     throw e; // rilancio eccezione;
  3017.                 }

  3019.             }// end Gestione Risposta


  3022.             /* ------- Commit/Close Connessione DB --------------- */
  3023.             this.openSPCoopState.commit();


  3026.             // Aggiornamento cache messaggio
  3027.             if(msgResponse !=null)
  3028.                 msgResponse.addMessaggiIntoCache_readFromTable(this.idModulo, "sendRispostaErroreProtocollo [risposta]");

  3030.             //  Aggiornamento cache proprietario messaggio
  3031.             if(addIntoCache){
  3032.                 String idRichiestaCorrelata = null;
  3033.                 if(this.idMessage.equals(this.idSessione)==false)
  3034.                     idRichiestaCorrelata = this.idSessione;
  3035.                 msgRequest.addProprietariIntoCache_readFromTable(this.idModulo, "sendRispostaErroreProtocollo [richiesta]",idRichiestaCorrelata,this.functionAsRouter);

  3037.             }
  3038.             if(msgResponse!=null)
  3039.                 msgResponse.addProprietariIntoCache_readFromTable(this.idModulo, "sendRispostaErroreProtocollo [risposta]",this.idSessione,this.functionAsRouter);

  3041.         }catch (Exception e) {  
  3042.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendRispostaErroreProtocollo");
  3043.             statoRichiesta.closePreparedStatement();
  3044.             statoRisposta.closePreparedStatement();
  3045.             // Rilancio l'eccezione
  3046.             throw new EJBUtilsException("EJBUtils.sendRispostaErroreProtocollo error: "+e.getMessage(),e);

  3048.         }   finally{
  3049.             this.unsetEJBSuffixFunctionName();
  3050.         }

  3052.     }

  3054.     
  3055.     
  3056.     
  3057.     
  3058.     
  3059.     
  3060.     
  3061.     
  3062.     
  3063.     
  3064.     
  3065.     

  3067.     /**
  3068.      * Spedisce un Messaggio di Sblocco 'Risposta'
  3069.      * al modulo di openspcoop 'RicezioneBusteXXX', 
  3070.      * inserendolo all'interno di  un
  3071.      * messaggio di tipo {@link org.openspcoop2.pdd.services.core.RicezioneBusteMessage} e 
  3072.      * spedendolo nella coda 'toRicezioneBusteXXX'.
  3073.      * La spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null.
  3074.      * 
  3075.      * @param idModuloInAttesa identificativo del modulo 'RicezioneBusteXXX'. 
  3076.      * 
  3077.      */
  3078.     public GestoreMessaggi sendSbloccoRicezioneBuste(String idModuloInAttesa)throws EJBUtilsException,ProtocolException{
  3079.         
  3080.         String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  3081.         RequestInfo requestInfo = (RequestInfo) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);

  3083.         // ID Busta Sblocco
  3084.         org.openspcoop2.protocol.engine.builder.Imbustamento imbustatore = new Imbustamento(this.log, this.protocolFactory, this.openSPCoopState.getStatoRichiesta());
  3085.         String idSblocco =  
  3086.             imbustatore.buildID(this.identitaPdD, idTransazione, 
  3087.                     this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  3088.                     this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  3089.                     RuoloMessaggio.RISPOSTA);
  3090.         return sendBustaRisposta(idModuloInAttesa,null,MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(), requestInfo.getProtocolRequestMessageType(), MessageRole.RESPONSE)
  3091.                 ,idSblocco,null,null,null,null);
  3092.     }
  3093.     
  3094.     public GestoreMessaggi sendSOAPFault(String idModuloInAttesa,OpenSPCoop2Message msg)throws EJBUtilsException,ProtocolException{
  3095.         
  3096.         String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  3097.         
  3098.         // ID Busta Sblocco
  3099.         org.openspcoop2.protocol.engine.builder.Imbustamento imbustatore = new Imbustamento(this.log, this.protocolFactory, this.openSPCoopState.getStatoRichiesta());
  3100.         String idSblocco = 
  3101.             imbustatore.buildID(this.identitaPdD, idTransazione, 
  3102.                     this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  3103.                     this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  3104.                     RuoloMessaggio.RISPOSTA);

  3106.         return sendBustaRisposta(idModuloInAttesa,null,msg,idSblocco,null,null,null,null);
  3107.     }

  3109.     /**
  3110.      * Spedisce una busta di Risposta al modulo di OpenSPCoop piu' indicato, a seconda che
  3111.      * la busta debba essere spedita sulla reply della connessione HTTP 
  3112.      * (nodo RicezioneBuste, la spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null)
  3113.      * o su di una nuova connessione (nodo InoltroRisposte), nel caso di indirizzo telematico o nuova risposta
  3114.      * La spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null.
  3115.      *
  3116.      * @param idModuloInAttesa identificativo del modulo 'RicezioneBusteXXX'. 
  3117.      * @param busta Busta he definisce la busta di risposta
  3118.      * @param msg Msg Applicativo (SOAP) da inserire nella busta di risposta.
  3119.      * 
  3120.      */
  3121.     public GestoreMessaggi buildAndSendBustaRisposta(String idModuloInAttesa,Busta busta,
  3122.             OpenSPCoop2Message msg,String profiloGestione,
  3123.             String idCorrelazioneApplicativa,String servizioApplicativoFruitore)throws EJBUtilsException,ProtocolException{
  3124.         return buildAndSendBustaRisposta(idModuloInAttesa, busta, msg, profiloGestione, idCorrelazioneApplicativa, null, servizioApplicativoFruitore);
  3125.     }
  3126.     public GestoreMessaggi buildAndSendBustaRisposta(String idModuloInAttesa,Busta busta,
  3127.             OpenSPCoop2Message msg,String profiloGestione,
  3128.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException,ProtocolException{

  3130.         String idTransazione = (String) this.pddContext.getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE);
  3131.         
  3132.         // ID Busta Costruita
  3133.         org.openspcoop2.protocol.engine.builder.Imbustamento imbustatore = new Imbustamento(this.log, this.protocolFactory, this.openSPCoopState.getStatoRichiesta());
  3134.         String id_busta = 
  3135.             imbustatore.buildID(this.identitaPdD, idTransazione, 
  3136.                     this.propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  3137.                     this.propertiesReader.getGestioneSerializableDBCheckInterval(),
  3138.                     RuoloMessaggio.RISPOSTA);

  3140.         // Aggiungo ID
  3141.         if(busta!=null)
  3142.             busta.setID(id_busta);

  3144.         return sendBustaRisposta(idModuloInAttesa,busta,msg,null,profiloGestione,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);

  3146.     }

  3148.     /**
  3149.      * Spedisce una busta di Risposta al modulo di OpenSPCoop piu'indicato, a seconda che
  3150.      * la busta debba essere spedita sulla reply della connessione HTTP 
  3151.      * (nodo RicezioneBuste, la spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null)
  3152.      * o su di una nuova connessione (nodo InoltroRisposte)
  3153.      * La spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null.
  3154.      *
  3155.      * @param idModuloInAttesa identificativo del modulo 'RicezioneBusteXXX'. 
  3156.      * @param busta Busta  
  3157.      * @return Pstmt da eseguire per la gestione della risposta
  3158.      * 
  3159.      */
  3160.     public GestoreMessaggi sendBustaRisposta(String idModuloInAttesa,
  3161.             Busta busta,String profiloGestione,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException{
  3162.         return sendBustaRisposta(idModuloInAttesa,busta,null,null,profiloGestione,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore);
  3163.     }

  3165.     /**
  3166.      * Spedisce una busta di Risposta al modulo di OpenSPCoop piu' indicato, a seconda che
  3167.      * la busta debba essere spedita sulla reply della connessione HTTP 
  3168.      * (nodo RicezioneBuste, la spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null)
  3169.      * o su di una nuova connessione (nodo InoltroRisposte)
  3170.      * La spedizione viene naturalmente effettuata solo se <var>idModuloInAttesa</var> e' diverso da null.
  3171.      *
  3172.      * @param idModuloInAttesa identificativo del modulo 'RicezioneBusteXXX'. 
  3173.      * @param busta Busta 
  3174.      * @param msg Msg Applicativo (SOAP) da inserire nella busta di risposta.
  3175.      * @param repository Repository dove effettuare il salvataggio della busta   
  3176.      * @param idSbloccoModulo Identificativo di sblocco del modulo RicezioneBuste
  3177.      * @return Pstmt da eseguire per la gestione della risposta
  3178.      * 
  3179.      */
  3180.     private GestoreMessaggi sendBustaRisposta(String idModuloInAttesa,
  3181.             Busta busta,OpenSPCoop2Message msg,String idSbloccoModulo,
  3182.             String profiloGestione,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore)throws EJBUtilsException{ 

  3184.         IState statoRisposta = this.openSPCoopState.getStatoRisposta(); 

  3186.         GestoreMessaggi msgResponse = null;
  3187.         this.setEJBSuffixFunctionName();
  3188.         try{
  3189.             
  3190.             /* ------- Gestione MsgRisposta --------------- */

  3192.             boolean httpReply = true;
  3193.             // Esamina tipo di risposta (indirizzo di spedizione) a meno di messaggi
  3194.             // di sblocco modulo.
  3195.             if(idSbloccoModulo==null){
  3196.                 if( this.replyOnNewConnection )
  3197.                     httpReply = false;
  3198.                 if(busta!=null){
  3199.                     if( busta.getIndirizzoDestinatario()!=null &&
  3200.                             this.utilizzoIndirizzoTelematico){
  3201.                         httpReply = false;      
  3202.                     }
  3203.                 }
  3204.             }

  3206.             // Devo generare una risposta solo se devo inviarla verso una nuova connessione,
  3207.             // o se esiste un nodo a cui inviare la risposta (idModuloInAttesa)
  3208.             if( (httpReply==false) || (idModuloInAttesa != null) ){

  3210.                 boolean salvaSuDatabasePerStateless = false;
  3211.                 if(httpReply==false && (this.functionAsRouter==false) && (this.openSPCoopState instanceof OpenSPCoopStateless)){
  3212.                     salvaSuDatabasePerStateless = true; // Il messaggio inviato su una nuova connessione è come fosse una richiesta
  3213.                 }
  3214.                 
  3215.                 // Salvataggio busta da inviare
  3216.                 if(busta!=null){
  3217.                     RepositoryBuste repositoryRisposta = new RepositoryBuste(statoRisposta, this.log, salvaSuDatabasePerStateless, this.protocolFactory);
  3218.                     repositoryRisposta.registraBustaIntoOutBox(busta, this.propertiesReader.getRepositoryIntervalloScadenzaMessaggi());
  3219.                     Integrazione infoIntegrazione = new Integrazione();
  3220.                     infoIntegrazione.setIdModuloInAttesa(idModuloInAttesa);
  3221.                     infoIntegrazione.setScenario(this.scenarioCooperazione);
  3222.                     repositoryRisposta.aggiornaInfoIntegrazioneIntoOutBox(busta.getID(),infoIntegrazione);
  3223.                 }

  3225.                 // --- Se devo generare una risposta 
  3226.                 // e mi e' chiesto di gestire un messaggio di risposta con errore (msg!=null), lo effettuo.
  3227.                 String idRisposta = null;
  3228.                 if(busta!=null)
  3229.                     idRisposta = busta.getID();
  3230.                 else
  3231.                     idRisposta = idSbloccoModulo;
  3232.                 msgResponse = new GestoreMessaggi(this.openSPCoopState, salvaSuDatabasePerStateless, idRisposta,Costanti.OUTBOX,this.msgDiag, this.pddContext);
  3233.                 if(httpReply==false){
  3234.                     msgResponse.setOneWayVersione11(this.oneWayVersione11);
  3235.                 }
  3236.                 if( msg!=null ){     
  3237.                     // creazione nuovo stato
  3238.                     if(this.openSPCoopState instanceof OpenSPCoopStateless){
  3239.                         msgResponse.registraMessaggio(msg,((OpenSPCoopStateless)this.openSPCoopState).getTempiAttraversamentoPDD().getRicezioneMsgIngresso(),idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta);
  3240.                     }else{
  3241.                         msgResponse.registraMessaggio(msg,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta);
  3242.                     }
  3243.                 }
  3244.                 // else{ Carico lo stato di un messaggio, esistente


  3247.                 //---   aggiorno riferimentoMsg
  3248.                 msgResponse.aggiornaRiferimentoMessaggio(this.idSessione);

  3250.                 // --- Aggiornamento Proprietario messaggio
  3251.                 if(httpReply==false){
  3252.                     // Aggiorno proprietario Messaggio: INOLTRO RISPOSTE    
  3253.                     msgResponse.aggiornaProprietarioMessaggio(InoltroRisposte.ID_MODULO);
  3254.                 }else{
  3255.                     if(idModuloInAttesa != null){          
  3256.                         // Aggiorno proprietario Messaggio: RICEZIONE BUSTE
  3257.                         msgResponse.aggiornaProprietarioMessaggio(idModuloInAttesa);
  3258.                     }
  3259.                 }

  3261.                 // --- Spedizione al successivo modulo
  3262.                 try{
  3263.                     if(httpReply==false){
  3264.                         // spedizione al modulo InoltroRisposte
  3265.                         sendToInoltroRisposte(busta,false,profiloGestione, msgResponse,idCorrelazioneApplicativa,idCorrelazioneApplicativaRisposta,servizioApplicativoFruitore,true);   
  3266.                     }else{
  3267.                         if(idModuloInAttesa != null){
  3268.                             // spedizione al modulo RicezioneBusteXXX
  3269.                             sendBustaToRicezioneBuste(idModuloInAttesa,busta,idSbloccoModulo);
  3270.                         }
  3271.                     }
  3272.                 }catch(Exception e){
  3273.                     throw e; // rilancio eccezione;
  3274.                 }

  3276.             }// end Gestione Risposta



  3280.             /* ------- Ritorna le pstmt da eseguire per la risposta --------------- */
  3281.             return msgResponse;

  3283.         }catch (Exception e) {  
  3284.             this.msgDiag.logErroreGenerico(e, "EJBUtils.sendRispostaProtocollo");
  3285.             if(msgResponse!=null )
  3286.                 ((StateMessage)statoRisposta).closePreparedStatement();
  3287.             //  Rilancio l'eccezione
  3288.             throw new EJBUtilsException("EJBUtils.sendRispostaProtocollo error: "+e.getMessage(),e);

  3290.         }   finally{
  3291.             this.unsetEJBSuffixFunctionName();
  3292.         }

  3294.     }




  3299.     /** ------------------- Metodi per la spedizione al nodo 'InoltroRisposte' ---------------- */

  3301.     /**
  3302.      * Spedisce una busta di risposta   
  3303.      * al modulo di openspcoop {@link org.openspcoop2.pdd.mdb.InoltroRisposteMDB}, 
  3304.      * inserendolo all'interno di  un messaggio di tipo {@link org.openspcoop2.pdd.mdb.InoltroRisposteMessage} e 
  3305.      * spedendolo nella coda 'toInoltroRisposte'.
  3306.      *
  3307.      * @param busta Busta utilizzata per la costruzione della busta di risposta
  3308.      * @param inoltroSegnalazioneErrore Indicazione se la busta inviata segnala la precedente ricezione di una busta
  3309.      *        di risposta malformata
  3310.      * 
  3311.      */
  3312.     public void sendToInoltroRisposte(Busta busta,
  3313.             boolean inoltroSegnalazioneErrore,String profiloGestione, GestoreMessaggi gm,
  3314.             String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,String servizioApplicativoFruitore,boolean imbustamento)throws EJBUtilsException{

  3316.         if (   (this.openSPCoopState instanceof OpenSPCoopStateful)  ||
  3317.                 this.oneWayVersione11) {
  3318.             
  3319.             try{
  3320.                 this.msgDiag.highDebug("[EJBUtils] Creazione ObjectMessage for send nell'infrastruttura.");
  3321.                 // costruzione
  3322.                 InoltroRisposteMessage inoltroMSG = new InoltroRisposteMessage();
  3323.                 inoltroMSG.setDominio(this.identitaPdD);
  3324.                 inoltroMSG.setInoltroSegnalazioneErrore(inoltroSegnalazioneErrore);
  3325.                 inoltroMSG.setBustaRisposta(busta);
  3326.                 inoltroMSG.setProfiloGestione(profiloGestione); 
  3327.                 inoltroMSG.setOneWayVersione11(this.oneWayVersione11);
  3328.                 inoltroMSG.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  3329.                 inoltroMSG.setIdCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  3330.                 inoltroMSG.setServizioApplicativoFruitore(servizioApplicativoFruitore);
  3331.                 inoltroMSG.setImbustamento(imbustamento);
  3332.                 inoltroMSG.setImplementazionePdDSoggettoMittente(this.implementazionePdDSoggettoMittente);
  3333.                 inoltroMSG.setImplementazionePdDSoggettoDestinatario(this.implementazionePdDSoggettoDestinatario);
  3334.                 inoltroMSG.setPddContext(this.pddContext);
  3335.     
  3336.                 if ( this.oneWayVersione11 ) {
  3337.                     
  3338.                     OpenSPCoopStateless statelessSerializzabile = ((OpenSPCoopStateless) this.openSPCoopState).rendiSerializzabile();
  3339.                     inoltroMSG.setOpenspcoopstate(statelessSerializzabile);
  3340.                 }

  3342.                 // send
  3343.                 this.nodeSender.send(inoltroMSG, org.openspcoop2.pdd.mdb.InoltroRisposte.ID_MODULO, this.msgDiag, 
  3344.                         this.identitaPdD,this.idModulo, this.idSessione,gm);
  3345.     
  3346.             } catch (Exception e) {
  3347.                 this.log.error("Spedizione->InoltroRisposte non riuscita",e);   
  3348.                 this.msgDiag.logErroreGenerico(e, "EJBUtils.sendToInoltroRisposte");
  3349.                 throw new EJBUtilsException("EJBUtils.sendToInoltroRisposte error: "+e.getMessage(),e);
  3350.             }
  3351.             
  3352.         }
  3353.     }







  3361.     
  3362.     
  3363.     /** ------------------- Metodi per la generazione di messaggi  'OK' ---------------- */
  3364.     
  3365.     /**
  3366.      * Metodo che si occupa di costruire un messaggio SOAPElement 'openspcoop OK'. 
  3367.      *
  3368.      * @return messaggio Soap 'OK' in caso di successo, null altrimenti.
  3369.      * 
  3370.      */
  3371.     public OpenSPCoop2Message buildOpenSPCoopOK(MessageType messageType, String id) throws UtilsException{
  3372.         try{
  3373.             OpenSPCoop2MessageFactory mf = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  3374.                         
  3375.             EsitoRichiesta esito = new EsitoRichiesta();
  3376.             esito.setMessageId(id);
  3377.             esito.setState(org.openspcoop2.core.integrazione.constants.Costanti.PRESA_IN_CARICO);
  3378.             
  3379.             switch (messageType) {
  3380.             case SOAP_11:
  3381.             case SOAP_12:
  3382.             
  3383.                 OpenSPCoop2Message responseSOAPMessage = mf.createEmptyMessage(messageType,MessageRole.RESPONSE);
  3384.                 OpenSPCoop2SoapMessage soapMessage = responseSOAPMessage.castAsSoap();
  3385.                 SOAPBody soapBody = soapMessage.getSOAPBody();
  3386.                 byte[]xmlEsito = EsitoRichiestaXMLUtils.generateEsitoRichiesta(esito);
  3387.                 soapBody.addChildElement(soapMessage.createSOAPElement(xmlEsito));
  3388.                 return responseSOAPMessage;
  3389.                 

  3391.             case JSON:
  3392.                 
  3393.                 byte[] bytes = EsitoRichiestaXMLUtils.generateEsitoRichiestaAsJson(esito).getBytes();
  3394.                 OpenSPCoop2MessageParseResult pr = mf.createMessage(messageType, MessageRole.RESPONSE, HttpConstants.CONTENT_TYPE_JSON, bytes);
  3395.                 return pr.getMessage_throwParseException();
  3396.                 
  3397.             default:
  3398.                 
  3399.                 bytes = EsitoRichiestaXMLUtils.generateEsitoRichiesta(esito);
  3400.                 pr = mf.createMessage(MessageType.XML, MessageRole.RESPONSE, HttpConstants.CONTENT_TYPE_XML, bytes);
  3401.                 return pr.getMessage_throwParseException();
  3402.                 
  3403.             }
  3404.             
  3405.             

  3407.         } catch(Exception e) {
  3408.             throw new UtilsException("Creazione MsgOpenSPCoopOK non riuscito: "+e.getMessage(),e);
  3409.         }
  3410.     }


  3413.     
  3414.     
  3415.     
  3416.     
  3417.     
  3418.     






  3425.     /** ------------------- Metodi per la spedizione al nodo 'RicezioneBuste' ---------------- */

  3427.     /**
  3428.      * Spedisce un header Protocollo <var>header</var>
  3429.      * al modulo di openspcoop 'RicezioneBusteXXX', 
  3430.      * inserendolo all'interno di  un
  3431.      * messaggio di tipo {@link org.openspcoop2.pdd.services.core.RicezioneBusteMessage} e 
  3432.      * spedendolo nella coda 'toRicezioneBusteXXX'.
  3433.      *
  3434.      * @param idModuloInAttesa identificativo del modulo 'RicezioneBusteXXX'. 
  3435.      * @param busta Busta utilizzata per la costruzione della busta di risposta
  3436.      * @param idSbloccoModulo Identificativo del messaggio di sblocco se il messaggio non contiene una busta
  3437.      * 
  3438.      */
  3439.     public void sendBustaToRicezioneBuste(String idModuloInAttesa,Busta busta, String idSbloccoModulo) throws EJBUtilsException{

  3441.         if (this.openSPCoopState instanceof OpenSPCoopStateless) {
  3442.             RicezioneBusteMessage ricezioneMSG = new RicezioneBusteMessage();
  3443.             ricezioneMSG.setBustaRisposta(busta);
  3444.             ricezioneMSG.setIdMessaggioSblocco(idSbloccoModulo);
  3445.             ricezioneMSG.setPddContext(this.pddContext);
  3446.             ((OpenSPCoopStateless)this.openSPCoopState).setMessageLib(ricezioneMSG);
  3447.         }
  3448.         
  3449.         if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(this.propertiesReader.getNodeReceiver())){ 

  3451.             try{
  3452.                 this.msgDiag.highDebug("Creazione ObjectMessage for send via JMS.");
  3453.                 // costruzione
  3454.                 RicezioneBusteMessage ricezioneMSG = new RicezioneBusteMessage();
  3455.                 ricezioneMSG.setBustaRisposta(busta);
  3456.                 ricezioneMSG.setIdMessaggioSblocco(idSbloccoModulo);
  3457.                 ricezioneMSG.setPddContext(this.pddContext);

  3459.                 if (this.openSPCoopState instanceof OpenSPCoopStateless) 
  3460.                     ((OpenSPCoopStateless)this.openSPCoopState).setMessageLib(ricezioneMSG);

  3462.                 else { //Stateful mode:
  3463.                     // NOTA: usare realmente JMSSender e non l'interfaccia INodeSender, perche' questo punto riguarda INodeReceiver!!
  3464.                     String idT = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, this.pddContext);
  3465.                     JMSSender senderJMS = new JMSSender(this.identitaPdD,this.idModulo,this.log,idT);
  3466.                     java.util.Properties prop = new java.util.Properties();
  3467.                     prop.put("ID",this.idSessione);

  3469.                     if(senderJMS.send(idModuloInAttesa,
  3470.                             ricezioneMSG,prop) == false){
  3471.                         this.msgDiag.logErroreGenerico(senderJMS.getErrore(), "EJBUtils.sendBustaToRicezioneBuste.senderJMS");
  3472.                         throw new Exception("SendJMSError: "+senderJMS.getErrore());
  3473.                     }

  3475.                     this.msgDiag.highDebug("ObjectMessage send via JMS.");
  3476.                 }
  3477.             } catch (Exception e) { 
  3478.                 this.msgDiag.logErroreGenerico(e, "EJBUtils.sendBustaToRicezioneBuste");
  3479.                 throw new EJBUtilsException("EJBUtils.sendToRicezioneBuste error: "+e.getMessage(),e);
  3480.             }
  3481.         }
  3482.     }

  3484.     public void setScenarioCooperazione(String scenarioCooperazione) {
  3485.         this.scenarioCooperazione = scenarioCooperazione;
  3486.     }

  3488.     public Timestamp getRicezioneMsgRisposta() {
  3489.         return this.ricezioneMsgRisposta;
  3490.     }

  3492.     public void setRicezioneMsgRisposta(Timestamp ricezioneMsgRisposta) {
  3493.         this.ricezioneMsgRisposta = ricezioneMsgRisposta;
  3494.     }

  3496.     public Timestamp getSpedizioneMsgIngresso() {
  3497.         return this.spedizioneMsgIngresso;
  3498.     }

  3500.     public void setSpedizioneMsgIngresso(Timestamp spedizioneMsgIngresso) {
  3501.         this.spedizioneMsgIngresso = spedizioneMsgIngresso;
  3502.     }

  3504.     
  3505.     /** restituisce true solo se i bytes del messaggio vanno salvati nel db */
  3506.     public boolean saveMessageStateless(PortaDelegata pd) throws Exception {
  3507.         ProfiloDiCollaborazione profiloCollaborazione = EJBUtils.calcolaProfiloCollaborazione(this.scenarioCooperazione);
  3508.         return this.configurazionePdDReader.isModalitaStateless(pd, profiloCollaborazione);
  3509.     }


  3512.     public void setOneWayVersione11(boolean oneWay11) {
  3513.         this.oneWayVersione11 = oneWay11;
  3514.     }

  3516.     public void setPortaDiTipoStateless_esclusoOneWay11(boolean stateless) {
  3517.         this.portaDiTipoStateless_esclusoOneWay11 = stateless;
  3518.     }

  3520.     public void setRouting(boolean routing) {
  3521.         this.routing = routing;
  3522.     }

  3524.     public void setRollbackRichiestaInCasoErrore(
  3525.             boolean rollbackRichiestaInCasoErrore) {
  3526.         this.rollbackRichiestaInCasoErrore = rollbackRichiestaInCasoErrore;
  3527.     }
  3528.     
  3529.     public void setRollbackRichiestaInCasoErrore_rollbackHistory(
  3530.             boolean rollbackRichiestaInCasoErrore_rollbackHistory) {
  3531.         this.rollbackRichiestaInCasoErrore_rollbackHistory = rollbackRichiestaInCasoErrore_rollbackHistory;
  3532.     }


  3535.     public static ProfiloDiCollaborazione calcolaProfiloCollaborazione(String scenarioCooperazione){
  3536.         // Calcolo Profilo di Collaborazione
  3537.         ProfiloDiCollaborazione profiloCollaborazione = null;
  3538.         if( Costanti.SCENARIO_ONEWAY_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ){
  3539.             profiloCollaborazione = ProfiloDiCollaborazione.ONEWAY;
  3540.         }
  3541.         else if(Costanti.SCENARIO_SINCRONO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ){
  3542.             profiloCollaborazione = ProfiloDiCollaborazione.SINCRONO;
  3543.         }
  3544.         else if(Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_POLLING.equals(scenarioCooperazione) || Costanti.SCENARIO_ASINCRONO_ASIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione)){
  3545.             profiloCollaborazione = ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO;
  3546.         }
  3547.         else if (Costanti.SCENARIO_ASINCRONO_SIMMETRICO_INVOCAZIONE_SERVIZIO.equals(scenarioCooperazione) ||
  3548.                 Costanti.SCENARIO_ASINCRONO_SIMMETRICO_CONSEGNA_RISPOSTA.equals(scenarioCooperazione)){
  3549.             profiloCollaborazione = ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO;
  3550.         }
  3551.         return profiloCollaborazione;
  3552.     }

  3554.     public String getServizioApplicativoErogatore() {
  3555.         return this.servizioApplicativoErogatore;
  3556.     }

  3558.     public void setServizioApplicativoErogatore(String servizioApplicativoErogatore) {
  3559.         this.servizioApplicativoErogatore = servizioApplicativoErogatore;
  3560.     }

  3562. }
Created with JaCoCo 0.8.8.202204050719