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



  23. package org.openspcoop2.protocol.engine.driver;


  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.util.ArrayList;
  30. import java.util.Date;
  31. import java.util.List;

  33. import org.openspcoop2.core.id.IDServizio;
  34. import org.openspcoop2.core.id.IDSoggetto;
  35. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  36. import org.openspcoop2.protocol.engine.Configurazione;
  37. import org.openspcoop2.protocol.engine.LetturaParametriBusta;
  38. import org.openspcoop2.protocol.engine.constants.Costanti;
  39. import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
  40. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  41. import org.openspcoop2.protocol.registry.RisultatoValidazione;
  42. import org.openspcoop2.protocol.sdk.Busta;
  43. import org.openspcoop2.protocol.sdk.Eccezione;
  44. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  45. import org.openspcoop2.protocol.sdk.Integrazione;
  46. import org.openspcoop2.protocol.sdk.ProtocolException;
  47. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  48. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  49. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  50. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  51. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  52. import org.openspcoop2.protocol.sdk.state.IState;
  53. import org.openspcoop2.protocol.sdk.state.StateMessage;
  54. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  55. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  56. import org.openspcoop2.utils.LoggerWrapperFactory;
  57. import org.openspcoop2.utils.Utilities;
  58. import org.openspcoop2.utils.date.DateManager;
  59. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  60. import org.openspcoop2.utils.sql.ISQLQueryObject;
  61. import org.openspcoop2.utils.sql.SQLObjectFactory;
  62. import org.slf4j.Logger;

  64. /**
  65.  * Sono inclusi i metodi per la gestione del profilo di collaborazione.
  66.  * Tutti i metodi hanno bisogno di una connessione ad un DB, precedentemente impostata
  67.  * e passata attraverso l'apposito metodo.
  68.  *
  69.  *
  70.  * @author Poli Andrea (apoli@link.it)
  71.  * @author Tronci Fabio (tronci@link.it)
  72.  * @author $Author$
  73.  * @version $Rev$, $Date$
  74.  */

  76. public class ProfiloDiCollaborazione {
  77.     
  78.     /** Logger utilizzato per debug. */
  79.     private Logger log = null;

  81.     private IState state;

  83.     /** GestoreRepository */
  84.     private IGestoreRepository gestoreRepositoryBuste;
  85.     
  86.     private IProtocolFactory<?> protocolFactory;
  87.     private IProtocolConfiguration protocolConfiguration;
  88.     private IProtocolManager protocolManager;
  89.     private ITraduttore protocolTraduttore;
  90.     
  91.     private void initProtocolFactory(IProtocolFactory<?> protocolFactory) throws ProtocolException{
  92.         this.protocolFactory = protocolFactory;
  93.         this.protocolManager = this.protocolFactory.createProtocolManager();
  94.         this.protocolTraduttore = this.protocolFactory.createTraduttore();
  95.         this.protocolConfiguration = this.protocolFactory.createProtocolConfiguration();
  96.     }

  98.     /* ********  C O S T R U T T O R E  ******** */

  100.     /**
  101.      * Costruttore. 
  102.      *
  103.      * @param state Oggetto che rappresenta lo stato di una busta
  104.      * @throws ProtocolException 
  105.      * 
  106.      */
  107.     public ProfiloDiCollaborazione(IState state,IProtocolFactory<?> protocolFactory) throws ProtocolException{
  108.         this(state, Configurazione.getLibraryLog(),protocolFactory);
  109.     }
  110.     /**
  111.      * Costruttore. 
  112.      *
  113.      * @param state Oggetto che rappresenta lo stato di una busta
  114.      * @throws ProtocolException 
  115.      * 
  116.      */
  117.     public ProfiloDiCollaborazione(IState state, Logger alog, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  118.         this.state = state;
  119.         this.gestoreRepositoryBuste = Configurazione.getGestoreRepositoryBuste();
  120.         if(alog!=null){
  121.             this.log = alog;
  122.         }else{
  123.             this.log = LoggerWrapperFactory.getLogger(ProfiloDiCollaborazione.class.getName());
  124.         }
  125.         if(protocolFactory!=null)
  126.             initProtocolFactory(protocolFactory);
  127.     }


  130.     public void updateState(IState state){
  131.         this.state = state;
  132.     }
  133.     

  135.     /* ********  PROFILO GENERICO  ******** */

  137.     /**
  138.      * Metodo che si occupa di salvare una busta, precedentemente registrata, 
  139.      * tra le buste usate per la gestione del Profilo di Collaborazione. 
  140.      * 
  141.      * @param id identificativo della busta da salvare.
  142.      * 
  143.      */
  144.     public void registraBustaInviata(String id) throws ProtocolException{
  145.         registraBusta(id,Costanti.OUTBOX);
  146.     }
  147.     /**
  148.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  149.      * tra le buste usate per la gestione del Profilo di Collaborazione. 
  150.      * 
  151.      * @param id identificativo della busta da eliminare.
  152.      * 
  153.      */
  154.     public void eliminaBustaInviata(String id,boolean forzaEliminazioneDB) throws ProtocolException{
  155.         eliminaBusta(id,Costanti.OUTBOX,forzaEliminazioneDB);
  156.     }
  157.     public void eliminaBustaInviata(String id) throws ProtocolException{
  158.         eliminaBusta(id,Costanti.OUTBOX);
  159.     }

  161.     /**
  162.      * Metodo che si occupa di salvare una busta, precedentemente registrata, 
  163.      * tra le buste usate per la gestione del Profilo di Collaborazione. 
  164.      * 
  165.      * @param id identificativo della busta da salvare.
  166.      * 
  167.      */
  168.     public void registraBustaRicevuta(String id) throws ProtocolException{
  169.         registraBusta(id,Costanti.INBOX);
  170.     }
  171.     /**
  172.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  173.      * tra le buste usate per la gestione del Profilo di Collaborazione. 
  174.      * 
  175.      * @param id identificativo della busta da eliminare.
  176.      * 
  177.      */
  178.     public void eliminaBustaRicevuta(String id,boolean forzaEliminazioneDB) throws ProtocolException{
  179.         eliminaBusta(id,Costanti.INBOX,forzaEliminazioneDB);
  180.     }
  181.     public void eliminaBustaRicevuta(String id) throws ProtocolException{
  182.         eliminaBusta(id,Costanti.INBOX);
  183.     }

  185.     /**
  186.      * Metodo che si occupa di salvare una busta, precedentemente registrata, 
  187.      * tra le buste usate per la gestione del Profilo di Collaborazione. 
  188.      * 
  189.      * @param id identificativo della busta da salvare.
  190.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  191.      * 
  192.      */
  193.     public void registraBusta(String id,String tipoBusta) throws ProtocolException{

  195.         if(this.state instanceof StatefulMessage) {
  196.             StatefulMessage stateful = (StatefulMessage)this.state;
  197.             Connection connectionDB = stateful.getConnectionDB();

  199.             PreparedStatement pstmtUpdate = null;
  200.             try{    

  202.                 StringBuilder queryUpdate = new StringBuilder();
  203.                 queryUpdate.append("UPDATE ");
  204.                 queryUpdate.append(Costanti.REPOSITORY);
  205.                 queryUpdate.append(" SET ");
  206.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  207.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  208.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  209.                 pstmtUpdate.setString(1,id);
  210.                 pstmtUpdate.setString(2,tipoBusta);

  212.                 // Add PreparedStatement
  213.                 stateful.getPreparedStatement().put("UPDATE saveBustaForProfilo"+tipoBusta+"_"+id,pstmtUpdate);

  215.             } catch(Exception e) {
  216.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE, Errore di registrazione "+tipoBusta+"/"+id+": "+e.getMessage();       
  217.                 this.log.error(errorMsg,e);
  218.                 try{
  219.                     if( pstmtUpdate != null )
  220.                         pstmtUpdate.close();
  221.                 } catch(Exception er) {
  222.                     // Eccezione SQL.
  223.                 }
  224.                 throw new ProtocolException(errorMsg,e);
  225.             }
  226.         }
  227.         else {  //NOP
  228.         }
  229.     }
  230.     /**
  231.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  232.      * tra le buste usate per la gestione del Profilo di Collaborazione.. 
  233.      * 
  234.      * @param id identificativo della busta da salvare.
  235.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  236.      * 
  237.      */
  238.     public void eliminaBusta(String id,String tipoBusta) throws ProtocolException{
  239.         this.eliminaBusta(id, tipoBusta, false);
  240.     }
  241.     public void eliminaBusta(String id,String tipoBusta, boolean forzaEliminazioneDB) throws ProtocolException{
  242.         if(this.state instanceof StatefulMessage  ||  forzaEliminazioneDB) {
  243.             StateMessage state = (StateMessage)this.state;
  244.             Connection connectionDB = state.getConnectionDB();

  246.             PreparedStatement pstmtUpdate = null;
  247.             try{    

  249.                 StringBuilder queryUpdate = new StringBuilder();
  250.                 queryUpdate.append("UPDATE ");
  251.                 queryUpdate.append(Costanti.REPOSITORY);
  252.                 queryUpdate.append(" SET ");
  253.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(false));
  254.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  255.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  256.                 pstmtUpdate.setString(1,id);
  257.                 pstmtUpdate.setString(2,tipoBusta);

  259.                 // Add PreparedStatement
  260.                 state.getPreparedStatement().put("UPDATE eliminaBustaForProfilo"+tipoBusta+"_"+id,pstmtUpdate);

  262.             } catch(Exception e) {
  263.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE, Errore di cancellazione "+tipoBusta+"/"+id+": "+e.getMessage();       
  264.                 this.log.error(errorMsg,e);
  265.                 try{
  266.                     if( pstmtUpdate != null )
  267.                         pstmtUpdate.close();
  268.                 } catch(Exception er) {
  269.                     // Eccezione SQL.
  270.                 }
  271.                 throw new ProtocolException(errorMsg,e);
  272.             }
  273.         }
  274.     }


  277.     /* ********  PROFILO SINCRONO  ******** */

  279.     /**
  280.      * Controlla se e' stato precedentemente registrata una richiesta sincrona.
  281.      *
  282.      * @param riferimentoMessaggio Identificativo.
  283.      * @return true se esiste una entry nella tabella apposita.
  284.      * 
  285.      */
  286.     public boolean sincrono_validazioneRiferimentoMessaggio(String riferimentoMessaggio) throws ProtocolException{
  287.         if(this.state instanceof StatefulMessage) {
  288.             StatefulMessage stateful = (StatefulMessage)this.state;
  289.             try{
  290.                 RepositoryBuste repositoryBuste = new RepositoryBuste(stateful, this.log, this.protocolFactory);
  291.                 if(repositoryBuste.isRegistrataIntoOutBox(riferimentoMessaggio)){
  292.                     return true;
  293.                 }else{
  294.                     return false;
  295.                 }
  296.             }catch(Exception e){    
  297.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_SINCRONO, Errore durante la sincrono_validazioneRiferimentoMessaggio "+riferimentoMessaggio+": "+e.getMessage();       
  298.                 this.log.error(errorMsg);
  299.                 return false;
  300.             }
  301.         }
  302.         else {
  303.             //TODO CHECKME
  304.             return true;
  305.         }
  306.     }

  308.     /**
  309.      * Valida la collaborazione utilizzata
  310.      *
  311.      * @param riferimentoMessaggio Identificativo.
  312.      * @return true se la collaborazione e' valida
  313.      * 
  314.      */
  315.     public boolean sincrono_validazioneCollaborazione(String riferimentoMessaggio,String idCollaborazione) throws ProtocolException{
  316.         if(this.state instanceof StatefulMessage) {
  317.             StatefulMessage stateful = (StatefulMessage)this.state;

  319.             try{
  320.                 RepositoryBuste repositoryBuste = new RepositoryBuste(stateful, this.log, this.protocolFactory);
  321.                 if(repositoryBuste.isRegistrataIntoOutBox(riferimentoMessaggio)){
  322.                     return idCollaborazione.equals(repositoryBuste.getCollaborazioneFromOutBox(riferimentoMessaggio));
  323.                 }else{
  324.                     return false;
  325.                 }
  326.             }catch(Exception e){    
  327.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_SINCRONO, Errore durante la sincrono_validazioneRiferimentoMessaggio "+riferimentoMessaggio+": "+e.getMessage();       
  328.                 this.log.error(errorMsg);
  329.                 return false;
  330.             }
  331.         }
  332.         else{ //TODO CHECKME 
  333.             return true;
  334.         }
  335.     }


  338.     /**
  339.      * Controlla se e' stato precedentemente registrata una richiesta sincrona.
  340.      *
  341.      * @param id Identificativo.
  342.      * 
  343.      */
  344.     public void sincrono_eliminaRichiestaInOutBox(String id) throws ProtocolException{
  345.         try{
  346.             this.eliminaBustaInviata(id);
  347.         }catch(ProtocolException e){    
  348.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_SINCRONO, Errore durante la sincrono_eliminaRichiestaInOutBox "+id+": "+e.getMessage();        
  349.             this.log.error(errorMsg);
  350.             throw e;
  351.         }
  352.     }

  354.     /**
  355.      * Costruisce una {@link org.openspcoop2.protocol.sdk.Busta} inizializzata con 
  356.      * tutte le informazioni necessarie per costruire la busta di ritorno in cui includere 
  357.      * il risultato applicativo da spedire alla porta di dominio mittente. 
  358.      * La costruire dell'apposita risposta comportera' vari aspetti come : rifMsg = id precedente , 
  359.      * Mitt e Dest scambiati , nuova OraRegistrazione e ID, ecc...
  360.      * <p>
  361.      * In caso in cui la busta di ritorno venga costruita con successo, l'entry verra' cancellata dalla tabella.
  362.      *
  363.      * @param id ID della busta contenente la richiesta sincrona.
  364.      * @return {@link org.openspcoop2.protocol.sdk.Busta} inizializzata per la costruzione della risposta sincrona in caso di successo, 
  365.      *         null altrimenti.
  366.      * 
  367.      */
  368.     public Busta sincrono_generaBustaRisposta(String id,TipoOraRegistrazione tipoTempo) throws ProtocolException {

  370.         StateMessage stateMSG = (StateMessage)this.state;
  371.         Busta busta = null;
  372.         try{
  373.             RepositoryBuste repository = new RepositoryBuste(stateMSG, this.log, this.protocolFactory);
  374.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  375.             parametri.setMittente(true);
  376.             parametri.setDestinatario(true);
  377.             parametri.setServizio(true);
  378.             parametri.setAzione(true);
  379.             parametri.setCollaborazione(true);
  380.             parametri.setProfiloTrasmissione(true);
  381.             parametri.setIndirizziTelematici(this.protocolConfiguration.isSupportoIndirizzoRisposta());
  382.             busta = repository.getSomeValuesFromInBox(id, parametri);
  383.         }catch(Exception e){
  384.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_SINCRONO, Errore durante la getBusta dal repository "+id+": "+e.getMessage();      
  385.             this.log.error(errorMsg,e);
  386.             throw new ProtocolException(errorMsg,e);
  387.         }

  389.         // inverto mitt con dest
  390.         String mitt = busta.getMittente();
  391.         String tipoMitt = busta.getTipoMittente();
  392.         String portaMitt = busta.getIdentificativoPortaMittente();
  393.         String indMitt = busta.getIndirizzoMittente();
  394.         busta.setMittente(busta.getDestinatario());
  395.         busta.setTipoMittente(busta.getTipoDestinatario());
  396.         busta.setIdentificativoPortaMittente(busta.getIdentificativoPortaDestinatario());
  397.         busta.setIndirizzoMittente(busta.getIndirizzoDestinatario());
  398.         busta.setDestinatario(mitt);
  399.         busta.setTipoDestinatario(tipoMitt);
  400.         busta.setIdentificativoPortaDestinatario(portaMitt);
  401.         busta.setIndirizzoDestinatario(indMitt);

  403.         // ProfiloDiCollaborazione
  404.         busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.SINCRONO);

  406.         // ID
  407.         busta.setRiferimentoMessaggio(id);

  409.         // OraRegistrazione
  410.         busta.setOraRegistrazione(DateManager.getDate());
  411.         busta.setTipoOraRegistrazione(tipoTempo,this.protocolTraduttore.toString(tipoTempo));

  413.         // la busta non serve piu' per il profilo di collaborazione
  414.         this.eliminaBustaRicevuta(busta.getRiferimentoMessaggio());

  416.         return busta;

  418.     } 

  420.     /**
  421.      * Effettua una validazione della busta di risposta che sia in correlazione con la richiesta.
  422.      * 
  423.      * @param bustaDaValidare Busta da controllare
  424.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  425.      * 
  426.      */
  427.     public Eccezione sincrono_validazioneCorrelazione(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException {
  428.         if(this.state instanceof StatefulMessage) {
  429.             StatefulMessage stateful = (StatefulMessage)this.state; 

  431.             Busta bustaRichiesta = null;
  432.             try{
  433.                 RepositoryBuste repository = new RepositoryBuste(stateful, this.log, this.protocolFactory);
  434.                 LetturaParametriBusta parametri = new LetturaParametriBusta();
  435.                 parametri.setMittente(true);
  436.                 parametri.setDestinatario(true);
  437.                 parametri.setServizio(true);
  438.                 parametri.setAzione(true);
  439.                 bustaRichiesta = repository.getSomeValuesFromOutBox(bustaDaValidare.getRiferimentoMessaggio(), parametri);
  440.             } catch(Exception e) {
  441.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_SINCRONO, Errore durante la sincrono_validazioneCorrelazione, get dal repository "+bustaDaValidare.getRiferimentoMessaggio()+": "+e.getMessage();      
  442.                 this.log.error(errorMsg,e);
  443.                 throw new ProtocolException(errorMsg,e);
  444.             }

  446.             // validazione
  447.             if (bustaRichiesta.getTipoDestinatario().equals(bustaDaValidare.getTipoMittente())==false){
  448.                 String msgErrore = "Tipo del mittente diverso da quello atteso nella gestione del profilo di collaborazione Sincrono";
  449.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.
  450.                         getErroreCooperazione(msgErrore),
  451.                         true,null,protocolFactory);
  452.                 this.log.error(msgErrore);
  453.                 return eccValidazione;
  454.             }
  455.             if (bustaRichiesta.getDestinatario().equals(bustaDaValidare.getMittente())==false){
  456.                 String msgErrore = "Mittente diverso da quello atteso nella gestione del profilo di collaborazione Sincrono";
  457.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.MITTENTE_NON_VALIDO.
  458.                         getErroreCooperazione(msgErrore),
  459.                         true,null,protocolFactory);
  460.                 this.log.error(msgErrore);
  461.                 return eccValidazione;
  462.             }
  463.             if (bustaRichiesta.getTipoMittente().equals(bustaDaValidare.getTipoDestinatario())==false){
  464.                 String msgErrore = "Tipo del destinatario diverso da quello atteso nella gestione del profilo di collaborazione Sincrono";
  465.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_DESTINATARIO_NON_VALIDO.
  466.                         getErroreCooperazione(msgErrore),
  467.                         true,null,protocolFactory);
  468.                 this.log.error(msgErrore);
  469.                 return eccValidazione;
  470.             }
  471.             if (bustaRichiesta.getMittente().equals(bustaDaValidare.getDestinatario())==false){
  472.                 String msgErrore = "Destinatario diverso da quello atteso nella gestione del profilo di collaborazione Sincrono";
  473.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.DESTINATARIO_NON_VALIDO.
  474.                         getErroreCooperazione(msgErrore),
  475.                         true,null,protocolFactory);
  476.                 this.log.error(msgErrore);
  477.                 return eccValidazione;
  478.             }

  480.             if(bustaDaValidare.getServizio()!=null && bustaDaValidare.getTipoServizio()!=null){
  481.                 if (bustaRichiesta.getTipoServizio().equals(bustaDaValidare.getTipoServizio())==false){
  482.                     String msgErrore = "Tipo di servizio diverso da quello atteso nella gestione del profilo di collaborazione Sincrono";
  483.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.
  484.                             getErroreCooperazione(msgErrore),
  485.                             true,null,protocolFactory);
  486.                     this.log.error(msgErrore);
  487.                     return eccValidazione;
  488.                 }
  489.                 if (bustaRichiesta.getServizio().equals(bustaDaValidare.getServizio())==false){
  490.                     String msgErrore = "Servizio diverso da quello atteso nella gestione del profilo di collaborazione Sincrono";
  491.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.SERVIZIO_NON_VALIDO.
  492.                             getErroreCooperazione(msgErrore),
  493.                             true,null,protocolFactory);
  494.                     this.log.error(msgErrore);
  495.                     return eccValidazione;
  496.                 }
  497.                 if(bustaDaValidare.getAzione()!=null){
  498.                     if (bustaDaValidare.getAzione().equals(bustaRichiesta.getAzione()) == false){
  499.                         String msgErrore = "Azione diversa da quello atteso nella gestione del profilo di collaborazione Sincrono";
  500.                         Eccezione eccValidazione = new Eccezione(ErroriCooperazione.AZIONE_NON_VALIDA.
  501.                                 getErroreCooperazione(msgErrore),
  502.                                 true,null,protocolFactory);
  503.                         this.log.error(msgErrore);
  504.                         return eccValidazione;
  505.                     }
  506.                 }
  507.             }

  509.             return null;
  510.         }

  512.         else{
  513.             //CHECKME
  514.             return null;
  515.         }
  516.     }


  519.     /* ********  PROFILO ASINCRONO SIMMETRICO ******** */

  521.     /**
  522.      * Registrazione di una richiesta inviata.
  523.      * Viene mantenuto nella tabella asincrona una entry con ID_MESSAGGIO, OUTBOX, dataInvio(serve per la respedizione) 
  524.      * e ServizioCorrelato inserito nella richiesta.
  525.      * 
  526.      * @param id Identificativo della richiesta
  527.      * @param tipoServizioCorrelato Tipo del Servizio Correlato
  528.      * @param servizioCorrelato Servizio Correlato
  529.      * @param ricevutaApplicativa Indicazione sull'abilitazione di una ricevuta applicativa
  530.      */
  531.     public void asincronoSimmetrico_registraRichiestaInviata(String id,String idCollaborazione,
  532.             String tipoServizioCorrelato,String servizioCorrelato,Integer versioneServizioCorrelato,
  533.             boolean ricevutaApplicativa,Integrazione integrazione,
  534.             long scadenzaMessaggi) throws ProtocolException{
  535.         
  536.         StateMessage state = (StateMessage)this.state;
  537.         Connection connectionDB = state.getConnectionDB();

  539.         PreparedStatement pstmt = null;
  540.         PreparedStatement pstmtUpdate = null;
  541.         try{    

  543.             java.sql.Timestamp oraInvio = DateManager.getTimestamp();

  545.             StringBuilder query = new StringBuilder();
  546.             query.append("INSERT INTO  ");
  547.             query.append(Costanti.PROFILO_ASINCRONO);
  548.             query.append(" (ID_MESSAGGIO,TIPO,ORA_REGISTRAZIONE,RICEVUTA_ASINCRONA,TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO");
  549.             query.append(",IS_RICHIESTA,ID_ASINCRONO,ID_COLLABORAZIONE,RICEVUTA_APPLICATIVA) ");
  550.             query.append(" VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )");

  552.             pstmt = connectionDB.prepareStatement(query.toString());
  553.             int index = 1;
  554.             pstmt.setString(index++,id);
  555.             pstmt.setString(index++,Costanti.OUTBOX);
  556.             pstmt.setTimestamp(index++,oraInvio);
  557.             pstmt.setInt(index++,0); // stato ricevuta: attesa
  558.             pstmt.setString(index++,tipoServizioCorrelato);
  559.             pstmt.setString(index++,servizioCorrelato);
  560.             if(versioneServizioCorrelato!=null){
  561.                 pstmt.setInt(index++,versioneServizioCorrelato);
  562.             }
  563.             else{
  564.                 pstmt.setNull(index++, java.sql.Types.INTEGER);
  565.             }
  566.             pstmt.setInt(index++,1); // is richiesta
  567.             pstmt.setString(index++,id); // idasincrono utilizzato per identificare questa instanza di cooperazione asincrona
  568.             pstmt.setString(index++,idCollaborazione); // idcollaborazione
  569.             if(ricevutaApplicativa){
  570.                 pstmt.setInt(index++,1); // ricevuta applicativa abilitata
  571.             }else{
  572.                 pstmt.setInt(index++,0); // ricevuta applicativa non abilitata
  573.             }

  575.             //  Add PreparedStatement
  576.             state.getPreparedStatement().put("INSERT save_RichiestaAsincronaSimmetricaInviata"+id,pstmt);

  578.             if(this.state instanceof StatefulMessage) {
  579.                 
  580.                 // salvo busta per profilo
  581.                 this.registraBustaInviata(id);
  582.                 
  583.             }else{
  584.                 
  585.                 StatelessMessage statelessMessage = (StatelessMessage) this.state;
  586.                 
  587.                 // Registro proprio la busta
  588.                 RepositoryBuste repository = new RepositoryBuste(this.state, this.log, true, this.protocolFactory);
  589.                 long scadenza = scadenzaMessaggi;
  590.                 if(scadenza<=0){
  591.                     scadenza = this.protocolManager.getIntervalloScadenzaBuste();
  592.                 }
  593.                 repository.registraBustaIntoOutBox(statelessMessage.getBusta(),scadenza);
  594.                 repository.aggiornaInfoIntegrazioneIntoOutBox(id,integrazione);
  595.                 this.registraBustaInviata(id);
  596.                 
  597.                 // salvo busta per profilo
  598.                 StringBuilder queryUpdate = new StringBuilder();
  599.                 queryUpdate.append("UPDATE ");
  600.                 queryUpdate.append(Costanti.REPOSITORY);
  601.                 queryUpdate.append(" SET ");
  602.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  603.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  604.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  605.                 pstmtUpdate.setString(1,id);
  606.                 pstmtUpdate.setString(2,Costanti.OUTBOX);

  608.                 // Add PreparedStatement
  609.                 state.getPreparedStatement().put("UPDATE saveBustaForProfilo"+Costanti.OUTBOX+"_"+id,pstmtUpdate);
  610.             }

  612.         } catch(Exception e) {
  613.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore di registrazione richiesta inviata "+id+": "+e.getMessage();       
  614.             this.log.error(errorMsg,e);
  615.             try{
  616.                 if( pstmt != null )
  617.                     pstmt.close();
  618.             } catch(Exception er) {
  619.                 // Eccezione SQL.
  620.             }
  621.             try{
  622.                 if( pstmtUpdate != null )
  623.                     pstmtUpdate.close();
  624.             } catch(Exception er) {
  625.                 // Eccezione SQL.
  626.             }
  627.             throw new ProtocolException(errorMsg,e);
  628.         }
  629.     }

  631.     /**
  632.      * Controlla se e' stato precedentemente registrata una richiesta asincrona simmetrica,
  633.      * ritornando eventuali dati dell'integrazione per la consegna della risposta.
  634.      *
  635.      * @param riferimentoMessaggio RiferimentoMessaggio
  636.      * @return Dati di integrazione per la consegna della risposta
  637.      * 
  638.      */
  639.     public Integrazione asincronoSimmetrico_getDatiConsegnaRisposta(String riferimentoMessaggio) throws ProtocolException{
  640.         StateMessage state = (StateMessage)this.state;
  641.         try{    
  642.             // I dati asincroni saranno eliminati quando scadra' la busta asincrona
  643.             History history = new History(state,this.log);
  644.             history.registraBustaInviata(riferimentoMessaggio);

  646.             // Prendo i dati di integrazione
  647.             RepositoryBuste repositoryBuste = new RepositoryBuste(state,  this.log, this.protocolFactory);
  648.             Integrazione integrazione = repositoryBuste.getInfoIntegrazioneFromOutBox(riferimentoMessaggio);
  649.             if(integrazione==null)
  650.                 throw new Exception("Dati di integrazione non trovati");
  651.             else
  652.                 return integrazione;

  654.         } catch(Exception e) {
  655.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore durante la asincronoSimmetrico_getDatiConsegnaRisposta "+riferimentoMessaggio+": "+e.getMessage();     
  656.             this.log.error(errorMsg,e);
  657.             throw new ProtocolException(errorMsg,e);
  658.         }
  659.     }

  661.     /**
  662.      * Controlla se e' stato precedentemente registrata una richiesta asincrona simmetrica,
  663.      * ritornando eventuali dati dell'integrazione per la consegna della ricevuta.
  664.      *
  665.      * @return Dati di integrazione per la consegna della risposta
  666.      * 
  667.      */
  668.     public Integrazione asincronoSimmetrico_getDatiConsegnaRicevuta(String riferimentoMessaggio) throws ProtocolException{
  669.         StateMessage state = (StateMessage)this.state;
  670.         try{    
  671.             // Prendo i dati di integrazione
  672.             RepositoryBuste repositoryBuste = new RepositoryBuste(state,  this.log, this.protocolFactory);
  673.             Integrazione integrazione = repositoryBuste.getInfoIntegrazioneFromOutBox(riferimentoMessaggio);
  674.             if(integrazione==null)
  675.                 throw new Exception("Dati di integrazione non trovati");
  676.             else
  677.                 return integrazione;

  679.         } catch(Exception e) {
  680.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore durante la asincronoSimmetrico_getDatiConsegnaRicevuta "+riferimentoMessaggio+": "+e.getMessage();     
  681.             this.log.error(errorMsg,e);
  682.             throw new ProtocolException(errorMsg,e);
  683.         }

  685.     }

  687.     /**
  688.      * Registrazione di una richiesta ricevuta.
  689.      * Viene mantenuto nella tabella asincrona una entry con ID_MESSAGGIO, INBOX 
  690.      * e ServizioCorrelato inserito nella richiesta.
  691.      * 
  692.      * @param id Identificativo della richiesta
  693.      * @param tipoServizioCorrelato Tipo del Servizio Correlato
  694.      * @param servizioCorrelato Servizio Correlato
  695.      * @param ricevutaApplicativa Indicazione sull'abilitazione di una ricevuta applicativa
  696.      */
  697.     public void asincronoSimmetrico_registraRichiestaRicevuta(String id,String idCollaborazione, 
  698.             String tipoServizioCorrelato,String servizioCorrelato, Integer versioneServizioCorrelato,
  699.             boolean ricevutaApplicativa,long scadenzaMessaggi)throws ProtocolException{
  700.         StateMessage state = (StateMessage)this.state;
  701.         Connection connectionDB = state.getConnectionDB();
  702.         PreparedStatement pstmt = null;
  703.         PreparedStatement pstmtUpdate = null;
  704.         ResultSet rs = null;
  705.         try{    

  707.             java.sql.Timestamp oraRicezione = DateManager.getTimestamp();

  709.             StringBuilder querySearch = new StringBuilder();
  710.             querySearch.append("SELECT ID_MESSAGGIO FROM ");
  711.             querySearch.append(Costanti.PROFILO_ASINCRONO);
  712.             querySearch.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  713.             pstmt = connectionDB.prepareStatement(querySearch.toString());
  714.             pstmt.setString(1,id);
  715.             pstmt.setString(2,Costanti.INBOX);
  716.             rs = pstmt.executeQuery();
  717.             boolean exists = rs.next();
  718.             rs.close();
  719.             pstmt.close();

  721.             StringBuilder query = new StringBuilder();
  722.             if(exists){
  723.                 query.append("UPDATE ");
  724.                 query.append(Costanti.PROFILO_ASINCRONO);
  725.                 query.append(" SET ID_MESSAGGIO=?,TIPO=?,ORA_REGISTRAZIONE=?,RICEVUTA_ASINCRONA=?,TIPO_SERVIZIO_CORRELATO=?,SERVIZIO_CORRELATO=?,VERSIONE_SERVIZIO_CORRELATO=?," +
  726.                 "IS_RICHIESTA=?,ID_ASINCRONO=?,ID_COLLABORAZIONE=?,RICEVUTA_APPLICATIVA=? WHERE ID_MESSAGGIO=? AND TIPO=?");
  727.             }else{
  728.                 query.append("INSERT INTO  ");
  729.                 query.append(Costanti.PROFILO_ASINCRONO);
  730.                 query.append(" (ID_MESSAGGIO,TIPO,ORA_REGISTRAZIONE,RICEVUTA_ASINCRONA,TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO");
  731.                 query.append(",IS_RICHIESTA,ID_ASINCRONO,ID_COLLABORAZIONE,RICEVUTA_APPLICATIVA) ");
  732.                 query.append(" VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )");
  733.             }


  736.             pstmt = connectionDB.prepareStatement(query.toString());
  737.             int index = 1;
  738.             pstmt.setString(index++,id);
  739.             pstmt.setString(index++,Costanti.INBOX);
  740.             pstmt.setTimestamp(index++,oraRicezione);
  741.             pstmt.setInt(index++,1); // stato ricevuta: non attesa
  742.             pstmt.setString(index++,tipoServizioCorrelato);
  743.             pstmt.setString(index++,servizioCorrelato);
  744.             if(versioneServizioCorrelato!=null){
  745.                 pstmt.setInt(index++,versioneServizioCorrelato);
  746.             }
  747.             else{
  748.                 pstmt.setNull(index++, java.sql.Types.INTEGER);
  749.             }
  750.             pstmt.setInt(index++,1); // is richiesta
  751.             pstmt.setString(index++,id); // idasincrono utilizzato per identificare questa instanza di cooperazione asincrona
  752.             pstmt.setString(index++,idCollaborazione); // idCollaborazione
  753.             if(ricevutaApplicativa){
  754.                 pstmt.setInt(index++,1); // ricevuta applicativa abilitata
  755.             }else{
  756.                 pstmt.setInt(index++,0); // ricevuta applicativa non abilitata
  757.             }
  758.             if(exists){
  759.                 pstmt.setString(index++,id);
  760.                 pstmt.setString(index++,Costanti.INBOX);
  761.             }

  763.             //  Add PreparedStatement
  764.             if(exists){
  765.                 state.getPreparedStatement().put("UPDATE save_RichiestaAsincronaSimmetricaRicevuta"+id,pstmt);
  766.             }else{
  767.                 state.getPreparedStatement().put("INSERT save_RichiestaAsincronaSimmetricaRicevuta"+id,pstmt);
  768.             }

  770.             
  771.             if(this.state instanceof StatefulMessage) {
  772.                 
  773.                 // salvo busta per profilo
  774.                 this.registraBustaRicevuta(id);
  775.                 
  776.             }else{
  777.                 
  778.                 StatelessMessage statelessMessage = (StatelessMessage) this.state;
  779.                 
  780.                 long scadenza = scadenzaMessaggi;
  781.                 if(scadenza<=0){
  782.                     scadenza = this.protocolManager.getIntervalloScadenzaBuste();
  783.                 }
  784.                 
  785.                 // Registro proprio la busta
  786.                 RepositoryBuste repository = new RepositoryBuste(this.state,  this.log, true, this.protocolFactory);
  787.                 String key = "INSERT RegistrazioneBustaForHistory" + Costanti.INBOX + "_" + statelessMessage.getBusta().getID();
  788.                 if(repository.isRegistrataIntoInBox(statelessMessage.getBusta().getID())){
  789.                     repository.aggiornaBustaIntoInBox(statelessMessage.getBusta(),
  790.                             scadenza);
  791.                 }else if(state.getPreparedStatement().containsKey(key)){
  792.                     repository.aggiornaBustaIntoInBox(statelessMessage.getBusta(),
  793.                             scadenza);
  794.                 }else{
  795.                     repository.registraBustaIntoInBox(statelessMessage.getBusta(),
  796.                             scadenza);
  797.                 }
  798.                 this.registraBustaRicevuta(id);
  799.                 
  800.                 
  801.                 // salvo busta per profilo
  802.                 StringBuilder queryUpdate = new StringBuilder();
  803.                 queryUpdate.append("UPDATE ");
  804.                 queryUpdate.append(Costanti.REPOSITORY);
  805.                 queryUpdate.append(" SET ");
  806.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  807.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  808.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  809.                 pstmtUpdate.setString(1,id);
  810.                 pstmtUpdate.setString(2,Costanti.INBOX);

  812.                 // Add PreparedStatement
  813.                 state.getPreparedStatement().put("UPDATE saveBustaForProfilo" + Costanti.INBOX + "_" + id,pstmtUpdate);
  814.             }
  815.             
  816.             

  818.         } catch(Exception e) {
  819.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore di registrazione richiesta ricevuta " + id + ": " + e.getMessage();        
  820.             this.log.error(errorMsg,e);
  821.             try{
  822.                 if( rs != null )
  823.                     rs.close();
  824.             } catch(Exception er) {
  825.                 // Eccezione SQL.
  826.             }
  827.             try{
  828.                 if( pstmt != null )
  829.                     pstmt.close();
  830.             } catch(Exception er) {
  831.                 // Eccezione SQL.
  832.             }
  833.             try{
  834.                 if( pstmtUpdate != null )
  835.                     pstmtUpdate.close();
  836.             } catch(Exception er) {
  837.                 // Eccezione SQL.
  838.             }
  839.             throw new ProtocolException(errorMsg,e);
  840.         }
  841.     }

  843.     /**
  844.      * Controlla se e' stato precedentemente registrata una richiesta asincrona simmetrica,
  845.      * ritornando eventuale busta da usare con la risposta applicativa.
  846.      *
  847.      * @param id Identificativo della richiesta.
  848.      * @param idRisposta Identificativo della risposta.
  849.      * @return Dati di integrazione per la consegna della risposta
  850.      * 
  851.      */
  852.     public Busta asincronoSimmetrico_getBustaRisposta(String id, String idRisposta, long scadenzaMessaggi) throws ProtocolException{
  853.         
  854.         StateMessage state = (StateMessage)this.state;
  855.         Connection connectionDB = state.getConnectionDB();
  856.         // getBustaRicevuta
  857.         Busta busta = null;
  858.         try{
  859.             RepositoryBuste repository = new RepositoryBuste(state,  this.log, this.protocolFactory);
  860.             // exists: controlla anche il marcatore logico, per vedere che la busta cmq non sia eliminata
  861.             if(repository.exists(id, Costanti.INBOX)){
  862.                 LetturaParametriBusta parametri = new LetturaParametriBusta();
  863.                 parametri.setMittente(true);
  864.                 parametri.setDestinatario(true);
  865.                 parametri.setServizioCorrelato(true);
  866.                 busta = repository.getSomeValuesFromInBox(id, parametri ,true); // Ultimo parametro forza la lettura su database
  867.             }else{
  868.                 throw new Exception("Busta non trovata");
  869.             }
  870.         }catch(Exception e){
  871.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore durante la getBusta dal repository "+id+": "+e.getMessage();       
  872.             this.log.error(errorMsg,e);
  873.             throw new ProtocolException(errorMsg,e);
  874.         }

  876.         // ProfiloDiCollaborazione
  877.         busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);

  879.         // check eventuali spedizione-risposta precedentemente effettuate
  880.         PreparedStatement pstmtCheck = null;
  881.         ResultSet rsCheck = null;
  882.         String oldIDRisposta = null;
  883.         String oldTipoRisposta = null;
  884.         try{
  885.             StringBuilder query = new StringBuilder();
  886.             query.append("SELECT ID_MESSAGGIO,TIPO FROM ");
  887.             query.append(Costanti.PROFILO_ASINCRONO);
  888.             query.append(" WHERE BACKUP_ID_RICHIESTA=?");

  890.             pstmtCheck = connectionDB.prepareStatement(query.toString());
  891.             pstmtCheck.setString(1,id);
  892.             rsCheck = pstmtCheck.executeQuery();        
  893.             if(rsCheck == null) {
  894.                 throw new ProtocolException("RS Check Null?");          
  895.             }
  896.             if(rsCheck.next()){
  897.                 oldIDRisposta = rsCheck.getString("ID_MESSAGGIO");
  898.                 oldTipoRisposta = rsCheck.getString("TIPO");
  899.             }       
  900.             rsCheck.close();
  901.             pstmtCheck.close();

  903.         }catch(Exception e){    
  904.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, asincronoSimmetrico_getBustaRisposta "+id+": "+e.getMessage();
  905.             this.log.error(errorMsg,e);
  906.             try{
  907.                 if( rsCheck != null )
  908.                     rsCheck.close();
  909.             } catch(Exception er) {
  910.                 // Eccezione SQL.
  911.             }
  912.             try{
  913.                 if( pstmtCheck != null )
  914.                     pstmtCheck.close();
  915.             } catch(Exception er) {
  916.                 // Eccezione SQL.
  917.             }
  918.             throw new ProtocolException(errorMsg,e);
  919.         }

  921.         // Imposto parametri per la consegna della risposta
  922.         PreparedStatement pstmt = null;
  923.         try{    

  925.             java.sql.Timestamp oraInvioRisposta = DateManager.getTimestamp();

  927.             StringBuilder query = new StringBuilder();
  928.             query.append("UPDATE ");
  929.             query.append(Costanti.PROFILO_ASINCRONO);
  930.             query.append(" SET IS_RICHIESTA=0, RICEVUTA_ASINCRONA=0, ORA_REGISTRAZIONE=?, ID_MESSAGGIO=?, TIPO=?, BACKUP_ID_RICHIESTA=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");

  932.             pstmt = connectionDB.prepareStatement(query.toString());
  933.             pstmt.setTimestamp(1,oraInvioRisposta);
  934.             pstmt.setString(2,idRisposta);
  935.             pstmt.setString(3,Costanti.OUTBOX);
  936.             pstmt.setString(4,id);
  937.             if(oldIDRisposta!=null && oldTipoRisposta!=null){
  938.                 pstmt.setString(5,oldIDRisposta);
  939.                 pstmt.setString(6,oldTipoRisposta);
  940.             }else{
  941.                 pstmt.setString(5,id);
  942.                 pstmt.setString(6,Costanti.INBOX);
  943.             }

  945.             //  Add PreparedStatement
  946.             state.getPreparedStatement().put("UPDATE save_RispostaAsincronaSimmetricaInviata"+id,pstmt);

  948.         } catch(Exception e) {
  949.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore di registrazione risposta inviata "+id+": "+e.getMessage();        
  950.             this.log.error(errorMsg,e);
  951.             try{
  952.                 if( pstmt != null )
  953.                     pstmt.close();
  954.             } catch(Exception er) {
  955.                 // Eccezione SQL.
  956.             }
  957.             throw new ProtocolException(errorMsg,e);
  958.         }

  960.         // Imposto tipo e nome servizio correlato
  961.         if(busta.getTipoServizioCorrelato()==null || busta.getServizioCorrelato()==null){
  962.             PreparedStatement pstmtServizioCorrelato = null;
  963.             ResultSet rsServizioCorrelato = null;
  964.             String tipoSC = null;
  965.             String nomeSC = null;
  966.             Integer versioneSC = null;
  967.             try{
  968.                 StringBuilder query = new StringBuilder();
  969.                 query.append("SELECT TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO FROM ");
  970.                 query.append(Costanti.PROFILO_ASINCRONO);
  971.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");

  973.                 pstmtServizioCorrelato = connectionDB.prepareStatement(query.toString());
  974.                 if(oldIDRisposta!=null && oldTipoRisposta!=null){
  975.                     pstmtServizioCorrelato.setString(1,oldIDRisposta);
  976.                     pstmtServizioCorrelato.setString(2,oldTipoRisposta);
  977.                 }else{
  978.                     pstmtServizioCorrelato.setString(1,id);
  979.                     pstmtServizioCorrelato.setString(2,Costanti.INBOX);
  980.                 }
  981.                 rsServizioCorrelato = pstmtServizioCorrelato.executeQuery();        
  982.                 if(rsServizioCorrelato == null) {
  983.                     throw new ProtocolException("RS Check Null?");          
  984.                 }
  985.                 if(rsServizioCorrelato.next()){
  986.                     tipoSC = rsServizioCorrelato.getString("TIPO_SERVIZIO_CORRELATO");
  987.                     nomeSC = rsServizioCorrelato.getString("SERVIZIO_CORRELATO");
  988.                     versioneSC = rsServizioCorrelato.getInt("VERSIONE_SERVIZIO_CORRELATO");
  989.                     if(rsServizioCorrelato.wasNull()){
  990.                         versioneSC = null;
  991.                     }
  992.                 }       
  993.                 rsServizioCorrelato.close();
  994.                 pstmtServizioCorrelato.close();

  996.                 if(tipoSC==null || nomeSC==null || versioneSC==null)
  997.                     throw new Exception("Tipo/Nome/Versione servizio correlato non trovato");

  999.             }catch(Exception e){    
  1000.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, asincronoSimmetrico_getBustaRisposta "+id+": "+e.getMessage();
  1001.                 this.log.error(errorMsg,e);
  1002.                 try{
  1003.                     if( rsServizioCorrelato != null )
  1004.                         rsServizioCorrelato.close();
  1005.                 } catch(Exception er) {
  1006.                     // Eccezione SQL.
  1007.                 }
  1008.                 try{
  1009.                     if( pstmtServizioCorrelato != null )
  1010.                         pstmtServizioCorrelato.close();
  1011.                 } catch(Exception er) {
  1012.                     // Eccezione SQL.
  1013.                 }
  1014.                 throw new ProtocolException(errorMsg,e);
  1015.             }
  1016.             busta.setTipoServizioCorrelato(tipoSC);
  1017.             busta.setServizioCorrelato(nomeSC);
  1018.             busta.setVersioneServizioCorrelato(versioneSC);
  1019.         }

  1021.         if(this.state instanceof StatefulMessage) {
  1022.         
  1023.             // Registro la busta con il nuovo id
  1024.             this.registraBustaInviata(idRisposta);
  1025.             
  1026.         }else{
  1027.         
  1028.             PreparedStatement pstmtUpdate = null;
  1029.             try{
  1030.             
  1031.                 StatelessMessage statelessMessage = (StatelessMessage) this.state;
  1032.                 
  1033.                 // Registro proprio la busta
  1034.                 RepositoryBuste repository = new RepositoryBuste(this.state,  this.log, true, this.protocolFactory);
  1035.                 long scadenza = scadenzaMessaggi;
  1036.                 if(scadenza<=0){
  1037.                     scadenza = this.protocolManager.getIntervalloScadenzaBuste();
  1038.                 }
  1039.                 repository.registraBustaIntoOutBox(statelessMessage.getBusta(),scadenza);
  1040.                 this.registraBustaInviata(idRisposta);
  1041.                 
  1042.                 // salvo busta per profilo
  1043.                 StringBuilder queryUpdate = new StringBuilder();
  1044.                 queryUpdate.append("UPDATE ");
  1045.                 queryUpdate.append(Costanti.REPOSITORY);
  1046.                 queryUpdate.append(" SET ");
  1047.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  1048.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1049.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  1050.                 pstmtUpdate.setString(1,idRisposta);
  1051.                 pstmtUpdate.setString(2,Costanti.OUTBOX);
  1052.     
  1053.                 // Add PreparedStatement
  1054.                 state.getPreparedStatement().put("UPDATE saveBustaForProfilo"+Costanti.OUTBOX+"_"+idRisposta,pstmtUpdate);
  1055.             
  1056.             } catch(Exception e) {
  1057.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore di aggiornamento busta di risposta "+idRisposta+": "+e.getMessage();       
  1058.                 this.log.error(errorMsg,e);
  1059.                 try{
  1060.                     if( pstmtUpdate != null )
  1061.                         pstmtUpdate.close();
  1062.                 } catch(Exception er) {
  1063.                     // Eccezione SQL.
  1064.                 }
  1065.                 throw new ProtocolException(errorMsg,e);
  1066.             }
  1067.             
  1068.         }

  1070.         //  delete vecchia risposta
  1071.         if(oldIDRisposta!=null && oldTipoRisposta!=null){
  1072.             this.eliminaBusta(oldIDRisposta,oldTipoRisposta,true);
  1073.         }

  1075.         return busta;
  1076.     }

  1078.     /**
  1079.      * Controlla se e' stato precedentemente registrata una richiesta asincrona simmetrica,
  1080.      * ritornando eventuale busta da usare con la ricevuta applicativa.
  1081.      *
  1082.      * @param id Identificativo della richiesta asincrona.
  1083.      * @param rifMsgRicevuta Riferimento Messaggio da applicare alla ricevuta.
  1084.      * @param isRichiesta Indicazione se si desidera la busta per una ricevuta ad una richiesta o risposta
  1085.      * @return Busta da utilizzare per la ricevuta
  1086.      * 
  1087.      */
  1088.     public Busta asincronoSimmetrico_getBustaRicevuta(String id,String rifMsgRicevuta,boolean isRichiesta,TipoOraRegistrazione tipoTempo) throws ProtocolException{
  1089.         StateMessage state = (StateMessage)this.state;
  1090.         Connection connectionDB = state.getConnectionDB();
  1091.         Busta busta = null;
  1092.         try{
  1093.             RepositoryBuste repository = new RepositoryBuste(state,  this.log, this.protocolFactory);
  1094.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  1095.             parametri.setMittente(true);
  1096.             parametri.setDestinatario(true);
  1097.             parametri.setServizio(true);
  1098.             parametri.setServizioCorrelato(true);
  1099.             parametri.setAzione(true);
  1100.             parametri.setCollaborazione(true);
  1101.             parametri.setProfiloTrasmissione(true);
  1102.             parametri.setIndirizziTelematici(this.protocolConfiguration.isSupportoIndirizzoRisposta());

  1104.             if(isRichiesta){
  1105.                 busta = repository.getSomeValuesFromInBox(id, parametri,true); // devo leggere i valori dal database
  1106.             }else{
  1107.                 busta = repository.getSomeValuesFromOutBox(id, parametri,true); // devo leggere i valori dal database

  1109.                 // elimino busta per profilo
  1110.                 this.eliminaBustaInviata(id,true);
  1111.             }

  1113.             // costruzione busta di risposta 

  1115.             // ProfiloDiCollaborazione
  1116.             busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);

  1118.             // inverto mitt con dest solo se e' una ricevuta alla richiesta
  1119.             if(isRichiesta){
  1120.                 String mitt = busta.getMittente();
  1121.                 String tipoMitt = busta.getTipoMittente();
  1122.                 String portaMitt = busta.getIdentificativoPortaMittente();
  1123.                 String indMitt = busta.getIndirizzoMittente();
  1124.                 busta.setMittente(busta.getDestinatario());
  1125.                 busta.setTipoMittente(busta.getTipoDestinatario());
  1126.                 busta.setIdentificativoPortaMittente(busta.getIdentificativoPortaDestinatario());
  1127.                 busta.setIndirizzoMittente(busta.getIndirizzoDestinatario());
  1128.                 busta.setDestinatario(mitt);
  1129.                 busta.setTipoDestinatario(tipoMitt);
  1130.                 busta.setIdentificativoPortaDestinatario(portaMitt);
  1131.                 busta.setIndirizzoDestinatario(indMitt);
  1132.             }

  1134.             if(isRichiesta == false){

  1136.                 String tipoServizioCorrelato = busta.getTipoServizioCorrelato();
  1137.                 String servizioCorrelato = busta.getServizioCorrelato();
  1138.                 Integer versioneServizioCorrelato = busta.getVersioneServizioCorrelato();

  1140.                 if(tipoServizioCorrelato==null || servizioCorrelato==null || versioneServizioCorrelato==null){
  1141.                     StringBuilder query = new StringBuilder();
  1142.                     query.append("SELECT TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO FROM ");
  1143.                     query.append(Costanti.PROFILO_ASINCRONO);
  1144.                     query.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  1145.                     PreparedStatement pstmtServizioCorrelato = null;
  1146.                     ResultSet rsServizioCorrelato = null;
  1147.                     try {
  1148.                         pstmtServizioCorrelato = connectionDB.prepareStatement(query.toString());
  1149.                         pstmtServizioCorrelato.setString(1,id);
  1150.                         pstmtServizioCorrelato.setString(2,Costanti.OUTBOX);
  1151.                         rsServizioCorrelato = pstmtServizioCorrelato.executeQuery();        
  1152. //                      if(rsServizioCorrelato == null) {
  1153. //                          throw new ProtocolException("RS Check Null?");          
  1154. //                      }
  1155.                         if(rsServizioCorrelato.next()){
  1156.                             tipoServizioCorrelato = rsServizioCorrelato.getString("TIPO_SERVIZIO_CORRELATO");
  1157.                             servizioCorrelato = rsServizioCorrelato.getString("SERVIZIO_CORRELATO");
  1158.                             versioneServizioCorrelato = rsServizioCorrelato.getInt("VERSIONE_SERVIZIO_CORRELATO");
  1159.                             if(rsServizioCorrelato.wasNull()){
  1160.                                 versioneServizioCorrelato = null;
  1161.                             }
  1162.                         }       
  1163.                         if(tipoServizioCorrelato==null || servizioCorrelato==null || versioneServizioCorrelato==null)
  1164.                             throw new Exception("Tipo/Nome/Versione servizio correlato non trovato");

  1166.                     }catch(Exception e){
  1167.                         throw new Exception("Lettura Servizio correlato non riuscita "+e.getMessage(),e );
  1168.                     }
  1169.                     finally {
  1170.                         try {
  1171.                             if(rsServizioCorrelato!=null) {
  1172.                                 rsServizioCorrelato.close();
  1173.                             }
  1174.                         }catch(Throwable e){
  1175.                             // ignore
  1176.                         }
  1177.                         try {
  1178.                             if(pstmtServizioCorrelato!=null) {
  1179.                                 pstmtServizioCorrelato.close();
  1180.                             }
  1181.                         }catch(Throwable e){
  1182.                             // ignore
  1183.                         }
  1184.                     }
  1185.                 }

  1187.                 busta.setTipoServizio(tipoServizioCorrelato);
  1188.                 busta.setServizio(servizioCorrelato);
  1189.             }

  1191.             busta.setRiferimentoMessaggio(rifMsgRicevuta);
  1192.             busta.setOraRegistrazione(DateManager.getDate());
  1193.             busta.setTipoOraRegistrazione(tipoTempo,this.protocolTraduttore.toString(tipoTempo));

  1195.             busta.setTipoServizioCorrelato(null);
  1196.             busta.setServizioCorrelato(null);

  1198.         }catch(Exception e){
  1199.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore durante la asincronoSimmetrico_getBustaRicevuta dal repository "+id+": "+e.getMessage();       
  1200.             this.log.error(errorMsg,e);
  1201.             throw new ProtocolException(errorMsg,e);
  1202.         }
  1203.         return busta;
  1204.     }

  1206.     /**
  1207.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona simmetrica.
  1208.      *
  1209.      * @param bustaDaValidare Busta da controllare
  1210.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  1211.      * 
  1212.      */
  1213.     public Eccezione asincronoSimmetrico_validazioneCorrelazione_ricevutaRichiesta(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  1214.         return asincronoSimmetrico_validazioneCorrelazione(bustaDaValidare,true,false,false,protocolFactory);
  1215.     }
  1216.     /**
  1217.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona simmetrica.
  1218.      *
  1219.      * @param bustaDaValidare Busta da controllare
  1220.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  1221.      * 
  1222.      */
  1223.     public Eccezione asincronoSimmetrico_validazioneCorrelazione_risposta(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  1224.         return asincronoSimmetrico_validazioneCorrelazione(bustaDaValidare,false,true,false,protocolFactory);
  1225.     }
  1226.     /**
  1227.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona simmetrica.
  1228.      *
  1229.      * @param bustaDaValidare Busta da controllare
  1230.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  1231.      * 
  1232.      */
  1233.     public Eccezione asincronoSimmetrico_validazioneCorrelazione_ricevutaRisposta(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  1234.         return asincronoSimmetrico_validazioneCorrelazione(bustaDaValidare,false,false,true,protocolFactory);
  1235.     }
  1236.     /**
  1237.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona simmetrica.
  1238.      *
  1239.      * @param bustaDaValidare Busta da controllare
  1240.      * @param isRicevutaRichiesta Ricevuta della Richiesta
  1241.      * @param isRisposta Risposta
  1242.      * @param isRicevutaRisposta Ricevuta della Risposta
  1243.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  1244.      * 
  1245.      */
  1246.     private Eccezione asincronoSimmetrico_validazioneCorrelazione(Busta bustaDaValidare,boolean isRicevutaRichiesta,boolean isRisposta,
  1247.             boolean isRicevutaRisposta, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  1248.         StateMessage state = (StateMessage)this.state;
  1249.         Connection connectionDB = state.getConnectionDB();
  1250.         Busta bustaRichiesta = null;
  1251.         try{
  1252.             RepositoryBuste repository = new RepositoryBuste(state,  this.log, this.protocolFactory);
  1253.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  1254.             parametri.setMittente(true);
  1255.             parametri.setDestinatario(true);
  1256.             parametri.setServizio(true);
  1257.             parametri.setAzione(true);

  1259.             // NOTA:
  1260.             //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  1261.             if(isRisposta && bustaDaValidare.getRiferimentoMessaggio()==null)
  1262.                 bustaRichiesta = repository.getSomeValuesFromOutBox(bustaDaValidare.getCollaborazione(), parametri, true); // deve leggere sempre da database
  1263.             else
  1264.                 bustaRichiesta = repository.getSomeValuesFromOutBox(bustaDaValidare.getRiferimentoMessaggio(), parametri, true); // deve leggere sempre da database

  1266.         }catch(Exception e){
  1267.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, Errore durante la validazioneCorrelazione, get dal repository "+bustaDaValidare.getRiferimentoMessaggio()+": "+e.getMessage();        
  1268.             this.log.error(errorMsg,e);
  1269.             throw new ProtocolException(errorMsg,e);
  1270.         }

  1272.         // Validazione Servizio (Tipo e Nome)
  1273.         // Obbligatoria per una risposta, opzionale per una ricevuta
  1274.         if( isRicevutaRichiesta ){
  1275.             if(bustaDaValidare.getServizio()!=null && bustaDaValidare.getTipoServizio()!=null){
  1276.                 if (bustaRichiesta.getTipoServizio().equals(bustaDaValidare.getTipoServizio())==false){
  1277.                     String msgErrore = "Tipo del servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1278.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.
  1279.                             getErroreCooperazione(msgErrore),
  1280.                             true,null,protocolFactory);
  1281.                     this.log.error(msgErrore);
  1282.                     return eccValidazione;
  1283.                 }
  1284.                 if (bustaRichiesta.getServizio().equals(bustaDaValidare.getServizio())==false){
  1285.                     String msgErrore = "Servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1286.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.SERVIZIO_NON_VALIDO.
  1287.                             getErroreCooperazione(msgErrore),
  1288.                             true,null,protocolFactory);
  1289.                     this.log.error(msgErrore);
  1290.                     return eccValidazione;
  1291.                 }
  1292.             }
  1293.         }
  1294.         else if(  (isRisposta) || (isRicevutaRisposta && bustaDaValidare.getServizio()!=null && bustaDaValidare.getTipoServizio()!=null) ) {
  1295.             PreparedStatement pstmt = null;
  1296.             ResultSet rs = null;
  1297.             try{
  1298.                 StringBuilder query = new StringBuilder();
  1299.                 query.append("SELECT TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO FROM ");
  1300.                 query.append(Costanti.PROFILO_ASINCRONO);
  1301.                 query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  1303.                 pstmt = connectionDB.prepareStatement(query.toString());

  1305.                 // NOTA:
  1306.                 //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  1307.                 if(isRisposta && bustaDaValidare.getRiferimentoMessaggio()==null)
  1308.                     pstmt.setString(1,bustaDaValidare.getCollaborazione());
  1309.                 else
  1310.                     pstmt.setString(1,bustaDaValidare.getRiferimentoMessaggio());

  1312.                 pstmt.setString(2,Costanti.OUTBOX);
  1313.                 rs = pstmt.executeQuery();      
  1314.                 if(rs == null) {
  1315.                     throw new ProtocolException("RS Null?");            
  1316.                 }
  1317.                 String tipoServizioCorrelatoRegistrato = null;
  1318.                 String servizioCorrelatoRegistrato = null;
  1319.                 Integer versioneServizioCorrelatoRegistrato = null;
  1320.                 if(rs.next()){
  1321.                     tipoServizioCorrelatoRegistrato = rs.getString("TIPO_SERVIZIO_CORRELATO");
  1322.                     servizioCorrelatoRegistrato = rs.getString("SERVIZIO_CORRELATO");
  1323.                     versioneServizioCorrelatoRegistrato = rs.getInt("VERSIONE_SERVIZIO_CORRELATO");
  1324.                     if(rs.wasNull()){
  1325.                         versioneServizioCorrelatoRegistrato = null;
  1326.                     }
  1327.                 }

  1329.                 rs.close();
  1330.                 pstmt.close();

  1332.                 if (bustaDaValidare.getTipoServizio().equals(tipoServizioCorrelatoRegistrato) == false){
  1333.                     String msgErrore = "Tipo del servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1334.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.
  1335.                             getErroreCooperazione(msgErrore),
  1336.                             true,null,protocolFactory);
  1337.                     this.log.error(msgErrore);
  1338.                     return eccValidazione;
  1339.                 }
  1340.                 if (bustaDaValidare.getServizio().equals(servizioCorrelatoRegistrato) == false){
  1341.                     String msgErrore = "Servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1342.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.SERVIZIO_NON_VALIDO.
  1343.                             getErroreCooperazione(msgErrore),
  1344.                             true,null,protocolFactory);
  1345.                     this.log.error(msgErrore);
  1346.                     return eccValidazione;
  1347.                 }
  1348.                 if(versioneServizioCorrelatoRegistrato==null){
  1349.                     versioneServizioCorrelatoRegistrato = -1; // valore apposta errato
  1350.                 }
  1351.                 if (bustaDaValidare.getVersioneServizio().intValue() != versioneServizioCorrelatoRegistrato.intValue()){
  1352.                     String msgErrore = "Versione del servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1353.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.VERSIONE_SERVIZIO_NON_VALIDO.
  1354.                             getErroreCooperazione(msgErrore),
  1355.                             true,null,protocolFactory);
  1356.                     this.log.error(msgErrore);
  1357.                     return eccValidazione;
  1358.                 }

  1360.             }catch(Exception e){    
  1361.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, validazioneCorrelazioneRichiesta RifMsg("+bustaDaValidare.getRiferimentoMessaggio()+") Collab("+bustaDaValidare.getCollaborazione()+"): "+e.getMessage();
  1362.                 this.log.error(errorMsg);
  1363.                 try{
  1364.                     if( rs != null )
  1365.                         rs.close();
  1366.                 } catch(Exception er) {
  1367.                     // Eccezione SQL.
  1368.                 }
  1369.                 try{
  1370.                     if( pstmt != null )
  1371.                         pstmt.close();
  1372.                 } catch(Exception er) {
  1373.                     // Eccezione SQL.
  1374.                 }
  1375.                 throw new ProtocolException(errorMsg);
  1376.             }
  1377.         }

  1379.         // Validazione altri parametri busta
  1380.         // L'azione di una ricevuta deve essere la stessa di quella della richiesta/risposta
  1381.         if(bustaDaValidare.getAzione()!=null && isRisposta==false){
  1382.             if (bustaDaValidare.getAzione().equals(bustaRichiesta.getAzione()) == false){
  1383.                 String msgErrore = "Azione diverso da quello attesa nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1384.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.AZIONE_NON_VALIDA.
  1385.                         getErroreCooperazione(msgErrore),
  1386.                         true,null,protocolFactory);
  1387.                 this.log.error(msgErrore);
  1388.                 return eccValidazione;
  1389.             }
  1390.         }
  1391.         if (bustaRichiesta.getTipoDestinatario().equals(bustaDaValidare.getTipoMittente()) == false){
  1392.             String msgErrore = "Tipo del mittente diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1393.             Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.
  1394.                     getErroreCooperazione(msgErrore),
  1395.                     true,null,protocolFactory);
  1396.             this.log.error(msgErrore);
  1397.             return eccValidazione;
  1398.         }
  1399.         if (bustaRichiesta.getDestinatario().equals(bustaDaValidare.getMittente()) == false){
  1400.             String msgErrore = "Mittente diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1401.             Eccezione eccValidazione = new Eccezione(ErroriCooperazione.MITTENTE_NON_VALIDO.
  1402.                     getErroreCooperazione(msgErrore),
  1403.                     true,null,protocolFactory);
  1404.             this.log.error(msgErrore);
  1405.             return eccValidazione;
  1406.         }
  1407.         if (bustaRichiesta.getTipoMittente().equals(bustaDaValidare.getTipoDestinatario()) == false){
  1408.             String msgErrore = "Tipo del destinatario diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1409.             Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_DESTINATARIO_NON_VALIDO.
  1410.                     getErroreCooperazione(msgErrore),
  1411.                     true,null,protocolFactory);
  1412.             this.log.error(msgErrore);
  1413.             return eccValidazione;
  1414.         }
  1415.         if (bustaRichiesta.getMittente().equals(bustaDaValidare.getDestinatario()) == false){
  1416.             String msgErrore = "Destinatario diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Simmetrico";
  1417.             Eccezione eccValidazione = new Eccezione(ErroriCooperazione.DESTINATARIO_NON_VALIDO.
  1418.                     getErroreCooperazione(msgErrore),
  1419.                     true,null,protocolFactory);
  1420.             this.log.error(msgErrore);
  1421.             return eccValidazione;
  1422.         }

  1424.         return null;
  1425.     }

  1427.     /**
  1428.      * Validazione del riferimentoMessaggio di una busta asincrona simmetrica.
  1429.      *
  1430.      * @param riferimentoMessaggio Identificativo.
  1431.      * @return true se esiste una entry nella tabella apposita.
  1432.      * 
  1433.      */
  1434.     public boolean asincronoSimmetrico_validazioneRiferimentoMessaggio(String riferimentoMessaggio) throws ProtocolException{
  1435.         StateMessage state = (StateMessage)this.state;
  1436.         Connection connectionDB = state.getConnectionDB();
  1437.         PreparedStatement pstmt = null;
  1438.         ResultSet rs = null;
  1439.         try{
  1440.             StringBuilder query = new StringBuilder();
  1441.             query.append("SELECT ID_MESSAGGIO FROM ");
  1442.             query.append(Costanti.PROFILO_ASINCRONO);
  1443.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  1445.             pstmt = connectionDB.prepareStatement(query.toString());
  1446.             pstmt.setString(1,riferimentoMessaggio);
  1447.             pstmt.setString(2,Costanti.OUTBOX);
  1448.             rs = pstmt.executeQuery();      
  1449.             if(rs == null) {
  1450.                 throw new ProtocolException("RS Null?");            
  1451.             }
  1452.             boolean value = rs.next();

  1454.             rs.close();
  1455.             pstmt.close();

  1457.             RepositoryBuste repositoryBuste = new RepositoryBuste(state,  this.log, this.protocolFactory);
  1458.             return value && repositoryBuste.isRegistrataIntoOutBox(riferimentoMessaggio);

  1460.         }catch(Exception e){    
  1461.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, validazioneRiferimentoMessaggio "+riferimentoMessaggio+": "+e.getMessage();
  1462.             this.log.error(errorMsg);
  1463.             try{
  1464.                 if( rs != null )
  1465.                     rs.close();
  1466.             } catch(Exception er) {
  1467.                 // Eccezione SQL.
  1468.             }
  1469.             try{
  1470.                 if( pstmt != null )
  1471.                     pstmt.close();
  1472.             } catch(Exception er) {
  1473.                 // Eccezione SQL.
  1474.             }
  1475.             throw new ProtocolException(errorMsg,e);
  1476.         }
  1477.     }

  1479.     /**
  1480.      * Validazione della collaborazione di una busta asincrona.
  1481.      *
  1482.      * @param riferimentoMessaggio Identificativo.
  1483.      * @param idCollaborazione Collaborazione
  1484.      * @return true se la collaborazione e' valida
  1485.      * 
  1486.      */
  1487.     public boolean asincronoSimmetrico_validazioneCollaborazione_risposta(String riferimentoMessaggio,String idCollaborazione) throws ProtocolException{
  1488.         return asincronoSimmetrico_validazioneCollaborazione(riferimentoMessaggio,idCollaborazione,true);
  1489.     }

  1491.     /**
  1492.      * Validazione della collaborazione di una busta asincrona.
  1493.      *
  1494.      * @param riferimentoMessaggio Identificativo.
  1495.      * @param idCollaborazione Collaborazione
  1496.      * @return true se la collaborazione e' valida
  1497.      * 
  1498.      */
  1499.     public boolean asincronoSimmetrico_validazioneCollaborazione_ricevuta(String riferimentoMessaggio,String idCollaborazione) throws ProtocolException{
  1500.         return asincronoSimmetrico_validazioneCollaborazione(riferimentoMessaggio,idCollaborazione,false);
  1501.     }

  1503.     /**
  1504.      * Validazione della collaborazione di una busta asincrona.
  1505.      *
  1506.      * @param riferimentoMessaggio Identificativo.
  1507.      * @param idCollaborazione Collaborazione
  1508.      * @return true se la collaborazione e' valida
  1509.      * 
  1510.      */
  1511.     private boolean asincronoSimmetrico_validazioneCollaborazione(String riferimentoMessaggio,String idCollaborazione,boolean isRisposta) throws ProtocolException{
  1512.         StateMessage state = (StateMessage)this.state;
  1513.         Connection connectionDB = state.getConnectionDB();
  1514.         PreparedStatement pstmt = null;
  1515.         ResultSet rs = null;
  1516.         try{
  1517.             StringBuilder query = new StringBuilder();
  1518.             query.append("SELECT ID_COLLABORAZIONE FROM ");
  1519.             query.append(Costanti.PROFILO_ASINCRONO);
  1520.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  1522.             pstmt = connectionDB.prepareStatement(query.toString());

  1524.             // NOTA:
  1525.             //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  1526.             if(isRisposta && riferimentoMessaggio==null)
  1527.                 pstmt.setString(1,idCollaborazione);
  1528.             else
  1529.                 pstmt.setString(1,riferimentoMessaggio);
  1530.             pstmt.setString(2,Costanti.OUTBOX);
  1531.             rs = pstmt.executeQuery();      
  1532.             if(rs == null) {
  1533.                 throw new ProtocolException("RS Null?");            
  1534.             }
  1535.             String value = null;
  1536.             if(rs.next()){
  1537.                 value = rs.getString("ID_COLLABORAZIONE");
  1538.             }

  1540.             rs.close();
  1541.             pstmt.close();

  1543.             return idCollaborazione.equals(value);

  1545.         }catch(Exception e){    
  1546.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOSIMMETRICO, validazioneCollaborazione "+riferimentoMessaggio+": "+e.getMessage();
  1547.             this.log.error(errorMsg,e);
  1548.             try{
  1549.                 if( rs != null )
  1550.                     rs.close();
  1551.             } catch(Exception er) {
  1552.                 // Eccezione SQL.
  1553.             }
  1554.             try{
  1555.                 if( pstmt != null )
  1556.                     pstmt.close();
  1557.             } catch(Exception er) {
  1558.                 // Eccezione SQL.
  1559.             }
  1560.             throw new ProtocolException(errorMsg,e);
  1561.         }
  1562.     }














  1577.     /* ********  PROFILO ASINCRONO ASIMMETRICO ******** */

  1579.     /**
  1580.      * Registrazione di una richiesta inviata.
  1581.      * Viene mantenuto nella tabella asincrona una entry con ID_MESSAGGIO, OUTBOX, dataInvio(serve per la respedizione) 
  1582.      * 
  1583.      * @param id Identificativo della richiesta
  1584.      * @param ricevutaApplicativa Indicazione sull'abilitazione di una ricevuta applicativa
  1585.      */
  1586.     public void asincronoAsimmetrico_registraRichiestaInviata(String id,String idCollaborazione,
  1587.             boolean ricevutaApplicativa,long scadenzaMessaggi)throws ProtocolException{
  1588.         
  1589.         StateMessage state = (StateMessage)this.state;
  1590.         Connection connectionDB = state.getConnectionDB();
  1591.         PreparedStatement pstmt = null;
  1592.         PreparedStatement pstmtUpdate = null;
  1593.         try{    

  1595.             java.sql.Timestamp oraInvio = DateManager.getTimestamp();

  1597.             StringBuilder query = new StringBuilder();
  1598.             query.append("INSERT INTO  ");
  1599.             query.append(Costanti.PROFILO_ASINCRONO);
  1600.             query.append(" (ID_MESSAGGIO,TIPO,ORA_REGISTRAZIONE,RICEVUTA_ASINCRONA,TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO");
  1601.             query.append(",IS_RICHIESTA,ID_ASINCRONO,ID_COLLABORAZIONE,RICEVUTA_APPLICATIVA) ");
  1602.             query.append(" VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ?, ?)");

  1604.             pstmt = connectionDB.prepareStatement(query.toString());
  1605.             int index = 1;
  1606.             pstmt.setString(index++,id);
  1607.             pstmt.setString(index++,Costanti.OUTBOX);
  1608.             pstmt.setTimestamp(index++,oraInvio);
  1609.             pstmt.setInt(index++,0); // stato ricevuta: attesa
  1610.             pstmt.setString(index++,null); // servizioCorrelato non conosciuto a priori
  1611.             pstmt.setString(index++,null); // servizioCorrelato non conosciuto a priori
  1612.             pstmt.setNull(index++, java.sql.Types.INTEGER); // servizioCorrelato non conosciuto a priori
  1613.             pstmt.setInt(index++,1); // is richiesta
  1614.             pstmt.setString(index++,id); // idasincrono utilizzato per identificare questa instanza di cooperazione asincrona
  1615.             pstmt.setString(index++,idCollaborazione); // idcollaborazione
  1616.             if(ricevutaApplicativa){
  1617.                 pstmt.setInt(index++,1); // ricevuta applicativa abilitata
  1618.             }else{
  1619.                 pstmt.setInt(index++,0); // ricevuta applicativa non abilitata
  1620.             }

  1622.             //  Add PreparedStatement
  1623.             state.getPreparedStatement().put("INSERT save_RichiestaAsincronaAsimmetricaInviata"+id,pstmt);

  1625.             
  1626.             if(this.state instanceof StatefulMessage) {
  1627.                 
  1628.                 // salvo busta per profilo
  1629.                 this.registraBustaInviata(id);
  1630.                 
  1631.             }else{
  1632.                 
  1633.                 StatelessMessage statelessMessage = (StatelessMessage) this.state;
  1634.                 
  1635.                 // Registro proprio la busta
  1636.                 RepositoryBuste repository = new RepositoryBuste(this.state,  this.log, true, this.protocolFactory);
  1637.                 long scadenza = scadenzaMessaggi;
  1638.                 if(scadenza<=0){
  1639.                     scadenza = this.protocolManager.getIntervalloScadenzaBuste();
  1640.                 }
  1641.                 repository.registraBustaIntoOutBox(statelessMessage.getBusta(),scadenza);
  1642.                 this.registraBustaInviata(id);
  1643.                 
  1644.                 // salvo busta per profilo
  1645.                 StringBuilder queryUpdate = new StringBuilder();
  1646.                 queryUpdate.append("UPDATE ");
  1647.                 queryUpdate.append(Costanti.REPOSITORY);
  1648.                 queryUpdate.append(" SET ");
  1649.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  1650.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1651.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  1652.                 pstmtUpdate.setString(1,id);
  1653.                 pstmtUpdate.setString(2,Costanti.OUTBOX);

  1655.                 // Add PreparedStatement
  1656.                 state.getPreparedStatement().put("UPDATE saveBustaForProfilo"+Costanti.OUTBOX+"_"+id,pstmtUpdate);
  1657.             }   

  1659.         } catch(Exception e) {
  1660.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore di registrazione richiesta inviata "+id+": "+e.getMessage();      
  1661.             this.log.error(errorMsg,e);
  1662.             try{
  1663.                 if( pstmt != null )
  1664.                     pstmt.close();
  1665.             } catch(Exception er) {
  1666.                 // Eccezione SQL.
  1667.             }
  1668.             try{
  1669.                 if( pstmtUpdate != null )
  1670.                     pstmtUpdate.close();
  1671.             } catch(Exception er) {
  1672.                 // Eccezione SQL.
  1673.             }
  1674.             throw new ProtocolException(errorMsg,e);
  1675.         }
  1676.     }

  1678.     /**
  1679.      * Controlla se e' stato precedentemente registrata una richiesta asincrona asimmetrica,
  1680.      * ritornando eventuali dati del servizio di richiesta per la consegna della risposta.
  1681.      *
  1682.      * @param riferimentoMessaggio RiferimentoMessaggio
  1683.      * @return Dati di integrazione per la consegna della risposta
  1684.      * 
  1685.      */
  1686.     public IDServizio asincronoAsimmetrico_getDatiConsegnaRisposta(String riferimentoMessaggio) throws ProtocolException{
  1687.         StateMessage state = (StateMessage)this.state;
  1688.         Connection connectionDB = state.getConnectionDB();


  1691.         //       Imposto ricevuta applicativa abilitata: pooling
  1692.         PreparedStatement pstmtPooling = null;
  1693.         try{    

  1695.             StringBuilder query = new StringBuilder();
  1696.             query.append("UPDATE ");
  1697.             query.append(Costanti.PROFILO_ASINCRONO);
  1698.             query.append(" SET RICEVUTA_APPLICATIVA=1 WHERE  ID_MESSAGGIO = ? AND TIPO=?");

  1700.             pstmtPooling = connectionDB.prepareStatement(query.toString());
  1701.             pstmtPooling.setString(1,riferimentoMessaggio);
  1702.             pstmtPooling.setString(2,Costanti.INBOX);

  1704.             //  Add PreparedStatement
  1705.             state.getPreparedStatement().put("UPDATE asincronoAsimmetrico_getDatiConsegnaRisposta "+riferimentoMessaggio,pstmtPooling);

  1707.         } catch(Exception e) {
  1708.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore asincronoAsimmetrico_getDatiConsegnaRisposta, update RICEVUTA_APPLICATIVA "+riferimentoMessaggio+": "+e.getMessage();     
  1709.             this.log.error(errorMsg,e);
  1710.             try{
  1711.                 if( pstmtPooling != null )
  1712.                     pstmtPooling.close();
  1713.             } catch(Exception er) {
  1714.                 // Eccezione SQL.
  1715.             }
  1716.             throw new ProtocolException(errorMsg,e);
  1717.         }

  1719.         try{    
  1720.             // I dati asincroni saranno eliminati quando scadra' la busta asincrona
  1721.             History history = new History(state,this.log);
  1722.             history.registraBustaRicevuta(riferimentoMessaggio);

  1724.             // Prendo i dati di integrazione
  1725.             RepositoryBuste repositoryBuste = new RepositoryBuste(state,  this.log, this.protocolFactory);
  1726.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  1727.             parametri.setDestinatario(true);
  1728.             parametri.setServizio(true);
  1729.             parametri.setAzione(true);
  1730.             Busta busta = repositoryBuste.getSomeValuesFromInBox(riferimentoMessaggio, parametri, true); // leggo dati da database
  1731.             if(busta==null)
  1732.                 throw new Exception("Dati non trovati");
  1733.             else{
  1734.                 IDServizio id = IDServizioFactory.getInstance().getIDServizioFromValues(busta.getTipoServizio(), busta.getServizio(),
  1735.                         busta.getTipoDestinatario(), busta.getDestinatario(),
  1736.                         busta.getVersioneServizio());
  1737.                 id.setAzione(busta.getAzione());
  1738.                 return id;
  1739.             }

  1741.         } catch(Exception e) {
  1742.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore durante la asincronoAsimmetrico_getDatiConsegnaRisposta "+riferimentoMessaggio+": "+e.getMessage();       
  1743.             this.log.error(errorMsg,e);
  1744.             throw new ProtocolException(errorMsg,e);
  1745.         }

  1747.     }

  1749.     /**
  1750.      * Controlla se e' stato precedentemente registrata una richiesta asincrona asimmetrica,
  1751.      * ritornando eventuali dati dell'integrazione per la consegna della ricevuta.
  1752.      *
  1753.      * @return Dati di integrazione per la consegna della risposta
  1754.      * 
  1755.      */
  1756.     public Integrazione asincronoAsimmetrico_getDatiConsegnaRicevuta(String riferimentoMessaggio) throws ProtocolException{
  1757.         if(this.state instanceof StatefulMessage) {
  1758.             StatefulMessage stateful = (StatefulMessage)this.state;
  1759.             try{    
  1760.                 // Prendo i dati di integrazione
  1761.                 RepositoryBuste repositoryBuste = new RepositoryBuste(stateful, this.log, this.protocolFactory);
  1762.                 Integrazione integrazione = repositoryBuste.getInfoIntegrazioneFromOutBox(riferimentoMessaggio);
  1763.                 if(integrazione==null)
  1764.                     throw new Exception("Dati di integrazione non trovati");
  1765.                 else
  1766.                     return integrazione;

  1768.             } catch(Exception e) {
  1769.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore durante la asincronoAsimmetrico_getDatiConsegnaRicevuta "+riferimentoMessaggio+": "+e.getMessage();       
  1770.                 this.log.error(errorMsg,e);
  1771.                 throw new ProtocolException(errorMsg,e);
  1772.             }
  1773.         }else{
  1774.             throw new ProtocolException("Metodo invocato con IState non valido");
  1775.         }
  1776.     }

  1778.     /**
  1779.      * Registrazione di una richiesta ricevuta.
  1780.      * Viene mantenuto nella tabella asincrona una entry con ID_MESSAGGIO, INBOX 
  1781.      * e ServizioCorrelato inserito nella richiesta.
  1782.      * 
  1783.      * @param id Identificativo della richiesta
  1784.      * @param tipoServizioCorrelato Tipo del Servizio Correlato
  1785.      * @param servizioCorrelato Servizio Correlato
  1786.      * @param ricevutaApplicativa Indicazione sull'abilitazione di una ricevuta applicativa
  1787.      */
  1788.     public void asincronoAsimmetrico_registraRichiestaRicevuta(String id,String idCollaborazione,
  1789.             String tipoServizioCorrelato,String servizioCorrelato, Integer versioneServizioCorrelato,
  1790.             boolean ricevutaApplicativa,long scadenzaMessaggi)throws ProtocolException{
  1791.         StateMessage state = (StateMessage)this.state;
  1792.         Connection connectionDB = state.getConnectionDB();
  1793.         PreparedStatement pstmt = null;
  1794.         ResultSet rs = null;
  1795.         PreparedStatement pstmtUpdate = null;
  1796.         try{    

  1798.             java.sql.Timestamp oraRicezione = DateManager.getTimestamp();

  1800.             StringBuilder querySearch = new StringBuilder();
  1801.             querySearch.append("SELECT ID_MESSAGGIO FROM ");
  1802.             querySearch.append(Costanti.PROFILO_ASINCRONO);
  1803.             querySearch.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  1804.             pstmt = connectionDB.prepareStatement(querySearch.toString());
  1805.             pstmt.setString(1,id);
  1806.             pstmt.setString(2,Costanti.INBOX);
  1807.             rs = pstmt.executeQuery();
  1808.             boolean exists = rs.next();
  1809.             rs.close();
  1810.             pstmt.close();


  1813.             StringBuilder query = new StringBuilder();
  1814.             if(exists){
  1815.                 query.append("UPDATE ");
  1816.                 query.append(Costanti.PROFILO_ASINCRONO);
  1817.                 query.append(" SET ID_MESSAGGIO=?,TIPO=?,ORA_REGISTRAZIONE=?,RICEVUTA_ASINCRONA=?,TIPO_SERVIZIO_CORRELATO=?,SERVIZIO_CORRELATO=?,VERSIONE_SERVIZIO_CORRELATO=?," +
  1818.                 "IS_RICHIESTA=?,ID_ASINCRONO=?,ID_COLLABORAZIONE=?,RICEVUTA_APPLICATIVA=? WHERE ID_MESSAGGIO=? AND TIPO=?");
  1819.             }else{
  1820.                 query.append("INSERT INTO  ");
  1821.                 query.append(Costanti.PROFILO_ASINCRONO);
  1822.                 query.append(" (ID_MESSAGGIO,TIPO,ORA_REGISTRAZIONE,RICEVUTA_ASINCRONA,TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO");
  1823.                 query.append(",IS_RICHIESTA,ID_ASINCRONO,ID_COLLABORAZIONE,RICEVUTA_APPLICATIVA) ");
  1824.                 query.append(" VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ?)");
  1825.             }


  1828.             pstmt = connectionDB.prepareStatement(query.toString());
  1829.             int index = 1;
  1830.             pstmt.setString(index++,id);
  1831.             pstmt.setString(index++,Costanti.INBOX);
  1832.             pstmt.setTimestamp(index++,oraRicezione);
  1833.             pstmt.setInt(index++,1); // stato ricevuta: non attesa
  1834.             pstmt.setString(index++,tipoServizioCorrelato);
  1835.             pstmt.setString(index++,servizioCorrelato);
  1836.             if(versioneServizioCorrelato!=null){
  1837.                 pstmt.setInt(index++,versioneServizioCorrelato);
  1838.             }
  1839.             else{
  1840.                 pstmt.setNull(index++, java.sql.Types.INTEGER);
  1841.             }
  1842.             pstmt.setInt(index++,0); // passo nella fase di ricezione richiesta-stato
  1843.             pstmt.setString(index++,id); // idasincrono utilizzato per identificare questa instanza di cooperazione asincrona
  1844.             pstmt.setString(index++,idCollaborazione); // idCollaborazione
  1845.             if(ricevutaApplicativa){
  1846.                 pstmt.setInt(index++,1); // ricevuta applicativa abilitata
  1847.             }else{
  1848.                 pstmt.setInt(index++,0); // ricevuta applicativa non abilitata
  1849.             }
  1850.             if(exists){
  1851.                 pstmt.setString(index++,id);
  1852.                 pstmt.setString(index++,Costanti.INBOX);
  1853.             }

  1855.             //  Add PreparedStatement
  1856.             if(exists){
  1857.                 state.getPreparedStatement().put("UPDATE save_RichiestaAsincronaAsimmetricaRicevuta"+id,pstmt);
  1858.             }else{
  1859.                 state.getPreparedStatement().put("INSERT save_RichiestaAsincronaAsimmetricaRicevuta"+id,pstmt);
  1860.             }

  1862.             if(this.state instanceof StatefulMessage) {
  1863.                 
  1864.                 // salvo busta per profilo
  1865.                 this.registraBustaRicevuta(id);
  1866.                 
  1867.             }else{
  1868.                 
  1869.                 StatelessMessage statelessMessage = (StatelessMessage) this.state;
  1870.                 
  1871.                 long scadenza = scadenzaMessaggi;
  1872.                 if(scadenza<=0){
  1873.                     scadenza = this.protocolManager.getIntervalloScadenzaBuste();
  1874.                 }
  1875.                 
  1876.                 // Registro proprio la busta
  1877.                 RepositoryBuste repository = new RepositoryBuste(this.state,  this.log, true,this.protocolFactory);
  1878.                 String key = "INSERT RegistrazioneBustaForHistory"+Costanti.INBOX+"_"+statelessMessage.getBusta().getID();
  1879.                 if(repository.isRegistrataIntoInBox(statelessMessage.getBusta().getID())){
  1880.                     repository.aggiornaBustaIntoInBox(statelessMessage.getBusta(),scadenza);
  1881.                 }
  1882.                 else if(state.getPreparedStatement().containsKey(key)){
  1883.                     repository.aggiornaBustaIntoInBox(statelessMessage.getBusta(),scadenza);
  1884.                 }else{
  1885.                     repository.registraBustaIntoInBox(statelessMessage.getBusta(),scadenza);
  1886.                 }
  1887.                 this.registraBustaInviata(id);
  1888.                 
  1889.                 // salvo busta per profilo
  1890.                 StringBuilder queryUpdate = new StringBuilder();
  1891.                 queryUpdate.append("UPDATE ");
  1892.                 queryUpdate.append(Costanti.REPOSITORY);
  1893.                 queryUpdate.append(" SET ");
  1894.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  1895.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1896.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  1897.                 pstmtUpdate.setString(1,id);
  1898.                 pstmtUpdate.setString(2,Costanti.INBOX);

  1900.                 // Add PreparedStatement
  1901.                 state.getPreparedStatement().put("UPDATE saveBustaForProfilo"+Costanti.INBOX+"_"+id,pstmtUpdate);
  1902.             }

  1904.         } catch(Exception e) {
  1905.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore di registrazione richiesta ricevuta "+id+": "+e.getMessage();     
  1906.             this.log.error(errorMsg,e);
  1907.             try{
  1908.                 if( rs != null )
  1909.                     rs.close();
  1910.             } catch(Exception er) {
  1911.                 // Eccezione SQL.
  1912.             }
  1913.             try{
  1914.                 if( pstmt != null )
  1915.                     pstmt.close();
  1916.             } catch(Exception er) {
  1917.                 // Eccezione SQL.
  1918.             }
  1919.             try{
  1920.                 if( pstmtUpdate != null )
  1921.                     pstmtUpdate.close();
  1922.             } catch(Exception er) {
  1923.                 // Eccezione SQL.
  1924.             }
  1925.             throw new ProtocolException(errorMsg,e);
  1926.         }
  1927.     }

  1929.     /**
  1930.      * Controlla se e' stato precedentemente registrata una richiesta asincrona asimmetrica,
  1931.      * ritornando eventuale busta da usare con la risposta applicativa.
  1932.      *
  1933.      * @param id Identificativo della richiesta.
  1934.      * @param idRisposta Identificativo della risposta.
  1935.      * @return Dati di integrazione per la consegna della risposta
  1936.      * 
  1937.      */
  1938.     public Busta asincronoAsimmetrico_getBustaRisposta(String id,String idRisposta,long scadenzaMessaggi) throws ProtocolException{
  1939.         StateMessage state = (StateMessage)this.state;
  1940.         Connection connectionDB = state.getConnectionDB();
  1941.         // getBustaRicevuta
  1942.         Busta busta = null;
  1943.         try{
  1944.             RepositoryBuste repository = new RepositoryBuste(state,  this.log, this.protocolFactory);
  1945.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  1946.             parametri.setMittente(true);
  1947.             parametri.setDestinatario(true);
  1948.             parametri.setServizioCorrelato(true);
  1949.             busta = repository.getSomeValuesFromOutBox(id, parametri, true); // Ultimo parametro forza la lettura su database

  1951.         }catch(Exception e){
  1952.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore durante la getBusta dal repository "+id+": "+e.getMessage();      
  1953.             this.log.error(errorMsg,e);
  1954.             throw new ProtocolException(errorMsg,e);
  1955.         }

  1957.         // ProfiloDiCollaborazione
  1958.         busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO);

  1960.         // check eventuali spedizione-risposta precedentemente effettuate
  1961.         PreparedStatement pstmtCheck = null;
  1962.         ResultSet rsCheck = null;
  1963.         String oldIDRisposta = null;
  1964.         String oldTipoRisposta = null;
  1965.         try{
  1966.             StringBuilder query = new StringBuilder();
  1967.             query.append("SELECT ID_MESSAGGIO,TIPO FROM ");
  1968.             query.append(Costanti.PROFILO_ASINCRONO);
  1969.             query.append(" WHERE BACKUP_ID_RICHIESTA=?");

  1971.             pstmtCheck = connectionDB.prepareStatement(query.toString());
  1972.             pstmtCheck.setString(1,id);
  1973.             rsCheck = pstmtCheck.executeQuery();        
  1974.             if(rsCheck == null) {
  1975.                 throw new ProtocolException("RS Check Null?");          
  1976.             }
  1977.             if(rsCheck.next()){
  1978.                 oldIDRisposta = rsCheck.getString("ID_MESSAGGIO");
  1979.                 oldTipoRisposta = rsCheck.getString("TIPO");
  1980.             }       
  1981.             rsCheck.close();
  1982.             pstmtCheck.close();

  1984.         }catch(Exception e){    
  1985.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, asincronoAsimmetrico_getBustaRisposta "+id+": "+e.getMessage();
  1986.             this.log.error(errorMsg,e);
  1987.             try{
  1988.                 if( rsCheck != null )
  1989.                     rsCheck.close();
  1990.             } catch(Exception er) {
  1991.                 // Eccezione SQL.
  1992.             }
  1993.             try{
  1994.                 if( pstmtCheck != null )
  1995.                     pstmtCheck.close();
  1996.             } catch(Exception er) {
  1997.                 // Eccezione SQL.
  1998.             }
  1999.             throw new ProtocolException(errorMsg,e);
  2000.         }

  2002.         //       leggo servizio correlato
  2003.         String tipoServizioCorrelato = null;
  2004.         String servizioCorrelato = null;
  2005.         Integer versioneServizioCorrelato = null;
  2006.         PreparedStatement pstmtRead = null;
  2007.         ResultSet rsRead = null;
  2008.         try{
  2009.             StringBuilder query = new StringBuilder();
  2010.             query.append("SELECT TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO FROM ");
  2011.             query.append(Costanti.PROFILO_ASINCRONO);
  2012.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  2014.             pstmtRead = connectionDB.prepareStatement(query.toString());
  2015.             if(oldIDRisposta!=null && oldTipoRisposta!=null){
  2016.                 pstmtRead.setString(1,oldIDRisposta);
  2017.                 pstmtRead.setString(2,oldTipoRisposta);
  2018.             }else{
  2019.                 pstmtRead.setString(1,id);
  2020.                 pstmtRead.setString(2,Costanti.OUTBOX);
  2021.             }
  2022.             rsRead = pstmtRead.executeQuery();      
  2023.             if(rsRead == null) {
  2024.                 throw new ProtocolException("RS Read Null?");           
  2025.             }
  2026.             if(rsRead.next()){
  2027.                 tipoServizioCorrelato = rsRead.getString("TIPO_SERVIZIO_CORRELATO");
  2028.                 servizioCorrelato = rsRead.getString("SERVIZIO_CORRELATO");
  2029.                 versioneServizioCorrelato = rsRead.getInt("VERSIONE_SERVIZIO_CORRELATO");
  2030.                 if(rsRead.wasNull()){
  2031.                     versioneServizioCorrelato = null;
  2032.                 }
  2033.             }       
  2034.             rsRead.close();
  2035.             pstmtRead.close();

  2037.         }catch(Exception e){    
  2038.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, asincronoAsimmetrico_getBustaRisposta, raccolta servizio correlato, "+id+": "+e.getMessage();
  2039.             this.log.error(errorMsg,e);
  2040.             try{
  2041.                 if( rsRead != null )
  2042.                     rsRead.close();
  2043.             } catch(Exception er) {
  2044.                 // Eccezione SQL.
  2045.             }
  2046.             try{
  2047.                 if( pstmtRead != null )
  2048.                     pstmtRead.close();
  2049.             } catch(Exception er) {
  2050.                 // Eccezione SQL.
  2051.             }
  2052.             throw new ProtocolException(errorMsg,e);
  2053.         }
  2054.         busta.setTipoServizioCorrelato(tipoServizioCorrelato);
  2055.         busta.setServizioCorrelato(servizioCorrelato);
  2056.         busta.setVersioneServizioCorrelato(versioneServizioCorrelato);

  2058.         // Imposto parametri per la consegna della risposta
  2059.         PreparedStatement pstmt = null;
  2060.         try{    

  2062.             java.sql.Timestamp oraInvioRisposta = DateManager.getTimestamp();

  2064.             StringBuilder query = new StringBuilder();
  2065.             query.append("UPDATE ");
  2066.             query.append(Costanti.PROFILO_ASINCRONO);
  2067.             query.append(" SET IS_RICHIESTA=0, RICEVUTA_ASINCRONA=0, ORA_REGISTRAZIONE=?, ID_MESSAGGIO=?, TIPO=?, BACKUP_ID_RICHIESTA=?, RICEVUTA_APPLICATIVA=1 WHERE  ID_MESSAGGIO = ? AND TIPO=?");

  2069.             pstmt = connectionDB.prepareStatement(query.toString());
  2070.             pstmt.setTimestamp(1,oraInvioRisposta);
  2071.             pstmt.setString(2,idRisposta);
  2072.             pstmt.setString(3,Costanti.OUTBOX);
  2073.             pstmt.setString(4,id);
  2074.             if(oldIDRisposta!=null && oldTipoRisposta!=null){
  2075.                 pstmt.setString(5,oldIDRisposta);
  2076.                 pstmt.setString(6,oldTipoRisposta);
  2077.             }else{
  2078.                 pstmt.setString(5,id);
  2079.                 pstmt.setString(6,Costanti.OUTBOX);
  2080.             }

  2082.             //  Add PreparedStatement
  2083.             state.getPreparedStatement().put("UPDATE save_RispostaAsincronaAsimmetricaInviata"+id,pstmt);

  2085.         } catch(Exception e) {
  2086.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore di registrazione risposta inviata "+id+": "+e.getMessage();       
  2087.             this.log.error(errorMsg,e);
  2088.             try{
  2089.                 if( pstmt != null )
  2090.                     pstmt.close();
  2091.             } catch(Exception er) {
  2092.                 // Eccezione SQL.
  2093.             }
  2094.             throw new ProtocolException(errorMsg,e);
  2095.         }

  2097.         History history = new History(state,this.log);

  2099.         // Registro la richiesta nell'history 
  2100.         history.registraBustaInviata(id);

  2102.         // Registro la richiesta stato nell'history con il nuovo id
  2103.         if(this.state instanceof StatefulMessage) {
  2104.             
  2105.             // salvo busta per profilo
  2106.             this.registraBustaInviata(idRisposta);
  2107.             
  2108.         }else{
  2109.             
  2110.             StatelessMessage statelessMessage = (StatelessMessage) this.state;
  2111.             
  2112.             long scadenza = scadenzaMessaggi;
  2113.             if(scadenza<=0){
  2114.                 scadenza = this.protocolManager.getIntervalloScadenzaBuste();
  2115.             }
  2116.             
  2117.             // Registro proprio la busta
  2118.             RepositoryBuste repository = new RepositoryBuste(this.state,  this.log, true,this.protocolFactory);
  2119.             repository.registraBustaIntoOutBox(statelessMessage.getBusta(),scadenza);
  2120.             this.registraBustaInviata(idRisposta);
  2121.             
  2122.             // salvo busta per profilo
  2123.             PreparedStatement pstmtUpdate = null;
  2124.             try{
  2125.                 StringBuilder queryUpdate = new StringBuilder();
  2126.                 queryUpdate.append("UPDATE ");
  2127.                 queryUpdate.append(Costanti.REPOSITORY);
  2128.                 queryUpdate.append(" SET ");
  2129.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(true));
  2130.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  2131.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  2132.                 pstmtUpdate.setString(1,idRisposta);
  2133.                 pstmtUpdate.setString(2,Costanti.OUTBOX);

  2135.                 // Add PreparedStatement
  2136.                 state.getPreparedStatement().put("UPDATE saveBustaForProfilo"+Costanti.OUTBOX+"_"+idRisposta,pstmtUpdate);
  2137.                 
  2138.             } catch(Exception e) {
  2139.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore di aggiornamento busta di risposta "+idRisposta+": "+e.getMessage();      
  2140.                 this.log.error(errorMsg,e);
  2141.                 try{
  2142.                     if( pstmtUpdate != null )
  2143.                         pstmtUpdate.close();
  2144.                 } catch(Exception er) {
  2145.                     // Eccezione SQL.
  2146.                 }
  2147.                 throw new ProtocolException(errorMsg,e);
  2148.             }
  2149.         }   
  2150.         

  2152.         //  I dati asincroni saranno eliminati quando scadra' la richiesta-stato asincrona
  2153.         history.registraBustaInviata(idRisposta);

  2155.         //  delete vecchia risposta
  2156.         if(oldIDRisposta!=null && oldTipoRisposta!=null){
  2157.             this.eliminaBusta(oldIDRisposta,oldTipoRisposta,true);
  2158.             history.eliminaBusta(oldIDRisposta,oldTipoRisposta,true);
  2159.         }

  2161.         return busta;
  2162.     }

  2164.     /**
  2165.      * Controlla se e' stato precedentemente registrata una richiesta asincrona simmetrica,
  2166.      * ritornando eventuale busta da usare con la ricevuta applicativa.
  2167.      *
  2168.      * @param id Identificativo della richiesta asincrona.
  2169.      * @param rifMsgRicevuta Riferimento Messaggio da applicare alla ricevuta.
  2170.      * @param isRichiesta Indicazione se si desidera la busta per una ricevuta ad una richiesta o risposta
  2171.      * @return Busta da utilizzare per la ricevuta
  2172.      * 
  2173.      */
  2174.     public Busta asincronoAsimmetrico_getBustaRicevuta(String id,String rifMsgRicevuta,boolean isRichiesta,boolean generazioneAttributiAsincroni,TipoOraRegistrazione tipoTempo) throws ProtocolException{
  2175.         StateMessage state = (StateMessage)this.state;
  2176.         Connection connectionDB = state.getConnectionDB();
  2177.         // leggo servizio correlato
  2178.         String tipoServizioCorrelato = null;
  2179.         String servizioCorrelato = null;
  2180.         Integer versioneServizioCorrelato = null;
  2181.         PreparedStatement pstmtRead = null;
  2182.         ResultSet rsRead = null;
  2183.         try{
  2184.             StringBuilder query = new StringBuilder();
  2185.             query.append("SELECT TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO FROM ");
  2186.             query.append(Costanti.PROFILO_ASINCRONO);
  2187.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  2189.             pstmtRead = connectionDB.prepareStatement(query.toString());
  2190.             pstmtRead.setString(1,id);
  2191.             pstmtRead.setString(2,Costanti.INBOX);
  2192.             rsRead = pstmtRead.executeQuery();      
  2193.             if(rsRead == null) {
  2194.                 throw new ProtocolException("RS Read Null?");           
  2195.             }
  2196.             if(rsRead.next()){
  2197.                 tipoServizioCorrelato = rsRead.getString("TIPO_SERVIZIO_CORRELATO");
  2198.                 servizioCorrelato = rsRead.getString("SERVIZIO_CORRELATO");
  2199.                 versioneServizioCorrelato = rsRead.getInt("VERSIONE_SERVIZIO_CORRELATO");
  2200.                 if(rsRead.wasNull()){
  2201.                     versioneServizioCorrelato = null;
  2202.                 }
  2203.             }       
  2204.             rsRead.close();
  2205.             pstmtRead.close();

  2207.         }catch(Exception e){    
  2208.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, asincronoAsimmetrico_getBustaRicevuta, raccolta servizio correlato, "+id+": "+e.getMessage();
  2209.             this.log.error(errorMsg,e);
  2210.             try{
  2211.                 if( rsRead != null )
  2212.                     rsRead.close();
  2213.             } catch(Exception er) {
  2214.                 // Eccezione SQL.
  2215.             }
  2216.             try{
  2217.                 if( pstmtRead != null )
  2218.                     pstmtRead.close();
  2219.             } catch(Exception er) {
  2220.                 // Eccezione SQL.
  2221.             }
  2222.             throw new ProtocolException(errorMsg,e);
  2223.         }



  2227.         Busta busta = null;
  2228.         try{
  2229.             RepositoryBuste repository = new RepositoryBuste(state,  this.log, this.protocolFactory);
  2230.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  2231.             parametri.setMittente(true);
  2232.             parametri.setDestinatario(true);
  2233.             parametri.setServizio(true);
  2234.             parametri.setAzione(true);
  2235.             parametri.setCollaborazione(true);
  2236.             parametri.setProfiloTrasmissione(true);
  2237.             parametri.setIndirizziTelematici(this.protocolConfiguration.isSupportoIndirizzoRisposta());
  2238.             busta = repository.getSomeValuesFromInBox(id, parametri, true); // prendo dati dal database

  2240.             if(isRichiesta==false){

  2242.                 // elimino busta per profilo
  2243.                 this.eliminaBustaRicevuta(id, true);
  2244.             }

  2246.             // costruzione busta di risposta   

  2248.             // profilo di collaborazione
  2249.             busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO);

  2251.             // inverto mitt con dest 
  2252.             String mitt = busta.getMittente();
  2253.             String tipoMitt = busta.getTipoMittente();
  2254.             String portaMitt = busta.getIdentificativoPortaMittente();
  2255.             String indMitt = busta.getIndirizzoMittente();
  2256.             busta.setMittente(busta.getDestinatario());
  2257.             busta.setTipoMittente(busta.getTipoDestinatario());
  2258.             busta.setIdentificativoPortaMittente(busta.getIdentificativoPortaDestinatario());
  2259.             busta.setIndirizzoMittente(busta.getIndirizzoDestinatario());
  2260.             busta.setDestinatario(mitt);
  2261.             busta.setTipoDestinatario(tipoMitt);
  2262.             busta.setIdentificativoPortaDestinatario(portaMitt);
  2263.             busta.setIndirizzoDestinatario(indMitt);

  2265.             if(isRichiesta){
  2266.                 // PRODUZIONE tipo e nome Servizio Correlato
  2267.                 if(generazioneAttributiAsincroni){
  2268.                     busta.setTipoServizioCorrelato(tipoServizioCorrelato);
  2269.                     busta.setServizioCorrelato(servizioCorrelato);
  2270.                     busta.setVersioneServizioCorrelato(versioneServizioCorrelato);
  2271.                 }
  2272.             }
  2273.             else{
  2274.                 busta.setTipoServizio(tipoServizioCorrelato);
  2275.                 busta.setServizio(servizioCorrelato);
  2276.                 busta.setVersioneServizio(versioneServizioCorrelato);
  2277.             }

  2279.             busta.setRiferimentoMessaggio(rifMsgRicevuta);
  2280.             busta.setOraRegistrazione(DateManager.getDate());
  2281.             busta.setTipoOraRegistrazione(tipoTempo,this.protocolTraduttore.toString(tipoTempo));

  2283.         }catch(Exception e){
  2284.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore durante la asincronoAsimmetrico_getBustaRicevuta dal repository "+id+": "+e.getMessage();     
  2285.             this.log.error(errorMsg,e);
  2286.             throw new ProtocolException(errorMsg,e);
  2287.         }

  2289.         return busta;

  2291.     }

  2293.     /**
  2294.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona asimmetrica.
  2295.      *
  2296.      * @param bustaDaValidare Busta da controllare
  2297.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  2298.      * 
  2299.      */
  2300.     public Eccezione asincronoAsimmetrico_validazioneCorrelazione_ricevutaRichiesta(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  2301.         return asincronoAsimmetrico_validazioneCorrelazione(bustaDaValidare,true,false,false,protocolFactory);
  2302.     }   

  2304.     /**
  2305.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona asimmetrica.
  2306.      *
  2307.      * @param bustaDaValidare Busta da controllare
  2308.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  2309.      * 
  2310.      */
  2311.     public Eccezione asincronoAsimmetrico_validazioneCorrelazione_richiestaStato(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  2312.         return asincronoAsimmetrico_validazioneCorrelazione(bustaDaValidare,false,true,false,protocolFactory);
  2313.     }   

  2315.     /**
  2316.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona asimmetrica.
  2317.      *
  2318.      * @param bustaDaValidare Busta da controllare
  2319.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  2320.      * 
  2321.      */
  2322.     public Eccezione asincronoAsimmetrico_validazioneCorrelazione_ricevutaRichiestaStato(Busta bustaDaValidare, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  2323.         return asincronoAsimmetrico_validazioneCorrelazione(bustaDaValidare,false,false,true,protocolFactory);
  2324.     }   


  2327.     /**
  2328.      * Validazione della busta, che sia coerente con la precedente richiesta asincrona asimmetrica.
  2329.      *
  2330.      * @param bustaDaValidare Busta da controllare
  2331.      * @param isRicevutaRichiesta Ricevuta della Richiesta
  2332.      * @param isRichiestaStato RichiestaStato
  2333.      * @param isRicevutaRichiestaStato Ricevuta della Risposta
  2334.      * @return una Eccezione se la validazione fallisce, null altrimenti.
  2335.      * 
  2336.      */
  2337.     private Eccezione asincronoAsimmetrico_validazioneCorrelazione(Busta bustaDaValidare,boolean isRicevutaRichiesta,boolean isRichiestaStato,
  2338.             boolean isRicevutaRichiestaStato, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  2339.         StateMessage state = (StateMessage)this.state;
  2340.         Connection connectionDB = state.getConnectionDB();
  2341.         Busta bustaRichiesta = null;
  2342.         try{
  2343.             RepositoryBuste repository = new RepositoryBuste(state,  this.log, this.protocolFactory);
  2344.             LetturaParametriBusta parametri = new LetturaParametriBusta();
  2345.             parametri.setMittente(true);
  2346.             parametri.setDestinatario(true);
  2347.             parametri.setServizio(true);
  2348.             parametri.setAzione(true);
  2349.             if(isRichiestaStato){
  2350.                 // NOTA:
  2351.                 //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  2352.                 if(bustaDaValidare.getRiferimentoMessaggio()==null)
  2353.                     bustaRichiesta = repository.getSomeValuesFromInBox(bustaDaValidare.getCollaborazione(),parametri,true); // deve leggere sempre da database
  2354.                 else
  2355.                     bustaRichiesta = repository.getSomeValuesFromInBox(bustaDaValidare.getRiferimentoMessaggio(),parametri,true); // deve leggere sempre da database
  2356.             }else
  2357.                 bustaRichiesta = repository.getSomeValuesFromOutBox(bustaDaValidare.getRiferimentoMessaggio(),parametri,true); // deve leggere sempre da database
  2358.         }catch(Exception e){
  2359.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, Errore durante la validazioneCorrelazione, get dal repository RifMsg("+bustaDaValidare.getRiferimentoMessaggio()+") Collab("+bustaDaValidare.getCollaborazione()+"): "+e.getMessage();
  2360.             this.log.error(errorMsg,e);
  2361.             throw new ProtocolException(errorMsg,e);
  2362.         }

  2364.         // Validazione Servizio (Tipo e Nome)
  2365.         // Obbligatoria per una risposta, opzionale per una ricevuta
  2366.         if( isRicevutaRichiesta ){
  2367.             if(bustaDaValidare.getServizio()!=null && bustaDaValidare.getTipoServizio()!=null){
  2368.                 if (bustaRichiesta.getTipoServizio().equals(bustaDaValidare.getTipoServizio())==false){
  2369.                     String msgErrore = "Tipo di servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2370.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.
  2371.                             getErroreCooperazione(msgErrore),
  2372.                             true,null,protocolFactory);
  2373.                     this.log.error(msgErrore);
  2374.                     return eccValidazione;
  2375.                 }
  2376.                 if (bustaRichiesta.getServizio().equals(bustaDaValidare.getServizio())==false){
  2377.                     String msgErrore = "Servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2378.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.SERVIZIO_NON_VALIDO.
  2379.                             getErroreCooperazione(msgErrore),
  2380.                             true,null,protocolFactory);
  2381.                     this.log.error(msgErrore);
  2382.                     return eccValidazione;
  2383.                 }
  2384.             }
  2385.         }
  2386.         else if(  (isRichiestaStato) || (isRicevutaRichiestaStato && bustaDaValidare.getServizio()!=null && bustaDaValidare.getTipoServizio()!=null) ) {

  2388.             // Validazione Servizio (Tipo e Nome)
  2389.             PreparedStatement pstmt = null;
  2390.             ResultSet rs = null;
  2391.             try{
  2392.                 StringBuilder query = new StringBuilder();
  2393.                 query.append("SELECT TIPO_SERVIZIO_CORRELATO,SERVIZIO_CORRELATO,VERSIONE_SERVIZIO_CORRELATO FROM ");
  2394.                 query.append(Costanti.PROFILO_ASINCRONO);
  2395.                 query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  2397.                 pstmt = connectionDB.prepareStatement(query.toString());

  2399.                 // NOTA:
  2400.                 //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  2401.                 if(isRichiestaStato && bustaDaValidare.getRiferimentoMessaggio()==null)
  2402.                     pstmt.setString(1,bustaDaValidare.getCollaborazione());
  2403.                 else
  2404.                     pstmt.setString(1,bustaDaValidare.getRiferimentoMessaggio());           

  2406.                 if(isRichiestaStato)
  2407.                     pstmt.setString(2,Costanti.INBOX);
  2408.                 else
  2409.                     pstmt.setString(2,Costanti.OUTBOX);
  2410.                 rs = pstmt.executeQuery();      
  2411.                 if(rs == null) {
  2412.                     throw new ProtocolException("RS Null?");            
  2413.                 }
  2414.                 String tipoServizioCorrelatoRegistrato = null;
  2415.                 String servizioCorrelatoRegistrato = null;
  2416.                 Integer versioneServizioCorrelatoRegistrato = null;
  2417.                 if(rs.next()){
  2418.                     tipoServizioCorrelatoRegistrato = rs.getString("TIPO_SERVIZIO_CORRELATO");
  2419.                     servizioCorrelatoRegistrato = rs.getString("SERVIZIO_CORRELATO");
  2420.                     versioneServizioCorrelatoRegistrato = rs.getInt("VERSIONE_SERVIZIO_CORRELATO");
  2421.                 }
  2422.                 rs.close();
  2423.                 pstmt.close();

  2425.                 if (bustaDaValidare.getTipoServizio().equals(tipoServizioCorrelatoRegistrato) == false){
  2426.                     String msgErrore = "Tipo di servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2427.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_SERVIZIO_NON_VALIDO.
  2428.                             getErroreCooperazione(msgErrore),
  2429.                             true,null,protocolFactory);
  2430.                     this.log.error(msgErrore);
  2431.                     return eccValidazione;
  2432.                 }
  2433.                 if (bustaDaValidare.getServizio().equals(servizioCorrelatoRegistrato) == false){
  2434.                     String msgErrore = "Servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2435.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.SERVIZIO_NON_VALIDO.
  2436.                             getErroreCooperazione(msgErrore),
  2437.                             true,null,protocolFactory);
  2438.                     this.log.error(msgErrore);
  2439.                     return eccValidazione;
  2440.                 }
  2441.                 if(versioneServizioCorrelatoRegistrato==null){
  2442.                     versioneServizioCorrelatoRegistrato = -1; //valore errato inserito appositamente
  2443.                 }
  2444.                 if (bustaDaValidare.getVersioneServizio().intValue() != versioneServizioCorrelatoRegistrato.intValue()){
  2445.                     String msgErrore = "Versione del servizio diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2446.                     Eccezione eccValidazione = new Eccezione(ErroriCooperazione.VERSIONE_SERVIZIO_NON_VALIDO.
  2447.                             getErroreCooperazione(msgErrore),
  2448.                             true,null,protocolFactory);
  2449.                     this.log.error(msgErrore);
  2450.                     return eccValidazione;
  2451.                 }


  2454.             }catch(Exception e){    
  2455.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, validazioneCorrelazione RifMsg("+bustaDaValidare.getRiferimentoMessaggio()+") Collab("+bustaDaValidare.getCollaborazione()+"): "+e.getMessage();
  2456.                 this.log.error(errorMsg,e);
  2457.                 try{
  2458.                     if( rs != null )
  2459.                         rs.close();
  2460.                 } catch(Exception er) {
  2461.                     // Eccezione SQL.
  2462.                 }
  2463.                 try{
  2464.                     if( pstmt != null )
  2465.                         pstmt.close();
  2466.                 } catch(Exception er) {
  2467.                     // Eccezione SQL.
  2468.                 }
  2469.                 throw new ProtocolException(errorMsg,e);
  2470.             }
  2471.         }

  2473.         // Validazione altri parametri busta
  2474.         // L'azione di una ricevuta deve essere la stessa di quella della richiesta/richiestaStato
  2475.         if(bustaDaValidare.getAzione()!=null && isRichiestaStato==false){
  2476.             if (bustaDaValidare.getAzione().equals(bustaRichiesta.getAzione()) == false){
  2477.                 String msgErrore = "Azione diversa da quello attesa nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2478.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.AZIONE_NON_VALIDA.
  2479.                         getErroreCooperazione(msgErrore),
  2480.                         true,null,protocolFactory);
  2481.                 this.log.error(msgErrore);
  2482.                 return eccValidazione;
  2483.             }
  2484.         }
  2485.         if(isRichiestaStato){
  2486.             if (bustaRichiesta.getTipoMittente().equals(bustaDaValidare.getTipoMittente()) == false){
  2487.                 String msgErrore = "Tipo del mittente diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2488.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.
  2489.                         getErroreCooperazione(msgErrore),
  2490.                         true,null,protocolFactory);
  2491.                 this.log.error(msgErrore);
  2492.                 return eccValidazione;
  2493.             }
  2494.             if (bustaRichiesta.getMittente().equals(bustaDaValidare.getMittente()) == false){
  2495.                 String msgErrore = "Mittente diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2496.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.MITTENTE_NON_VALIDO.
  2497.                         getErroreCooperazione(msgErrore),
  2498.                         true,null,protocolFactory);
  2499.                 this.log.error(msgErrore);
  2500.                 return eccValidazione;
  2501.             }
  2502.             if (bustaRichiesta.getTipoDestinatario().equals(bustaDaValidare.getTipoDestinatario()) == false){
  2503.                 String msgErrore = "Tipo del destinatario diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2504.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_DESTINATARIO_NON_VALIDO.
  2505.                         getErroreCooperazione(msgErrore),
  2506.                         true,null,protocolFactory);
  2507.                 this.log.error(msgErrore);
  2508.                 return eccValidazione;
  2509.             }
  2510.             if (bustaRichiesta.getDestinatario().equals(bustaDaValidare.getDestinatario()) == false){
  2511.                 String msgErrore = "Destinatario diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2512.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.DESTINATARIO_NON_VALIDO.
  2513.                         getErroreCooperazione(msgErrore),
  2514.                         true,null,protocolFactory);
  2515.                 this.log.error(msgErrore);
  2516.                 return eccValidazione;
  2517.             }
  2518.         }else{
  2519.             if (bustaRichiesta.getTipoDestinatario().equals(bustaDaValidare.getTipoMittente()) == false){
  2520.                 String msgErrore = "Tipo del mittente diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2521.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_MITTENTE_NON_VALIDO.
  2522.                         getErroreCooperazione(msgErrore),
  2523.                         true,null,protocolFactory);
  2524.                 this.log.error(msgErrore);
  2525.                 return eccValidazione;
  2526.             }
  2527.             if (bustaRichiesta.getDestinatario().equals(bustaDaValidare.getMittente()) == false){
  2528.                 String msgErrore = "Mittente diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2529.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.MITTENTE_NON_VALIDO.
  2530.                         getErroreCooperazione(msgErrore),
  2531.                         true,null,protocolFactory);
  2532.                 this.log.error(msgErrore);
  2533.                 return eccValidazione;
  2534.             }
  2535.             if (bustaRichiesta.getTipoMittente().equals(bustaDaValidare.getTipoDestinatario()) == false){
  2536.                 String msgErrore = "Tipo del destinatario diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2537.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.TIPO_DESTINATARIO_NON_VALIDO.
  2538.                         getErroreCooperazione(msgErrore),
  2539.                         true,null,protocolFactory);
  2540.                 this.log.error(msgErrore);
  2541.                 return eccValidazione;
  2542.             }
  2543.             if (bustaRichiesta.getMittente().equals(bustaDaValidare.getDestinatario()) == false){
  2544.                 String msgErrore = "Destinatario diverso da quello atteso nella gestione del profilo di collaborazione Asincrono Asimmetrico";
  2545.                 Eccezione eccValidazione = new Eccezione(ErroriCooperazione.DESTINATARIO_NON_VALIDO.
  2546.                         getErroreCooperazione(msgErrore),
  2547.                         true,null,protocolFactory);
  2548.                 this.log.error(msgErrore);
  2549.                 return eccValidazione;
  2550.             }
  2551.         }
  2552.         return null;
  2553.     }

  2555.     /**
  2556.      * Validazione del riferimentoMessaggio di una busta asincrona asimmetrica.
  2557.      *
  2558.      * @param riferimentoMessaggio Identificativo.
  2559.      * @return true se esiste una entry nella tabella apposita.
  2560.      * 
  2561.      */
  2562.     public boolean asincronoAsimmetrico_validazioneRiferimentoMessaggio_richiestaStato(String riferimentoMessaggio) throws ProtocolException{
  2563.         return asincronoAsimmetrico_validazioneRiferimentoMessaggio(riferimentoMessaggio,true);
  2564.     }

  2566.     /**
  2567.      * Validazione del riferimentoMessaggio di una busta asincrona asimmetrica.
  2568.      *
  2569.      * @param riferimentoMessaggio Identificativo.
  2570.      * @return true se esiste una entry nella tabella apposita.
  2571.      * 
  2572.      */
  2573.     public boolean asincronoAsimmetrico_validazioneRiferimentoMessaggio_ricevuta(String riferimentoMessaggio) throws ProtocolException{
  2574.         return asincronoAsimmetrico_validazioneRiferimentoMessaggio(riferimentoMessaggio,false);
  2575.     }

  2577.     /**
  2578.      * Validazione del riferimentoMessaggio di una busta asincrona asimmetrica.
  2579.      *
  2580.      * @param riferimentoMessaggio Identificativo.
  2581.      * @param isRichiestaStato Indicazione se la busta da validare e' una richiesta stato
  2582.      * @return true se esiste una entry nella tabella apposita.
  2583.      * 
  2584.      */
  2585.     private boolean asincronoAsimmetrico_validazioneRiferimentoMessaggio(String riferimentoMessaggio,boolean isRichiestaStato) throws ProtocolException{
  2586.         StateMessage state = (StateMessage)this.state;
  2587.         Connection connectionDB = state.getConnectionDB();
  2588.         PreparedStatement pstmt = null;
  2589.         ResultSet rs = null;
  2590.         try{
  2591.             StringBuilder query = new StringBuilder();
  2592.             query.append("SELECT ID_MESSAGGIO FROM ");
  2593.             query.append(Costanti.PROFILO_ASINCRONO);
  2594.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  2596.             pstmt = connectionDB.prepareStatement(query.toString());
  2597.             pstmt.setString(1,riferimentoMessaggio);
  2598.             if(isRichiestaStato)
  2599.                 pstmt.setString(2,Costanti.INBOX);
  2600.             else
  2601.                 pstmt.setString(2,Costanti.OUTBOX);
  2602.             rs = pstmt.executeQuery();      
  2603.             if(rs == null) {
  2604.                 throw new ProtocolException("RS Null?");            
  2605.             }
  2606.             boolean value = rs.next();

  2608.             rs.close();
  2609.             pstmt.close();

  2611.             RepositoryBuste repositoryBuste = new RepositoryBuste(state, this.log, this.protocolFactory);
  2612.             if(isRichiestaStato)
  2613.                 return value && repositoryBuste.isRegistrataIntoInBox(riferimentoMessaggio);
  2614.             else
  2615.                 return value && repositoryBuste.isRegistrataIntoOutBox(riferimentoMessaggio);

  2617.         }catch(Exception e){    
  2618.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, validazioneRiferimentoMessaggio "+riferimentoMessaggio+": "+e.getMessage();
  2619.             this.log.error(errorMsg,e);
  2620.             try{
  2621.                 if( rs != null )
  2622.                     rs.close();
  2623.             } catch(Exception er) {
  2624.                 // Eccezione SQL.
  2625.             }
  2626.             try{
  2627.                 if( pstmt != null )
  2628.                     pstmt.close();
  2629.             } catch(Exception er) {
  2630.                 // Eccezione SQL.
  2631.             }
  2632.             throw new ProtocolException(errorMsg,e);
  2633.         }
  2634.     }

  2636.     /**
  2637.      * Validazione della collaborazione di una busta asincrona.
  2638.      *
  2639.      * @param riferimentoMessaggio Identificativo.
  2640.      * @param idCollaborazione Collaborazione
  2641.      * @return true se la collaborazione e' valida
  2642.      * 
  2643.      */
  2644.     public boolean asincronoAsimmetrico_validazioneCollaborazione_richiestaStato(String riferimentoMessaggio,String idCollaborazione) throws ProtocolException{
  2645.         return asincronoAsimmetrico_validazioneCollaborazione(riferimentoMessaggio,idCollaborazione,true);
  2646.     }

  2648.     /**
  2649.      * Validazione della collaborazione di una busta asincrona.
  2650.      *
  2651.      * @param riferimentoMessaggio Identificativo.
  2652.      * @param idCollaborazione Collaborazione
  2653.      * @return true se la collaborazione e' valida
  2654.      * 
  2655.      */
  2656.     public boolean asincronoAsimmetrico_validazioneCollaborazione_ricevuta(String riferimentoMessaggio,String idCollaborazione) throws ProtocolException{
  2657.         return asincronoAsimmetrico_validazioneCollaborazione(riferimentoMessaggio,idCollaborazione,false);
  2658.     }

  2660.     /**
  2661.      * Validazione della collaborazione di una busta asincrona.
  2662.      *
  2663.      * @param riferimentoMessaggio Identificativo.
  2664.      * @param idCollaborazione Collaborazione
  2665.      * @param isRichiestaStato Indicazione se la busta da validare e' una richiesta stato
  2666.      * @return true se la collaborazione e' valida
  2667.      * 
  2668.      */
  2669.     private boolean asincronoAsimmetrico_validazioneCollaborazione(String riferimentoMessaggio,String idCollaborazione,boolean isRichiestaStato) throws ProtocolException{
  2670.         StateMessage state = (StateMessage)this.state;
  2671.         Connection connectionDB = state.getConnectionDB();
  2672.         PreparedStatement pstmt = null;
  2673.         ResultSet rs = null;
  2674.         try{
  2675.             StringBuilder query = new StringBuilder();
  2676.             query.append("SELECT ID_COLLABORAZIONE FROM ");
  2677.             query.append(Costanti.PROFILO_ASINCRONO);
  2678.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  2680.             pstmt = connectionDB.prepareStatement(query.toString());

  2682.             // NOTA:
  2683.             //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione
  2684.             if(isRichiestaStato && riferimentoMessaggio==null)
  2685.                 pstmt.setString(1,idCollaborazione);
  2686.             else
  2687.                 pstmt.setString(1,riferimentoMessaggio);

  2689.             if(isRichiestaStato)
  2690.                 pstmt.setString(2,Costanti.INBOX);
  2691.             else
  2692.                 pstmt.setString(2,Costanti.OUTBOX);
  2693.             rs = pstmt.executeQuery();      
  2694.             if(rs == null) {
  2695.                 throw new ProtocolException("RS Null?");            
  2696.             }
  2697.             String value = null;
  2698.             if(rs.next()){
  2699.                 value = rs.getString("ID_COLLABORAZIONE");
  2700.             }

  2702.             rs.close();
  2703.             pstmt.close();

  2705.             return idCollaborazione.equals(value);

  2707.         }catch(Exception e){    
  2708.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONOASIMMETRICO, validazioneCollaborazione "+riferimentoMessaggio+": "+e.getMessage();
  2709.             this.log.error(errorMsg,e);
  2710.             try{
  2711.                 if( rs != null )
  2712.                     rs.close();
  2713.             } catch(Exception er) {
  2714.                 // Eccezione SQL.
  2715.             }
  2716.             try{
  2717.                 if( pstmt != null )
  2718.                     pstmt.close();
  2719.             } catch(Exception er) {
  2720.                 // Eccezione SQL.
  2721.             }
  2722.             throw new ProtocolException(errorMsg,e);
  2723.         }
  2724.     }


  2727.     
  2728.     
  2729.     
  2730.     
  2731.     
  2732.     
  2733.     
  2734.     
  2735.     

  2737.     /* ********  PROFILO ASINCRONO ******** */

  2739.     /**
  2740.      * In caso esista nella tabella asincrona buste inviate che non sono state ringraziate da una ricevuta dopo un intervallo di tempo,
  2741.      * si occupa di ritornare un array di buste da reinviare, aggiornando le loro date di registrazione.
  2742.      *
  2743.      * @param timeout Minuti dopo il quale una data risulta scaduta.
  2744.      * @return un List di {@link org.openspcoop2.protocol.sdk.Busta} contenente le informazioni necessarie per il re-invio delle buste, 
  2745.      *         se esistono buste non ringraziate.
  2746.      * @deprecated utilizzare la versione non serializable
  2747.      */
  2748.     @Deprecated
  2749.     public List<Busta> asincrono_getBusteAsincronePerUlterioreInoltro_serializable(long timeout)throws ProtocolException{
  2750.         return this.asincrono_getBusteAsincronePerUlterioreInoltro_serializable(timeout,60l,100);
  2751.     }

  2753.     /**
  2754.      * In caso esista nella tabella asincrona buste inviate che non sono state ringraziate da una ricevuta dopo un intervallo di tempo,
  2755.      * si occupa di ritornare un array di buste da reinviare, aggiornando le loro date di registrazione.
  2756.      *
  2757.      * @param timeout Minuti dopo il quale una data risulta scaduta.
  2758.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  2759.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  2760.      * @return un List di {@link org.openspcoop2.protocol.sdk.Busta} contenente le informazioni necessarie per il re-invio delle buste, 
  2761.      *         se esistono buste non ringraziate.
  2762.      * @deprecated utilizzare la versione non serializable 
  2763.      */
  2764.     @Deprecated
  2765.     public List<Busta> asincrono_getBusteAsincronePerUlterioreInoltro_serializable(long timeout,long attesaAttiva,int checkInterval)throws ProtocolException{
  2766.         if(this.state instanceof StatefulMessage) {
  2767.             StatefulMessage stateful = (StatefulMessage)this.state;
  2768.             Connection connectionDB = stateful.getConnectionDB();

  2770.             /*
  2771.              * Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  2772.              *  di leggere solo le indicazioni di richieste asincrone committate,
  2773.              * e comunque rispedira' anche le buste eliminate, ma non committate.
  2774.              */
  2775.             // setAutoCommit e livello Isolamento
  2776.             int oldTransactionIsolation = -1;
  2777.             try{
  2778.                 oldTransactionIsolation = connectionDB.getTransactionIsolation();
  2779.                 connectionDB.setAutoCommit(false);
  2780.                 JDBCUtilities.setTransactionIsolationSerializable(Configurazione.getSqlQueryObjectType(), connectionDB);
  2781.             } catch(Exception er) {
  2782.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante la getBusteAsincronePerUlterioreInoltro(setIsolation): "+er.getMessage();        
  2783.                 this.log.error(errorMsg,er);
  2784.                 throw new ProtocolException(errorMsg,er);
  2785.             }

  2787.             boolean getBusteOK = false;
  2788.             java.util.List<Busta> busteNonRingraziate = new java.util.ArrayList<Busta>();   

  2790.             long scadenzaWhile = DateManager.getTimeMillis() + attesaAttiva;

  2792.             while(getBusteOK==false && DateManager.getTimeMillis() < scadenzaWhile){

  2794.                 PreparedStatement pstmt = null;
  2795.                 ResultSet rs = null;
  2796.                 java.util.List<String> IDBuste = new java.util.ArrayList<>();
  2797.                 try{    

  2799.                     long nowTime = DateManager.getTimeMillis() - (timeout * 60 * 1000);
  2800.                     java.sql.Timestamp scadenzaRingraziamento = new java.sql.Timestamp(nowTime);

  2802.                     StringBuilder query = new StringBuilder();
  2803.                     query.append("SELECT ID_MESSAGGIO FROM ");
  2804.                     query.append(Costanti.PROFILO_ASINCRONO);
  2805.                     query.append(" WHERE ORA_REGISTRAZIONE < ? AND TIPO=? AND RICEVUTA_ASINCRONA=0 AND RICEVUTA_APPLICATIVA=0 FOR UPDATE");

  2807.                     pstmt = connectionDB.prepareStatement(query.toString());
  2808.                     pstmt.setTimestamp(1,scadenzaRingraziamento);   
  2809.                     pstmt.setString(2,Costanti.OUTBOX);

  2811.                     // Esecuzione comando SQL
  2812.                     rs = pstmt.executeQuery();      
  2813.                     if(rs == null) {
  2814.                         pstmt.close();
  2815.                         return null;
  2816.                     }       
  2817.                     while(rs.next()){
  2818.                         String id = rs.getString("ID_MESSAGGIO");
  2819.                         IDBuste.add(id);
  2820.                     }
  2821.                     rs.close();
  2822.                     pstmt.close();
  2823.                     if(IDBuste.size() > 0){
  2824.                         RepositoryBuste repositoryBuste = new RepositoryBuste(stateful, this.log, this.protocolFactory);
  2825.                         for(int i=0; i<IDBuste.size();i++){
  2826.                             String id = IDBuste.get(i);
  2827.                             try{
  2828.                                 Busta busta = repositoryBuste.getBustaFromOutBox(id);
  2829.                                 busteNonRingraziate.add(busta);
  2830.                             }catch(Exception e){
  2831.                                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante la getBusteAsincronePerUlterioreInoltro (read busta ["+id+"]): "+e.getMessage();     
  2832.                                 this.log.error(errorMsg);
  2833.                             }
  2834.                         }
  2835.                     }
  2836.                     // Chiusura Transazione
  2837.                     connectionDB.commit();

  2839.                     // ID Costruito
  2840.                     getBusteOK = true;

  2842.                 } catch(Exception e) {
  2843.                     //log.error("ERROR GET BUSTA ASINCRONA PER ULTERIORE INOLTRO ["+e.getMessage()+"]");
  2844.                     try{
  2845.                         if( pstmt != null )
  2846.                             pstmt.close();
  2847.                     } catch(Exception er) {
  2848.                         // close
  2849.                     }
  2850.                     try{
  2851.                         if( rs != null )
  2852.                             rs.close();
  2853.                     } catch(Exception er) {
  2854.                         // close
  2855.                     }
  2856.                     try{
  2857.                         connectionDB.rollback();
  2858.                     } catch(Exception er) {
  2859.                         // ignore
  2860.                     }
  2861.                 }

  2863.                 if(getBusteOK == false){
  2864.                     // Per aiutare ad evitare conflitti
  2865.                     try{
  2866.                         Utilities.sleep(ProtocolRandomUtilities.getRandom().nextInt(checkInterval)); // random da 0ms a checkIntervalms
  2867.                     }catch(Exception eRandom){
  2868.                         // ignore
  2869.                     }
  2870.                 }
  2871.             }

  2873.             // Ripristino Transazione
  2874.             try{
  2875.                 connectionDB.setTransactionIsolation(oldTransactionIsolation);
  2876.                 connectionDB.setAutoCommit(true);
  2877.             } catch(Exception er) {
  2878.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante la getBusteAsincronePerUlterioreInoltro(ripristinoIsolation): "+er.getMessage();     
  2879.                 this.log.error(errorMsg,er);
  2880.                 throw new ProtocolException(errorMsg,er);
  2881.             }
  2882.             return busteNonRingraziate;
  2883.         }else if (this.state instanceof StatelessMessage){
  2884.             //CHECKME
  2885.             throw new ProtocolException("Metodo non invocabile in modalita Stateless");
  2886.         }else{
  2887.             throw new ProtocolException("Metodo invocato con IState non valido");
  2888.         }
  2889.     }


  2892.     /**
  2893.      * In caso esista nella tabella asincrona buste inviate che non sono state ringraziate da una ricevuta dopo un intervallo di tempo,
  2894.      * si occupa di ritornare un array di buste da reinviare, aggiornando le loro date di registrazione.
  2895.      *
  2896.      * @param timeout Minuti dopo il quale una data risulta scaduta.
  2897.      * @return un List di {@link org.openspcoop2.protocol.sdk.Busta} contenente le informazioni necessarie per il re-invio delle buste, 
  2898.      *         se esistono buste non ringraziate.
  2899.      */
  2900.     public List<BustaNonRiscontrata> asincrono_getBusteAsincronePerUlterioreInoltro(long timeout,int limit,int offset,boolean logQuery)throws ProtocolException{
  2901.         if(this.state instanceof StatefulMessage) {
  2902.             StatefulMessage stateful = (StatefulMessage)this.state;
  2903.             Connection connectionDB = stateful.getConnectionDB();
  2904.             
  2905.             PreparedStatement pstmt = null;
  2906.             ResultSet rs = null;
  2907.             java.util.List<String> IDBuste = new java.util.ArrayList<>();
  2908.             String queryString = null;
  2909.             try{    

  2911.                 long nowTime = DateManager.getTimeMillis()- (timeout * 60 * 1000);
  2912.                 java.sql.Timestamp scadenzaRingraziamento = new java.sql.Timestamp(nowTime);
  2913.                 IGestoreRepository gestoreRepositoryBuste = Configurazione.getGestoreRepositoryBuste();
  2914.                 
  2915.                 if(Configurazione.getSqlQueryObjectType()==null){
  2916.                     StringBuilder query = new StringBuilder();
  2917.                     query.append("SELECT ID_MESSAGGIO FROM ");
  2918.                     query.append(Costanti.PROFILO_ASINCRONO);
  2919.                     query.append(" WHERE ORA_REGISTRAZIONE < ? AND TIPO=? AND RICEVUTA_ASINCRONA=0 AND RICEVUTA_APPLICATIVA=0");
  2920.                     // Nuovo AND per la gestione stateless
  2921.                     // Le ricevute asincrone non devono cmq appartenere a buste ormai eliminate
  2922.                     query.append(" AND NOT EXISTS (SELECT ID_MESSAGGIO FROM ");
  2923.                     query.append(Costanti.REPOSITORY);
  2924.                     query.append(" WHERE ");
  2925.                     query.append(Costanti.REPOSITORY);
  2926.                     query.append(".TIPO=");
  2927.                     query.append(Costanti.PROFILO_ASINCRONO);
  2928.                     query.append(".TIPO");
  2929.                     query.append(" AND ");
  2930.                     query.append(Costanti.REPOSITORY);
  2931.                     query.append(".ID_MESSAGGIO=");
  2932.                     query.append(Costanti.PROFILO_ASINCRONO);
  2933.                     query.append(".ID_MESSAGGIO");
  2934.                     query.append(" AND ");
  2935.                     query.append(gestoreRepositoryBuste.createSQLCondition_PdD(false));
  2936.                     query.append(" AND ");
  2937.                     query.append(gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  2938.                     query.append(" ) ");
  2939.                     
  2940.                     queryString = query.toString();
  2941.                 }else{
  2942.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  2943.                     sqlQueryObject.addSelectField("ID_MESSAGGIO");
  2944.                     sqlQueryObject.addSelectField("ORA_REGISTRAZIONE");
  2945.                     sqlQueryObject.addSelectField("TIPO");
  2946.                     sqlQueryObject.addSelectField("RICEVUTA_ASINCRONA");
  2947.                     sqlQueryObject.addSelectField("RICEVUTA_APPLICATIVA");
  2948.                     sqlQueryObject.addFromTable(Costanti.PROFILO_ASINCRONO);
  2949.                     sqlQueryObject.addWhereCondition("ORA_REGISTRAZIONE < ?");
  2950.                     sqlQueryObject.addWhereCondition("TIPO=?");
  2951.                     sqlQueryObject.addWhereCondition("RICEVUTA_ASINCRONA=0");
  2952.                     sqlQueryObject.addWhereCondition("RICEVUTA_APPLICATIVA=0");
  2953.                     
  2954.                     // Nuovo AND per la gestione stateless
  2955.                     // Le ricevute asincrone non devono cmq appartenere a buste ormai eliminate
  2956.                     ISQLQueryObject sqlQueryObjectNotExists = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  2957.                     sqlQueryObjectNotExists.addFromTable(Costanti.REPOSITORY);
  2958.                     sqlQueryObjectNotExists.addSelectField(Costanti.REPOSITORY,"ID_MESSAGGIO");
  2959.                     sqlQueryObjectNotExists.addWhereCondition(Costanti.REPOSITORY+".TIPO="+Costanti.PROFILO_ASINCRONO+".TIPO");
  2960.                     sqlQueryObjectNotExists.addWhereCondition(Costanti.REPOSITORY+".ID_MESSAGGIO="+Costanti.PROFILO_ASINCRONO+".ID_MESSAGGIO");
  2961.                     sqlQueryObjectNotExists.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_PdD(false));
  2962.                     sqlQueryObjectNotExists.addWhereCondition(gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  2963.                     sqlQueryObjectNotExists.setANDLogicOperator(true);
  2964.                     sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectNotExists);
  2965.                     
  2966.                     sqlQueryObject.setANDLogicOperator(true);
  2967.                     sqlQueryObject.addOrderBy("ORA_REGISTRAZIONE"); // order by e' obbligatorio essendoci l'offset
  2968.                     sqlQueryObject.setSortType(true);
  2969.                     sqlQueryObject.setLimit(limit);
  2970.                     sqlQueryObject.setOffset(offset);
  2971.                     queryString = sqlQueryObject.createSQLQuery();
  2972.                 }

  2974.                 //System.out.println("QUERY ASINCRONO IS: ["+queryString+"] 1["+scadenzaRingraziamento+"] 2["+Costanti.OUTBOX+"]");

  2976.                 pstmt = connectionDB.prepareStatement(queryString);
  2977.                 pstmt.setTimestamp(1,scadenzaRingraziamento);   
  2978.                 pstmt.setString(2,Costanti.OUTBOX);

  2980.                 // Esecuzione comando SQL
  2981.                 long startDateSQLCommand = DateManager.getTimeMillis();
  2982.                 if(logQuery)
  2983.                     this.log.debug("[QUERY] (RicevuteAsincrone) ["+queryString+"] 1["+scadenzaRingraziamento+"] 2["+Costanti.OUTBOX+"]...");
  2984.                 rs = pstmt.executeQuery();  
  2985.                 long endDateSQLCommand = DateManager.getTimeMillis();
  2986.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  2987.                 if(logQuery)
  2988.                     this.log.debug("[QUERY] (RicevuteAsincrone) ["+queryString+"] 1["+scadenzaRingraziamento+"] 2["+Costanti.OUTBOX+"] effettuata in "+secondSQLCommand+" secondi");

  2990.                 if(rs == null) {
  2991.                     pstmt.close();
  2992.                     return null;
  2993.                 }   
  2994.                 int countLimit = 0;
  2995.                 int countOffset = 0;
  2996.                 while(rs.next()){
  2997.                     if(Configurazione.getSqlQueryObjectType()==null){
  2998.                         // OFFSET APPLICATIVO
  2999.                         if( countOffset>=offset ){
  3000.                             String id = rs.getString("ID_MESSAGGIO");
  3001.                             IDBuste.add(id);
  3002.                             // LIMIT Applicativo
  3003.                             countLimit++;
  3004.                             if(countLimit==limit)
  3005.                                 break;
  3006.                         }
  3007.                         else{
  3008.                             countOffset++;
  3009.                         }
  3010.                     }else{
  3011.                         String id = rs.getString("ID_MESSAGGIO");
  3012.                         IDBuste.add(id);
  3013.                     }
  3014.                 }
  3015.                 rs.close();
  3016.                 pstmt.close();

  3018.             } catch(Exception e) {
  3019.                 try{
  3020.                     if( rs != null )
  3021.                         rs.close();
  3022.                 } catch(Exception er) {
  3023.                     // close
  3024.                 }
  3025.                 try{
  3026.                     if( pstmt != null )
  3027.                         pstmt.close();
  3028.                 } catch(Exception er) {
  3029.                     // close
  3030.                 }
  3031.                 String errorMsg = "[ProfiloDiCollaborazione.asincrono_getBusteAsincronePerUlterioreInoltro] errore, queryString["+queryString+"]: "+e.getMessage();
  3032.                 this.log.error(errorMsg,e);
  3033.                 throw new  ProtocolException(errorMsg,e);
  3034.             }

  3036.             List<BustaNonRiscontrata> listaBustaNonRiscontrata = new ArrayList<BustaNonRiscontrata>();
  3037.             for (int i = 0; i < IDBuste.size(); i++) {
  3038.                 BustaNonRiscontrata bustaNonRiscontrata = new BustaNonRiscontrata();
  3039.                 bustaNonRiscontrata.setIdentificativo(IDBuste.get(i));
  3040.                 PreparedStatement pstmtReadProfilo = null;
  3041.                 ResultSet rsReadProfilo = null;
  3042.                 try{
  3043.                     
  3044.                     if(Configurazione.getSqlQueryObjectType()==null){
  3045.                         StringBuilder query = new StringBuilder();
  3046.                         query.append("SELECT PROFILO_DI_COLLABORAZIONE FROM ");
  3047.                         query.append(Costanti.REPOSITORY);
  3048.                         query.append(" WHERE ID_MESSAGGIO=? AND TIPO=? ");
  3049.                         queryString = query.toString();
  3050.                     }
  3051.                     else{
  3052.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  3053.                         sqlQueryObject.addSelectField("PROFILO_DI_COLLABORAZIONE");
  3054.                         sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  3055.                         sqlQueryObject.addWhereCondition("ID_MESSAGGIO=?");
  3056.                         sqlQueryObject.addWhereCondition("TIPO=?");
  3057.                         sqlQueryObject.setANDLogicOperator(true);
  3058.                         queryString = sqlQueryObject.createSQLQuery();
  3059.                     }
  3060.                     
  3061.                     pstmtReadProfilo = connectionDB.prepareStatement(queryString);
  3062.                     pstmtReadProfilo.setString(1,bustaNonRiscontrata.getIdentificativo());  
  3063.                     pstmtReadProfilo.setString(2,Costanti.OUTBOX);
  3064.                     rsReadProfilo = pstmtReadProfilo.executeQuery();    
  3065.                     
  3066.                     if(rsReadProfilo.next())
  3067.                         bustaNonRiscontrata.setProfiloCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.toProfiloDiCollaborazione(rsReadProfilo.getString("PROFILO_DI_COLLABORAZIONE")));
  3068.                     
  3069.                     listaBustaNonRiscontrata.add(bustaNonRiscontrata);
  3070.                     
  3071.                 } catch(Exception e) {
  3072.                     String errorMsg = "[ProfiloDiCollaborazione.asincrono_getBusteAsincronePerUlterioreInoltro] errore, queryString["+queryString+"]: "+e.getMessage();
  3073.                     this.log.error(errorMsg,e);
  3074.                     throw new  ProtocolException(errorMsg,e);
  3075.                 }
  3076.                 finally{
  3077.                     try{
  3078.                         if( rsReadProfilo != null )
  3079.                             rsReadProfilo.close();
  3080.                     } catch(Exception er) {
  3081.                         // close
  3082.                     }
  3083.                     try{
  3084.                         if( pstmtReadProfilo != null )
  3085.                             pstmtReadProfilo.close();
  3086.                     } catch(Exception er) {
  3087.                         // close
  3088.                     }
  3089.                 }
  3090.             }
  3091.             
  3092.             return listaBustaNonRiscontrata;
  3093.         }else if (this.state instanceof StatelessMessage){
  3094.             throw new ProtocolException("Metodo non invocabile in modalita stateless");
  3095.         }else{
  3096.             throw new ProtocolException("Metodo invocato con IState non valido");
  3097.         }
  3098.     }



  3102.     /**
  3103.      * Indicazione se la busta e' una ricevuta asincrona di una richiesta
  3104.      * 
  3105.      * @param riferimentoMessaggio Riferimento Messaggio della ricevuta
  3106.      */
  3107.     public boolean asincrono_isRicevutaRichiesta(String riferimentoMessaggio)throws ProtocolException{
  3108.         return asincrono_isRicevuta(riferimentoMessaggio,true);
  3109.     }

  3111.     /**
  3112.      * Indicazione se la busta e' una ricevuta asincrona di una richiestaStato/Risposta
  3113.      * 
  3114.      * @param riferimentoMessaggio Riferimento Messaggio della ricevuta
  3115.      */
  3116.     public boolean asincrono_isRicevutaRisposta(String riferimentoMessaggio)throws ProtocolException{
  3117.         return asincrono_isRicevuta(riferimentoMessaggio,false);
  3118.     }


  3121.     /**
  3122.      * Indicazione se la busta e' una ricevuta asincrona
  3123.      * 
  3124.      * @param riferimentoMessaggio Riferimento Messaggio della ricevuta
  3125.      * @param isRicevutaRichiesta Se il check deve controllare che sia una ricevuta di una richiesta
  3126.      */
  3127.     private boolean asincrono_isRicevuta(String riferimentoMessaggio,boolean isRicevutaRichiesta)throws ProtocolException{
  3128.         StateMessage state = (StateMessage)this.state;
  3129.         Connection connectionDB = state.getConnectionDB();
  3130.         PreparedStatement pstmt = null;
  3131.         ResultSet rs = null;
  3132.         try{    

  3134.             StringBuilder query = new StringBuilder();
  3135.             query.append("SELECT ID_ASINCRONO FROM ");
  3136.             query.append(Costanti.PROFILO_ASINCRONO);
  3137.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=? AND RICEVUTA_ASINCRONA=0");

  3139.             pstmt = connectionDB.prepareStatement(query.toString());
  3140.             pstmt.setString(1,riferimentoMessaggio);
  3141.             pstmt.setString(2,Costanti.OUTBOX);
  3142.             rs = pstmt.executeQuery();      
  3143.             if(rs == null) {
  3144.                 throw new ProtocolException("RS Null?");            
  3145.             }
  3146.             boolean value = false;
  3147.             if(rs.next()){
  3148.                 if(riferimentoMessaggio.equals(rs.getString("ID_ASINCRONO"))){
  3149.                     value = isRicevutaRichiesta;
  3150.                 }else{
  3151.                     value = !isRicevutaRichiesta;
  3152.                 }
  3153.             }

  3155.             rs.close();
  3156.             pstmt.close();

  3158.             return value;

  3160.         } catch(Exception e) {
  3161.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, isRicevutaAsincrono "+riferimentoMessaggio+": "+e.getMessage();     
  3162.             this.log.error(errorMsg,e);
  3163.             try{
  3164.                 if( rs != null )
  3165.                     rs.close();
  3166.             } catch(Exception er) {
  3167.                 // Eccezione SQL.
  3168.             }
  3169.             try{
  3170.                 if( pstmt != null )
  3171.                     pstmt.close();
  3172.             } catch(Exception er) {
  3173.                 // Eccezione SQL.
  3174.             }
  3175.             throw new ProtocolException(errorMsg,e);
  3176.         }
  3177.     }

  3179.     /**
  3180.      * Valida una ricevuta asincrona, identificato dall'identificativo della busta.
  3181.      * In caso di validazione della ricevuta, l'entry nella tabella PROFILO Asincrono 
  3182.      * viene aggiornata con RICEVUTA_ASINCRONA=1 se IS_RICHIESTA=1, altrimenti viene eliminata
  3183.      *
  3184.      * @param ricevuta busta da validare.
  3185.      * @deprecated utilizzare la versione non serializable 
  3186.      * 
  3187.      */
  3188.     @Deprecated
  3189.     public void asincrono_valdazioneRicevuta_serializable(Busta ricevuta) throws ProtocolException{
  3190.         asincrono_validazioneRicevuta_serializable(ricevuta,60l,100);
  3191.     }


  3194.     /**
  3195.      * Valida una ricevuta asincrona, identificato dall'identificativo della busta.
  3196.      * In caso di validazione della ricevuta, l'entry nella tabella PROFILO Asincrono 
  3197.      * viene aggiornata con RICEVUTA_ASINCRONA=1 se IS_RICHIESTA=1, altrimenti viene eliminata
  3198.      *
  3199.      * @param ricevuta busta da validare.
  3200.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  3201.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  3202.      * @deprecated utilizzare la versione non serializable 
  3203.      */
  3204.     @Deprecated
  3205.     public void asincrono_validazioneRicevuta_serializable(Busta ricevuta,long attesaAttiva,int checkInterval) throws ProtocolException{
  3206.         if(this.state instanceof StatefulMessage) {
  3207.             StatefulMessage stateful = (StatefulMessage)this.state;
  3208.             Connection connectionDB = stateful.getConnectionDB();
  3209.             String idRicevuta = ricevuta.getRiferimentoMessaggio();

  3211.             /*
  3212.              * Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  3213.              *  di leggere solo le indicazioni di richieste asincrone committate,
  3214.              * e comunque rispedira' anche le buste eliminate, ma non committate.
  3215.              */
  3216.             // setAutoCommit e livello Isolamento
  3217.             int oldTransactionIsolation = -1;
  3218.             try{
  3219.                 oldTransactionIsolation = connectionDB.getTransactionIsolation();
  3220.                 connectionDB.setAutoCommit(false);
  3221.                 JDBCUtilities.setTransactionIsolationSerializable(Configurazione.getSqlQueryObjectType(), connectionDB);
  3222.             } catch(Exception er) {
  3223.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante la validazioneRicevutaAsincrona "+idRicevuta+"(setIsolation): "+er.getMessage();     
  3224.                 this.log.error(errorMsg,er);
  3225.                 throw new ProtocolException(errorMsg,er);
  3226.             }


  3229.             boolean validazioneRicevutaOK = false;

  3231.             long scadenzaWhile = DateManager.getTimeMillis() + attesaAttiva;

  3233.             while(validazioneRicevutaOK==false && DateManager.getTimeMillis() < scadenzaWhile){

  3235.                 PreparedStatement pstmtValidazione = null;
  3236.                 PreparedStatement pstmt = null;
  3237.                 ResultSet rs = null;
  3238.                 try{

  3240.                     // Check flusso asincrono: richiesta/ricevuta  o  risposta(richiestaStato)/ricevuta(Risposta)
  3241.                     StringBuilder query = new StringBuilder();
  3242.                     query.append("SELECT IS_RICHIESTA,RICEVUTA_ASINCRONA,ID_ASINCRONO FROM ");
  3243.                     query.append(Costanti.PROFILO_ASINCRONO);
  3244.                     query.append(" WHERE ID_MESSAGGIO=? AND TIPO=? FOR UPDATE");
  3245.                     pstmt = connectionDB.prepareStatement(query.toString());
  3246.                     pstmt.setString(1,idRicevuta);
  3247.                     pstmt.setString(2,Costanti.OUTBOX);

  3249.                     // Esecuzione comando SQL
  3250.                     rs = pstmt.executeQuery();      
  3251.                     if(rs == null) {
  3252.                         throw new ProtocolException("RS Null?");    
  3253.                     }
  3254.                     boolean isRichiesta = false;
  3255.                     boolean validaRicevuta = false;
  3256.                     String idCollaborazione = null;
  3257.                     if(rs.next()==false){
  3258.                         rs.close();
  3259.                         pstmt.close();
  3260.                         return; // l'entry non e' presente...
  3261.                     }else{
  3262.                         if(rs.getInt("IS_RICHIESTA")==1)
  3263.                             isRichiesta = true;
  3264.                         if(rs.getInt("RICEVUTA_ASINCRONA")==0)
  3265.                             validaRicevuta = true;
  3266.                         idCollaborazione = rs.getString("ID_ASINCRONO");
  3267.                     }
  3268.                     rs.close();
  3269.                     pstmt.close();

  3271.                     if(validaRicevuta==false){
  3272.                         String tipoRicevuta = "ricevuta di una richiesta asincrona";
  3273.                         if(isRichiesta == false)
  3274.                             tipoRicevuta = "ricevuta di una risposta asincrona";
  3275.                         this.log.warn("Validazione "+tipoRicevuta+" non effettuata, poiche' inutile: ricevuta precedentemente gia' analizzata.");
  3276.                     }

  3278.                     if(isRichiesta){
  3279.                         // Aggiorno valore ricevuta
  3280.                         query.delete(0,query.length());
  3281.                         query.append("UPDATE ");
  3282.                         query.append(Costanti.PROFILO_ASINCRONO);
  3283.                         if(ricevuta.getServizioCorrelato()!=null && org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(ricevuta.getProfiloDiCollaborazione())){
  3284.                             query.append(" SET RICEVUTA_ASINCRONA=1,IS_RICHIESTA=0,TIPO_SERVIZIO_CORRELATO=?,SERVIZIO_CORRELATO=?,VERSIONE_SERVIZIO_CORRELATO=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  3285.                             pstmtValidazione = connectionDB.prepareStatement(query.toString());
  3286.                             pstmtValidazione.setString(1,ricevuta.getTipoServizioCorrelato());
  3287.                             pstmtValidazione.setString(2,ricevuta.getServizioCorrelato());
  3288.                             if(ricevuta.getVersioneServizioCorrelato()!=null){
  3289.                                 pstmt.setInt(3,ricevuta.getVersioneServizioCorrelato());
  3290.                             }
  3291.                             else{
  3292.                                 pstmt.setNull(3, java.sql.Types.INTEGER);
  3293.                             }
  3294.                             pstmtValidazione.setString(4,idRicevuta);
  3295.                             pstmtValidazione.setString(5,Costanti.OUTBOX);
  3296.                         }else{
  3297.                             query.append(" SET RICEVUTA_ASINCRONA=1,IS_RICHIESTA=0 WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  3298.                             pstmtValidazione = connectionDB.prepareStatement(query.toString());
  3299.                             pstmtValidazione.setString(1,idRicevuta);
  3300.                             pstmtValidazione.setString(2,Costanti.OUTBOX);
  3301.                         }
  3302.                         pstmtValidazione.execute();
  3303.                         pstmtValidazione.close();
  3304.                     }else{

  3306.                         // la busta ricevuta/inviata, come richiesta, necessaria per l'invio della risposta, non serve piu'.
  3307.                         if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(ricevuta.getProfiloDiCollaborazione())){
  3308.                             this.eliminaBustaRicevuta(idCollaborazione);
  3309.                         }else{
  3310.                             this.eliminaBustaInviata(idCollaborazione);
  3311.                         }   

  3313.                         // Elimino entry solo per il profilo asincrono simmetrico
  3314.                         if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(ricevuta.getProfiloDiCollaborazione())){
  3315.                             query.delete(0,query.capacity());
  3316.                             query.append("DELETE FROM ");
  3317.                             query.append(Costanti.PROFILO_ASINCRONO);
  3318.                             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  3319.                             pstmtValidazione = connectionDB.prepareStatement(query.toString());
  3320.                             pstmtValidazione.setString(1,idRicevuta);
  3321.                             pstmtValidazione.setString(2,Costanti.OUTBOX);
  3322.                             pstmtValidazione.execute();
  3323.                             pstmtValidazione.close();
  3324.                         }

  3326.                         // Eliminazione accesso_profilo per l'invio della busta di risposta/richiesta stato
  3327.                         this.eliminaBustaInviata(idRicevuta);

  3329.                         stateful.executePreparedStatement();
  3330.                     }

  3332.                     // Chiusura Transazione
  3333.                     connectionDB.commit();

  3335.                     // ID Costruito
  3336.                     validazioneRicevutaOK = true;

  3338.                 } catch(Throwable e) {
  3339.                     try{
  3340.                         if( rs != null  )
  3341.                             rs.close();
  3342.                     } catch(Exception er) {
  3343.                         // close
  3344.                     }
  3345.                     try{
  3346.                         if( pstmt != null  )
  3347.                             pstmt.close();
  3348.                     } catch(Exception er) {
  3349.                         // close
  3350.                     }
  3351.                     try{
  3352.                         if( pstmtValidazione != null  )
  3353.                             pstmtValidazione.close();
  3354.                     } catch(Exception er) {
  3355.                         // close
  3356.                     }
  3357.                     try{
  3358.                         connectionDB.rollback();
  3359.                     } catch(Exception er) {
  3360.                         // ignore
  3361.                     }
  3362.                 }

  3364.                 if(validazioneRicevutaOK == false){
  3365.                     // Per aiutare ad evitare conflitti
  3366.                     try{
  3367.                         Utilities.sleep(ProtocolRandomUtilities.getRandom().nextInt(checkInterval)); // random da 0ms a checkIntervalms
  3368.                     }catch(Exception eRandom){
  3369.                         // ignore
  3370.                     }
  3371.                 }
  3372.             }

  3374.             // Ripristino Transazione
  3375.             try{
  3376.                 connectionDB.setTransactionIsolation(oldTransactionIsolation);
  3377.                 connectionDB.setAutoCommit(true);
  3378.             } catch(Exception er) {
  3379.                 String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante la validazioneRicevutaAsincrona "+idRicevuta+"(ripristinoIsolation): "+er.getMessage();      
  3380.                 this.log.error(errorMsg,er);
  3381.                 throw new ProtocolException(errorMsg,er);
  3382.             }
  3383.         }else{
  3384.             throw new ProtocolException("Metodo invocato con IState non valido");
  3385.         }
  3386.     }   

  3388.     /**
  3389.      * Valida una ricevuta asincrona, identificato dall'identificativo della busta.
  3390.      * In caso di validazione della ricevuta, l'entry nella tabella PROFILO Asincrono 
  3391.      * viene aggiornata con RICEVUTA_ASINCRONA=1 se IS_RICHIESTA=1, altrimenti viene eliminata
  3392.      *
  3393.      * @param ricevuta busta da validare. 
  3394.      * 
  3395.      */
  3396.     public void asincrono_valdazioneRicevuta(Busta ricevuta) throws ProtocolException{
  3397.         StateMessage state = (StateMessage)this.state;
  3398.         Connection connectionDB = state.getConnectionDB();
  3399.         String idRicevuta = ricevuta.getRiferimentoMessaggio();

  3401.         PreparedStatement pstmtValidazione = null;
  3402.         PreparedStatement pstmt = null;
  3403.         ResultSet rs = null;
  3404.         try{

  3406.             // Check flusso asincrono: richiesta/ricevuta  o  risposta(richiestaStato)/ricevuta(Risposta)
  3407.             StringBuilder query = new StringBuilder();
  3408.             query.append("SELECT IS_RICHIESTA,RICEVUTA_ASINCRONA,ID_ASINCRONO FROM ");
  3409.             query.append(Costanti.PROFILO_ASINCRONO);
  3410.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  3411.             pstmt = connectionDB.prepareStatement(query.toString());
  3412.             pstmt.setString(1,idRicevuta);
  3413.             pstmt.setString(2,Costanti.OUTBOX);

  3415.             // Esecuzione comando SQL
  3416.             rs = pstmt.executeQuery();      
  3417.             if(rs == null) {
  3418.                 throw new ProtocolException("RS Null?");    
  3419.             }
  3420.             boolean isRichiesta = false;
  3421.             boolean validaRicevuta = false;
  3422.             String idCollaborazione = null;
  3423.             if(rs.next()==false){
  3424.                 rs.close();
  3425.                 pstmt.close();
  3426.                 return; // l'entry non e' presente...
  3427.             }else{
  3428.                 if(rs.getInt("IS_RICHIESTA")==1)
  3429.                     isRichiesta = true;
  3430.                 if(rs.getInt("RICEVUTA_ASINCRONA")==0)
  3431.                     validaRicevuta = true;
  3432.                 idCollaborazione = rs.getString("ID_ASINCRONO");
  3433.             }
  3434.             rs.close();
  3435.             pstmt.close();

  3437.             if(validaRicevuta==false){
  3438.                 String tipoRicevuta = "ricevuta di una richiesta asincrona";
  3439.                 if(isRichiesta == false)
  3440.                     tipoRicevuta = "ricevuta di una risposta asincrona";
  3441.                 this.log.warn("Validazione "+tipoRicevuta+" non effettuata, poiche' inutile: ricevuta precedentemente gia' analizzata.");
  3442.             }

  3444.             if(isRichiesta){
  3445.                 // Aggiorno valore ricevuta
  3446.                 query.delete(0,query.length());
  3447.                 query.append("UPDATE ");
  3448.                 query.append(Costanti.PROFILO_ASINCRONO);
  3449.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(ricevuta.getProfiloDiCollaborazione())){
  3450.                     String tipoServizioCorrelato = ricevuta.getTipoServizioCorrelato();
  3451.                     String servizioCorrelato = ricevuta.getServizioCorrelato();
  3452.                     Integer versioneServizioCorrelato = ricevuta.getVersioneServizioCorrelato();
  3453.                     if(servizioCorrelato==null || tipoServizioCorrelato==null || versioneServizioCorrelato==null){
  3454.                         IDSoggetto fruitore = new IDSoggetto(ricevuta.getTipoDestinatario(),ricevuta.getDestinatario());
  3455.                         IDServizio servizio = IDServizioFactory.getInstance().getIDServizioFromValues(ricevuta.getTipoServizio(),ricevuta.getServizio(), 
  3456.                                 ricevuta.getTipoMittente(),ricevuta.getMittente(), 
  3457.                                 ricevuta.getVersioneServizio());
  3458.                         servizio.setAzione(ricevuta.getAzione());
  3459.                         RisultatoValidazione validazione = RegistroServiziManager.getInstance(state).validaServizio(fruitore,servizio,null);
  3460.                         if( (validazione==null) || (validazione.getServizioRegistrato()==false))
  3461.                             throw new Exception("Servizio ["+servizio.toString()+"] non esiste nel registro dei servizi");
  3462.                         if( (validazione.getServizioCorrelato()==null) || (validazione.getTipoServizioCorrelato()==null) || (validazione.getVersioneServizioCorrelato()==null) )
  3463.                             throw new Exception("Servizio ["+servizio.toString()+"] non possiede un servizio correlato associato");
  3464.                         tipoServizioCorrelato = validazione.getTipoServizioCorrelato();
  3465.                         servizioCorrelato = validazione.getServizioCorrelato();
  3466.                         versioneServizioCorrelato = validazione.getVersioneServizioCorrelato();
  3467.                     }
  3468.                     query.append(" SET RICEVUTA_ASINCRONA=1,IS_RICHIESTA=0,TIPO_SERVIZIO_CORRELATO=?,SERVIZIO_CORRELATO=?,VERSIONE_SERVIZIO_CORRELATO=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  3469.                     pstmtValidazione = connectionDB.prepareStatement(query.toString());
  3470.                     pstmtValidazione.setString(1,tipoServizioCorrelato);
  3471.                     pstmtValidazione.setString(2,servizioCorrelato);
  3472.                     if(versioneServizioCorrelato!=null){
  3473.                         pstmtValidazione.setInt(3,versioneServizioCorrelato);
  3474.                     }
  3475.                     else{
  3476.                         pstmtValidazione.setNull(3, java.sql.Types.INTEGER);
  3477.                     }
  3478.                     pstmtValidazione.setString(4,idRicevuta);
  3479.                     pstmtValidazione.setString(5,Costanti.OUTBOX);
  3480.                 }
  3481.                 else{
  3482.                     query.append(" SET RICEVUTA_ASINCRONA=1,IS_RICHIESTA=0 WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  3483.                     pstmtValidazione = connectionDB.prepareStatement(query.toString());
  3484.                     pstmtValidazione.setString(1,idRicevuta);
  3485.                     pstmtValidazione.setString(2,Costanti.OUTBOX);
  3486.                 }

  3488.                 //  Add PreparedStatement
  3489.                 state.getPreparedStatement().put("UPDATE validazioneRicevutaRichiestaAsincrona_"+idRicevuta,pstmtValidazione);

  3491.             }else{

  3493.                 // la busta ricevuta/inviata, come richiesta, necessaria per l'invio della risposta, non serve piu'.
  3494.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(ricevuta.getProfiloDiCollaborazione())){
  3495.                     this.eliminaBustaRicevuta(idCollaborazione,true);
  3496.                 }else{
  3497.                     this.eliminaBustaInviata(idCollaborazione,true);
  3498.                 }   

  3500.                 // Elimino entry solo per il profilo asincrono simmetrico
  3501.                 if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(ricevuta.getProfiloDiCollaborazione())){
  3502.                     query.delete(0,query.capacity());
  3503.                     query.append("DELETE FROM ");
  3504.                     query.append(Costanti.PROFILO_ASINCRONO);
  3505.                     query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  3506.                     pstmtValidazione =  connectionDB.prepareStatement(query.toString());
  3507.                     pstmtValidazione.setString(1,idRicevuta);
  3508.                     pstmtValidazione.setString(2,Costanti.OUTBOX);

  3510.                     //  Add PreparedStatement
  3511.                     state.getPreparedStatement().put("UPDATE validazioneRicevutaRispostaAsincrona_"+idRicevuta,pstmtValidazione);
  3512.                 }

  3514.                 // Eliminazione accesso_profilo per l'invio della busta di risposta/richiesta stato
  3515.                 this.eliminaBustaInviata(idRicevuta,true);

  3517.             }

  3519.         } catch(Exception e) {
  3520.             try{
  3521.                 if( rs != null  )
  3522.                     rs.close();
  3523.             } catch(Exception er) {
  3524.                 // close
  3525.             }
  3526.             try{
  3527.                 if( pstmt != null  )
  3528.                     pstmt.close();
  3529.             } catch(Exception er) {
  3530.                 // close
  3531.             }
  3532.             try{
  3533.                 if( pstmtValidazione != null  )
  3534.                     pstmtValidazione.close();
  3535.             } catch(Exception er) {
  3536.                 // close
  3537.             }
  3538.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante la validazioneRicevutaAsincrona "+idRicevuta+": "+e.getMessage();        
  3539.             this.log.error(errorMsg,e);
  3540.             throw new ProtocolException(errorMsg,e);
  3541.         }

  3543.     }


  3546.     /**
  3547.      * Ritorna lo stato di una gestione asincrona, true se e' legittimo gestire una richiesta-stato/Risposta, false altrimenti.
  3548.      *
  3549.      * @param busta busta da controllare
  3550.      * @return true se e' una risposta asincrona.
  3551.      * 
  3552.      */
  3553.     public boolean asincrono_isRisposta(Busta busta) throws ProtocolException{
  3554.         StateMessage state = (StateMessage)this.state;
  3555.         Connection connectionDB = state.getConnectionDB();
  3556.         PreparedStatement pstmt = null;
  3557.         ResultSet rs = null;
  3558.         try{

  3560.             // NOTA:
  3561.             //   una busta asincrona RISPOSTA puo avere riferimentoMessaggio o collaborazione

  3563.             if(busta.getRiferimentoMessaggio()==null && busta.getCollaborazione()==null)
  3564.                 return false;

  3566.             StringBuilder query = new StringBuilder();
  3567.             query.append("SELECT * FROM ");
  3568.             query.append(Costanti.PROFILO_ASINCRONO);
  3569.             query.append(" WHERE ");
  3570.             if(busta.getRiferimentoMessaggio()!=null && busta.getCollaborazione()!=null){
  3571.                 query.append(" (ID_MESSAGGIO=? OR ID_MESSAGGIO=?) ");
  3572.             }else {
  3573.                 query.append(" ID_MESSAGGIO=? ");
  3574.             }
  3575.             query.append(" AND TIPO=?");

  3577.             String tipo = null;
  3578.             if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione())){
  3579.                 // asincrono simmetrico
  3580.                 tipo=Costanti.OUTBOX;
  3581.             }else{
  3582.                 // asincrono asimmetrico
  3583.                 tipo=Costanti.INBOX;
  3584.             }

  3586.             pstmt = connectionDB.prepareStatement(query.toString());
  3587.             if(busta.getRiferimentoMessaggio()!=null && busta.getCollaborazione()!=null){
  3588.                 pstmt.setString(1,busta.getRiferimentoMessaggio());
  3589.                 pstmt.setString(2,busta.getCollaborazione());
  3590.                 pstmt.setString(3,tipo);
  3591.             }else if(busta.getRiferimentoMessaggio()!=null){ 
  3592.                 pstmt.setString(1,busta.getRiferimentoMessaggio());
  3593.                 pstmt.setString(2,tipo);
  3594.             }else{
  3595.                 pstmt.setString(1,busta.getCollaborazione());
  3596.                 pstmt.setString(2,tipo);
  3597.             }

  3599.             rs = pstmt.executeQuery();  
  3600.             if(rs == null) {
  3601.                 throw new ProtocolException("RS Null?");            
  3602.             }
  3603.             boolean value = false;
  3604.             if(rs.next()){
  3605.                 if( (rs.getInt("IS_RICHIESTA")==0) &&
  3606.                         (rs.getInt("RICEVUTA_ASINCRONA")==1) &&
  3607.                         (rs.getString("TIPO_SERVIZIO_CORRELATO")!=null) &&
  3608.                         (rs.getString("TIPO_SERVIZIO_CORRELATO").equals(busta.getTipoServizio())) &&
  3609.                         (rs.getString("SERVIZIO_CORRELATO")!=null) &&
  3610.                         (rs.getString("SERVIZIO_CORRELATO").equals(busta.getServizio())) &&
  3611.                         (rs.getInt("VERSIONE_SERVIZIO_CORRELATO") == busta.getVersioneServizio().intValue()) 
  3612.                 )
  3613.                     value = true;
  3614.             }

  3616.             rs.close();
  3617.             pstmt.close();

  3619.             return value;

  3621.         }catch(Exception e){    
  3622.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, asincrono_isRisposta "+busta.getRiferimentoMessaggio()+": "+e.getMessage();
  3623.             this.log.error(errorMsg,e);
  3624.             try{
  3625.                 if( rs != null )
  3626.                     rs.close();
  3627.             } catch(Exception er) {
  3628.                 // Eccezione SQL.
  3629.             }
  3630.             try{
  3631.                 if( pstmt != null )
  3632.                     pstmt.close();
  3633.             } catch(Exception er) {
  3634.                 // Eccezione SQL.
  3635.             }
  3636.             throw new ProtocolException(errorMsg,e);
  3637.         }
  3638.     }

  3640.     /**
  3641.      * Ritorna l'indicazione se la gestione di una ricevuta applicativa e' abilitata o meno
  3642.      *
  3643.      * @param id ID per la gestione del profilo Asincrono
  3644.      * @return true se la ricevuta applicativa e' abilitato.
  3645.      * 
  3646.      */
  3647.     public boolean asincrono_ricevutaApplicativaAbilitata(String id) throws ProtocolException{
  3648.         StateMessage state = (StateMessage)this.state;
  3649.         Connection connectionDB = state.getConnectionDB();
  3650.         PreparedStatement pstmt = null;
  3651.         ResultSet rs = null;
  3652.         try{
  3653.             StringBuilder query = new StringBuilder();
  3654.             query.append("SELECT * FROM ");
  3655.             query.append(Costanti.PROFILO_ASINCRONO);
  3656.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  3658.             pstmt = connectionDB.prepareStatement(query.toString());
  3659.             pstmt.setString(1,id);
  3660.             pstmt.setString(2,Costanti.OUTBOX);
  3661.             rs = pstmt.executeQuery();      
  3662.             if(rs == null) {
  3663.                 throw new ProtocolException("RS Null?");            
  3664.             }
  3665.             if(rs.next()){
  3666.                 if( rs.getInt("RICEVUTA_APPLICATIVA")==0 ){
  3667.                     rs.close();
  3668.                     pstmt.close();
  3669.                     return false;
  3670.                 }
  3671.                 else{
  3672.                     rs.close();
  3673.                     pstmt.close();
  3674.                     return true;
  3675.                 }
  3676.             }

  3678.             throw new Exception("?Valore non trovato nella tabella asincrona?");

  3680.         }catch(Exception e){    
  3681.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, asincrono_ricevutaApplicativaAbilitata "+id+": "+e.getMessage();
  3682.             this.log.error(errorMsg,e);
  3683.             try{
  3684.                 if( rs != null )
  3685.                     rs.close();
  3686.             } catch(Exception er) {
  3687.                 // Eccezione SQL.
  3688.             }
  3689.             try{
  3690.                 if( pstmt != null )
  3691.                     pstmt.close();
  3692.             } catch(Exception er) {
  3693.                 // Eccezione SQL.
  3694.             }
  3695.             throw new ProtocolException(errorMsg,e);
  3696.         }
  3697.     }

  3699.     /**
  3700.      * Ritorna l'indicazione se e' in corso la gestione di una richiesta asincrona
  3701.      *
  3702.      * @param id ID per la gestione del profilo Asincrono
  3703.      * @return true se la ricevuta applicativa e' abilitato.
  3704.      * 
  3705.      */
  3706.     public boolean asincrono_spedizioneRichiestaInCorso(String id) throws ProtocolException{
  3707.         StateMessage state = (StateMessage)this.state;
  3708.         Connection connectionDB = state.getConnectionDB();
  3709.         PreparedStatement pstmt = null;
  3710.         ResultSet rs = null;
  3711.         try{
  3712.             StringBuilder query = new StringBuilder();
  3713.             query.append("SELECT IS_RICHIESTA,RICEVUTA_ASINCRONA FROM ");
  3714.             query.append(Costanti.PROFILO_ASINCRONO);
  3715.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  3717.             pstmt = connectionDB.prepareStatement(query.toString());
  3718.             pstmt.setString(1,id);
  3719.             pstmt.setString(2,Costanti.OUTBOX);
  3720.             rs = pstmt.executeQuery();      
  3721.             if(rs == null) {
  3722.                 throw new ProtocolException("RS Null?");            
  3723.             }
  3724.             if(rs.next()){
  3725.                 if( rs.getInt("IS_RICHIESTA")==1 &&
  3726.                         rs.getInt("RICEVUTA_ASINCRONA")==0  ){
  3727.                     rs.close();
  3728.                     pstmt.close();
  3729.                     return true;
  3730.                 }
  3731.                 else{
  3732.                     rs.close();
  3733.                     pstmt.close();
  3734.                     return false;
  3735.                 }
  3736.             }

  3738.             rs.close();
  3739.             pstmt.close();
  3740.             return false;

  3742.         }catch(Exception e){    
  3743.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, asincrono_spedizioneRichiestaInCorso "+id+": "+e.getMessage();
  3744.             this.log.error(errorMsg,e);
  3745.             try{
  3746.                 if( rs != null )
  3747.                     rs.close();
  3748.             } catch(Exception er) {
  3749.                 // Eccezione SQL.
  3750.             }
  3751.             try{
  3752.                 if( pstmt != null )
  3753.                     pstmt.close();
  3754.             } catch(Exception er) {
  3755.                 // Eccezione SQL.
  3756.             }
  3757.             throw new ProtocolException(errorMsg,e);
  3758.         }
  3759.     }

  3761.     /**
  3762.      * Ritorna l'indicazione se e' in corso la gestione di una risposta asincrona
  3763.      *
  3764.      * @param id ID per la gestione del profilo Asincrono
  3765.      * @return true se la ricevuta applicativa e' abilitato.
  3766.      * 
  3767.      */
  3768.     public boolean asincrono_spedizioneRispostaInCorso(String id) throws ProtocolException{

  3770.         StateMessage state = (StateMessage)this.state;
  3771.         Connection connectionDB = state.getConnectionDB();
  3772.         PreparedStatement pstmt = null;
  3773.         ResultSet rs = null;
  3774.         try{
  3775.             StringBuilder query = new StringBuilder();
  3776.             query.append("SELECT IS_RICHIESTA,RICEVUTA_ASINCRONA FROM ");
  3777.             query.append(Costanti.PROFILO_ASINCRONO);
  3778.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");

  3780.             pstmt = connectionDB.prepareStatement(query.toString());
  3781.             pstmt.setString(1,id);
  3782.             pstmt.setString(2,Costanti.OUTBOX);
  3783.             rs = pstmt.executeQuery();      
  3784.             if(rs == null) {
  3785.                 throw new ProtocolException("RS Null?");            
  3786.             }
  3787.             if(rs.next()){
  3788.                 if( rs.getInt("IS_RICHIESTA")==0 &&
  3789.                         rs.getInt("RICEVUTA_ASINCRONA")==0  ){
  3790.                     rs.close();
  3791.                     pstmt.close();
  3792.                     return true;
  3793.                 }
  3794.                 else{
  3795.                     rs.close();
  3796.                     pstmt.close();
  3797.                     return false;
  3798.                 }
  3799.             }

  3801.             rs.close();
  3802.             pstmt.close();
  3803.             return false;

  3805.         }catch(Exception e){    
  3806.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, asincrono_spedizioneRispostaInCorso "+id+": "+e.getMessage();
  3807.             this.log.error(errorMsg,e);
  3808.             try{
  3809.                 if( rs != null )
  3810.                     rs.close();
  3811.             } catch(Exception er) {
  3812.                 // Eccezione SQL.
  3813.             }
  3814.             try{
  3815.                 if( pstmt != null )
  3816.                     pstmt.close();
  3817.             } catch(Exception er) {
  3818.                 // Eccezione SQL.
  3819.             }
  3820.             throw new ProtocolException(errorMsg,e);
  3821.         }
  3822.     }

  3824.     /**
  3825.      * Elimina i dati salvati per la gestione di un profilo asicrono.
  3826.      *
  3827.      * @param id Identificativo.
  3828.      * @param tipoBusta INBOX/OUTBOX
  3829.      * 
  3830.      */
  3831.     public void asincrono_eliminaRegistrazione(String id,String tipoBusta, Date data) throws ProtocolException{
  3832.         StateMessage state = (StateMessage)this.state;
  3833.         Connection connectionDB = state.getConnectionDB();
  3834.         PreparedStatement pstmt = null;
  3835.         try{    
  3836.             StringBuilder query = new StringBuilder();
  3837.             query.append("DELETE FROM ");
  3838.             query.append(Costanti.PROFILO_ASINCRONO);
  3839.             query.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  3840.             if(data!=null) {
  3841.                 query.append(" AND ORA_REGISTRAZIONE<=?");
  3842.             }
  3843.             pstmt = connectionDB.prepareStatement(query.toString());
  3844.             pstmt.setString(1,id);
  3845.             pstmt.setString(2,tipoBusta);
  3846.             java.sql.Timestamp nowT = null;
  3847.             if(data!=null) {
  3848.                 nowT = new java.sql.Timestamp(data.getTime());
  3849.                 pstmt.setTimestamp(3,nowT);
  3850.             }
  3851.             
  3852.             //  Add PreparedStatement
  3853.             state.getPreparedStatement().put("DELETE delete_datiAsincroni"+id,pstmt);

  3855.         } catch(Exception e) {
  3856.             String errorMsg = "PROFILO_DI_COLLABORAZIONE_ASINCRONO, Errore durante l'asincrono_eliminaRegistrazione "+id+": "+e.getMessage();       
  3857.             this.log.error(errorMsg,e);
  3858.             try{
  3859.                 if( pstmt != null )
  3860.                     pstmt.close();
  3861.             } catch(Exception er) {
  3862.                 // Eccezione SQL.
  3863.             }
  3864.             throw new ProtocolException(errorMsg,e);
  3865.         }
  3866.     }

  3868. }




Created with JaCoCo 0.8.8.202204050719