RepositoryBuste.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.sql.Timestamp;
  30. import java.util.ArrayList;
  31. import java.util.Date;
  32. import java.util.List;
  33. import java.util.Map;

  35. import org.openspcoop2.core.commons.DBUtils;
  36. import org.openspcoop2.core.id.IDServizio;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.protocol.engine.Configurazione;
  39. import org.openspcoop2.protocol.engine.LetturaParametriBusta;
  40. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  41. import org.openspcoop2.protocol.engine.constants.Costanti;
  42. import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
  43. import org.openspcoop2.protocol.sdk.Busta;
  44. import org.openspcoop2.protocol.sdk.Eccezione;
  45. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  46. import org.openspcoop2.protocol.sdk.Integrazione;
  47. import org.openspcoop2.protocol.sdk.ProtocolException;
  48. import org.openspcoop2.protocol.sdk.Riscontro;
  49. import org.openspcoop2.protocol.sdk.Trasmissione;
  50. import org.openspcoop2.protocol.sdk.constants.CodiceErroreCooperazione;
  51. import org.openspcoop2.protocol.sdk.constants.ContestoCodificaEccezione;
  52. import org.openspcoop2.protocol.sdk.constants.Inoltro;
  53. import org.openspcoop2.protocol.sdk.constants.LivelloRilevanza;
  54. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  55. import org.openspcoop2.protocol.sdk.state.IState;
  56. import org.openspcoop2.protocol.sdk.state.StateMessage;
  57. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  58. import org.openspcoop2.protocol.sdk.state.StatelessMessage;
  59. import org.openspcoop2.utils.LoggerWrapperFactory;
  60. import org.openspcoop2.utils.SortedMap;
  61. import org.openspcoop2.utils.date.DateManager;
  62. import org.openspcoop2.utils.date.DateUtils;
  63. import org.openspcoop2.utils.sql.ISQLQueryObject;
  64. import org.openspcoop2.utils.sql.SQLObjectFactory;
  65. import org.slf4j.Logger;


  68. /**
  69.  * Sono inclusi i metodi per la gestione delle buste inviate/ricevute.
  70.  *
  71.  *
  72.  * @author Poli Andrea (apoli@link.it)
  73.  * @author Tronci Fabio (tronci@link.it)
  74.  * @author $Author$
  75.  * @version $Rev$, $Date$
  76.  */

  78. public class RepositoryBuste  {

  80.     /** Logger utilizzato per debug. */
  81.     private Logger log = null;

  83.     /** Se IState e' un'istanza di StatefulMessage possiede una Connessione SQL in autoCommit mode su cui effettuare query
  84.      *  Altrimenti, e' un'istanza di StatelessMessage e nn necessita di connessioni
  85.      * */
  86.     private IState state;

  88.     /** Identifica se questo repository lavora su buste di richiesta o risposta */
  89.     private boolean isRichiesta=true;
  90.     
  91.     public boolean isRichiesta() {
  92.         return this.isRichiesta;
  93.     }
  94.     public void setRichiesta(boolean isRichiesta) {
  95.         this.isRichiesta = isRichiesta;
  96.     }


  99.     /** GestoreRepository */
  100.     private IGestoreRepository gestoreRepositoryBuste;

  102.     private IProtocolFactory<?> protocolFactory;

  104.     
  105.     /* ********  C O S T R U T T O R E  ******** */

  107.     //public RepositoryBuste(IState state){
  108.     //  this(state, Configurazione.getLibraryLog(), true,null);
  109.     //}
  110.     public RepositoryBuste(IState state, boolean isRichiesta,IProtocolFactory<?> protocolFactory){
  111.         this(state, Configurazione.getLibraryLog(), isRichiesta,protocolFactory);
  112.     }
  113.     public RepositoryBuste(IState state, Logger alog,IProtocolFactory<?> protocolFactory){
  114.         this(state, alog, true,protocolFactory);
  115.     }
  116.     public RepositoryBuste(IState state,IProtocolFactory<?> protocolFactory){
  117.         this(state, Configurazione.getLibraryLog(), true,protocolFactory);
  118.     }
  119.     /**
  120.      * Costruttore.
  121.      *
  122.      * @param state Oggetto che rappresenta lo stato di una busta
  123.      *
  124.      */
  125.     public RepositoryBuste(IState state, Logger alog, boolean isRichiesta,IProtocolFactory<?> protocolFactory){
  126.         this.state = state;
  127.         this.gestoreRepositoryBuste = Configurazione.getGestoreRepositoryBuste();
  128.         if(alog!=null){
  129.             this.log = alog;
  130.         }else{
  131.             this.log = LoggerWrapperFactory.getLogger(RepositoryBuste.class.getName());
  132.         }
  133.         this.isRichiesta = isRichiesta;
  134.         this.protocolFactory = protocolFactory;
  135.     }
  136.     
  137.     

  139.     /**
  140.      * Imposta lo stato
  141.      *
  142.      * @param state Stato
  143.      *
  144.      */
  145.     public void updateState(IState state){
  146.         this.state = state;
  147.     }




  152.     /* ********  B U S T E     O U T B O X  ******** */
  153.     /**
  154.      * Metodo che si occupa di registrare una busta in uscita.
  155.      *
  156.      * @param busta Contiene le informazioni su di una busta in uscita (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  157.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  158.      *
  159.      */
  160.     public void registraBustaIntoOutBox(Busta busta,long scadenza) throws ProtocolException{
  161.         registraBusta(busta,Costanti.OUTBOX,null,scadenza);
  162.     }
  163.     /**
  164.      * Metodo che si occupa di registrare una busta in uscita con errori.
  165.      *
  166.      * @param busta Contiene le informazioni su di una busta in uscita (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  167.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  168.      * @param errors un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se contenente errori di validazione.
  169.      *
  170.      */
  171.     public void registraBustaIntoOutBox(Busta busta,List<Eccezione> errors,long scadenza) throws ProtocolException{
  172.         registraBusta(busta,Costanti.OUTBOX,errors,scadenza);
  173.     }
  174.     /**
  175.      * Metodo che si occupa di registrare una busta in uscita.
  176.      *
  177.      * @param id Identificativo della Richiesta
  178.      * @param soggettoFruitore Soggetto fruitore
  179.      * @param servizio Servizio invocato
  180.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  181.      *
  182.      */
  183.     public void registraBustaIntoOutBox(String id,IDSoggetto soggettoFruitore,IDServizio servizio,long scadenza,
  184.             org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione profiloCollaborazione,boolean confermaRicezione, Inoltro inoltro) throws ProtocolException{
  185.         Busta busta = new Busta(this.protocolFactory.getProtocol());
  186.         busta.setID(id);
  187.         busta.setTipoMittente(soggettoFruitore.getTipo());
  188.         busta.setMittente(soggettoFruitore.getNome());
  189.         busta.setIdentificativoPortaMittente(soggettoFruitore.getCodicePorta());
  190.         busta.setTipoDestinatario(servizio.getSoggettoErogatore().getTipo());
  191.         busta.setDestinatario(servizio.getSoggettoErogatore().getNome());
  192.         busta.setIdentificativoPortaDestinatario(servizio.getSoggettoErogatore().getCodicePorta());
  193.         busta.setTipoServizio(servizio.getTipo());
  194.         busta.setServizio(servizio.getNome());
  195.         busta.setVersioneServizio(servizio.getVersione());
  196.         busta.setAzione(servizio.getAzione());
  197.         busta.setProfiloDiCollaborazione(profiloCollaborazione);
  198.         busta.setConfermaRicezione(confermaRicezione);
  199.         busta.setInoltro(inoltro,this.protocolFactory.createTraduttore().toString(inoltro));
  200.         registraBusta(busta,Costanti.OUTBOX,null,scadenza);
  201.     }

  203.     public void aggiornaProprietaBustaIntoOutBox(Map<String, String> properties, String idBusta)throws ProtocolException{
  204.         this.aggiornaProprietaBusta(properties, idBusta, Costanti.OUTBOX);
  205.     }
  206.     
  207.     /**
  208.      * Aggiorna l'informazione di duplicati della busta.
  209.      *
  210.      * @param id identificativo della busta da ritornare.
  211.      *
  212.      */
  213.     public void aggiornaDuplicatiIntoOutBox(String id)throws ProtocolException{
  214.         this.aggiornaDuplicati(id, Costanti.OUTBOX);
  215.     }

  217.     /**
  218.      * Aggiorna le informazioni di integrazione della busta in uscita.
  219.      *
  220.      * @param id identificativo della busta da ritornare.
  221.      * @param infoIntegrazione Informazioni di integrazione
  222.      *
  223.      */
  224.     public void aggiornaInfoIntegrazioneIntoOutBox(String id,Integrazione infoIntegrazione)throws ProtocolException{
  225.         aggiornaInfoIntegrazione(id,Costanti.OUTBOX,infoIntegrazione);
  226.     }

  228.     /**
  229.      * Aggiorna il servizio applicativo di integrazione nel repositoryBuste della busta in uscita.
  230.      *
  231.      * @param id identificativo della busta da ritornare.
  232.      * @param servizioApplicativo Servizio Applicativo
  233.      *
  234.      */
  235.     public void aggiornaInfoIntegrazioneIntoOutBox_ServizioApplicativo(String id,String servizioApplicativo)throws ProtocolException{
  236.         aggiornaInfoIntegrazione_ServizioApplicativo(id,Costanti.OUTBOX,servizioApplicativo);
  237.     }

  239.     /**
  240.      * Aggiorna lo scenario di integrazione del Msg gestito da OpenSPCoop della busta in uscita.
  241.      *
  242.      * @param id identificativo della busta da ritornare.
  243.      * @param scenario Scenario di integrazione
  244.      *
  245.      */
  246.     public void aggiornaInfoIntegrazioneIntoOutBox_Scenario(String id,String scenario)throws ProtocolException{
  247.         aggiornaInfoIntegrazione_Scenario(id,Costanti.OUTBOX,scenario);
  248.     }

  250.     /**
  251.      * Metodo che si occupa di aggiornare i dati di una busta in uscita precedentemente inviata.
  252.      *
  253.      * @param busta Contiene le informazioni su di una busta in uscita (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  254.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  255.      *
  256.      */
  257.     public void aggiornaBustaIntoOutBox(Busta busta,long scadenza) throws ProtocolException{
  258.         aggiornaBusta(busta,Costanti.OUTBOX,scadenza,null);
  259.     }
  260.     /**
  261.      * Metodo che si occupa di aggiornare i dati di una busta in uscita precedentemente inviata.
  262.      *
  263.      * @param busta Contiene le informazioni su di una busta in entrata (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  264.      * @param errors un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se contenente errori di validazione.
  265.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  266.      *
  267.      */
  268.     public void aggiornaBustaIntoOutBox(Busta busta,long scadenza,List<Eccezione> errors) throws ProtocolException{
  269.         aggiornaBusta(busta,Costanti.OUTBOX,scadenza,errors);
  270.     }

  272.     /**
  273.      * Metodo che si occupa di aggiornare una busta in uscita.
  274.      *
  275.      * @param id Identificativo della Richiesta
  276.      * @param soggettoFruitore Soggetto fruitore
  277.      * @param servizio Servizio invocato
  278.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  279.      *
  280.      */
  281.     public void aggiornaBustaIntoOutBox(String id,IDSoggetto soggettoFruitore,IDServizio servizio,long scadenza,
  282.             org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione profiloCollaborazione,boolean confermaRicezione,Inoltro inoltro) throws ProtocolException{
  283.         Busta bustaDaAggiornare = new Busta(this.protocolFactory.getProtocol());
  284.         bustaDaAggiornare.setID(id);
  285.         bustaDaAggiornare.setTipoMittente(soggettoFruitore.getTipo());
  286.         bustaDaAggiornare.setMittente(soggettoFruitore.getNome());
  287.         bustaDaAggiornare.setIdentificativoPortaMittente(soggettoFruitore.getCodicePorta());
  288.         bustaDaAggiornare.setTipoDestinatario(servizio.getSoggettoErogatore().getTipo());
  289.         bustaDaAggiornare.setDestinatario(servizio.getSoggettoErogatore().getNome());
  290.         bustaDaAggiornare.setIdentificativoPortaDestinatario(servizio.getSoggettoErogatore().getCodicePorta());
  291.         bustaDaAggiornare.setTipoServizio(servizio.getTipo());
  292.         bustaDaAggiornare.setServizio(servizio.getNome());
  293.         bustaDaAggiornare.setVersioneServizio(servizio.getVersione());
  294.         bustaDaAggiornare.setAzione(servizio.getAzione());
  295.         bustaDaAggiornare.setProfiloDiCollaborazione(profiloCollaborazione);
  296.         bustaDaAggiornare.setConfermaRicezione(confermaRicezione);
  297.         bustaDaAggiornare.setInoltro(inoltro,this.protocolFactory.createTraduttore().toString(inoltro));
  298.         aggiornaBusta(bustaDaAggiornare,Costanti.OUTBOX, scadenza, null);
  299.     }

  301.     /**
  302.      * Metodo che si occupa di aggiornare la collaborazione di una busta.
  303.      *
  304.      * @param id  Identificativo di una busta
  305.      * @param collaborazione ID di Collaborazione di una busta
  306.      *
  307.      */
  308.     public void aggiornaCollaborazioneIntoOutBox(String id,String collaborazione) throws ProtocolException{
  309.         aggiornaCollaborazione(id,Costanti.OUTBOX,collaborazione);
  310.     }

  312.     /**
  313.      * Metodo che si occupa di aggiornare il numero di sequenza di una busta in uscita.
  314.      *
  315.      * @param id  Identificativo di una busta
  316.      * @param sequenza Numero di sequenza di una busta
  317.      *
  318.      */
  319.     public void aggiornaSequenzaIntoOutBox(String id,long sequenza) throws ProtocolException{
  320.         aggiornaSequenza(id,Costanti.OUTBOX,sequenza);
  321.     }

  323.     /**
  324.      * Ritorna l'informazione se una busta in uscita e' gia stata precedentemente registrata.
  325.      *
  326.      * @param id identificativo della busta da ritornare.
  327.      * @return true se e' presente la busta richiesta.
  328.      *
  329.      */
  330.     public boolean isRegistrataIntoOutBox(String id) throws ProtocolException{
  331.         return isRegistrata(id,Costanti.OUTBOX);
  332.     }

  334.     /**
  335.      * Metodo che si occupa di ritornare un oggetto {@link org.openspcoop2.protocol.sdk.Busta} contenente
  336.      * le informazioni di una busta in uscita, precedentemente salvata,
  337.      * prelevandola dalla tabella delle buste. Alla busta, al momento della registrazione,
  338.      * e' stato associato l'identificativo della busta, quindi attraverso esso sara' possibile trovarlo nella History.
  339.      *
  340.      * @param id identificativo della busta da ritornare.
  341.      * @return un oggetto {@link org.openspcoop2.protocol.sdk.Busta} se e' presente la busta richiesta.
  342.      *
  343.      */
  344.     public Busta getBustaFromOutBox(String id) throws ProtocolException{
  345.         return getBusta(id,Costanti.OUTBOX);
  346.     }

  348.     /**
  349.      * Metodo che si occupa di ritornare un oggetto contenente errori di validazione
  350.      * {@link org.openspcoop2.protocol.sdk.Eccezione} avvenuti durante la validazione di una busta.
  351.      *
  352.      * @param id identificativo della busta da ritornare.
  353.      * @return un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se e' presente la busta richiesta.
  354.      *
  355.      */
  356.     public List<Eccezione> getErrorsFromOutBox(String id, IProtocolFactory<?> protocolFactory) throws ProtocolException{
  357.         return getErrors(id, Costanti.OUTBOX);
  358.     }

  360.     /**
  361.      * Ritorna alcuni campi associata alla busta.
  362.      *
  363.      * @param id identificativo della busta.
  364.      * @param parametri Indicazione sul tipo di busta inviata/ricevuta
  365.      * @return alcuni valori della busta
  366.      *
  367.      */
  368.     public Busta getSomeValuesFromOutBox(String id,LetturaParametriBusta parametri) throws ProtocolException{
  369.         return getSomeValues(id, Costanti.OUTBOX, parametri, false, null);
  370.     }
  371.     public Busta getSomeValuesFromOutBox(String id,LetturaParametriBusta parametri,boolean forzaLetturaDatabase) throws ProtocolException{
  372.         return getSomeValues(id, Costanti.OUTBOX, parametri, forzaLetturaDatabase, null);
  373.     }
  374.     public Busta getSomeValuesFromOutBox(String id,LetturaParametriBusta parametri, Date dataRegistrazione) throws ProtocolException{
  375.         return getSomeValues(id, Costanti.OUTBOX, parametri, false, dataRegistrazione);
  376.     }
  377.     public Busta getSomeValuesFromOutBox(String id,LetturaParametriBusta parametri,boolean forzaLetturaDatabase, Date dataRegistrazione) throws ProtocolException{
  378.         return getSomeValues(id, Costanti.OUTBOX, parametri, forzaLetturaDatabase, dataRegistrazione);
  379.     }

  381.     /**
  382.      * Ritorna la collaborazione associata alla busta.
  383.      *
  384.      * @param id identificativo della busta.
  385.      * @return Collaborazione associata alla busta
  386.      *
  387.      */
  388.     public String getCollaborazioneFromOutBox(String id) throws ProtocolException{
  389.         return getCollaborazione(id,Costanti.OUTBOX);
  390.     }

  392.     /**
  393.      * Ritorna il profilo di collaborazione associata alla busta.
  394.      *
  395.      * @param id identificativo della busta.
  396.      * @return Collaborazione associata alla busta
  397.      *
  398.      */
  399.     public org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione getProfiloCollaborazioneFromOutBox(String id) throws ProtocolException{
  400.         return getProfiloCollaborazione(id,Costanti.OUTBOX);
  401.     }
  402.     
  403.     public String getProfiloCollaborazioneValueFromOutBox(String id) throws ProtocolException{
  404.         return getProfiloCollaborazioneValue(id,Costanti.OUTBOX);
  405.     }

  407.     /**
  408.      * Ritorna la sequenza associata alla busta in uscita.
  409.      *
  410.      * @param id identificativo della busta.
  411.      * @return Sequenza associata alla busta
  412.      *
  413.      */
  414.     public long getSequenzaFromOutBox(String id) throws ProtocolException{
  415.         return getSequenza(id,Costanti.OUTBOX);
  416.     }

  418.     /**
  419.      * Ritorna le informazioni di integrazione associate alla busta in uscita.
  420.      *
  421.      * @param id identificativo della busta.
  422.      * @return Informazioni di integrazione associate alla busta
  423.      *
  424.      */
  425.     public Integrazione getInfoIntegrazioneFromOutBox(String id) throws ProtocolException{
  426.         return getInfoIntegrazione(id,Costanti.OUTBOX);
  427.     }

  429.     /**
  430.      * Metodo che si occupa di eliminare l'indicazione di utilizzo della busta dalla PdD
  431.      *
  432.      * @param id identificativo della busta.
  433.      *
  434.      */
  435.     public void eliminaUtilizzoPdDFromOutBox(String id) throws ProtocolException{
  436.         this.eliminaUtilizzoPdD(id,Costanti.OUTBOX,false, null);
  437.     }
  438.     public void eliminaUtilizzoPdDFromOutBox(String id,boolean forzaUpdateDB) throws ProtocolException{
  439.         eliminaUtilizzoPdD(id,Costanti.OUTBOX,forzaUpdateDB, null);
  440.     }
  441.     public void eliminaUtilizzoPdDFromOutBox(String id,boolean forzaUpdateDB,boolean savePreparedStatement) throws ProtocolException{
  442.         eliminaUtilizzoPdD(id,Costanti.OUTBOX,forzaUpdateDB,savePreparedStatement, null);
  443.     }
  444.     public void eliminaUtilizzoPdDFromOutBox(String id, Date dataRegistrazione) throws ProtocolException{
  445.         this.eliminaUtilizzoPdD(id,Costanti.OUTBOX,false, dataRegistrazione);
  446.     }
  447.     public void eliminaUtilizzoPdDFromOutBox(String id,boolean forzaUpdateDB, Date dataRegistrazione) throws ProtocolException{
  448.         eliminaUtilizzoPdD(id,Costanti.OUTBOX,forzaUpdateDB, dataRegistrazione);
  449.     }
  450.     public void eliminaUtilizzoPdDFromOutBox(String id,boolean forzaUpdateDB,boolean savePreparedStatement, Date dataRegistrazione) throws ProtocolException{
  451.         eliminaUtilizzoPdD(id,Costanti.OUTBOX,forzaUpdateDB,savePreparedStatement, dataRegistrazione);
  452.     }
  453.     /**
  454.      * Metodo che si occupa di eliminare una busta precedentemente salvata.
  455.      * Alla busta, al momento della registrazione,
  456.      * e' stato associato l'identificativo della busta, quindi attraverso esso sara' possibile trovarlo nella History.
  457.      *
  458.      * @param id identificativo della busta.
  459.      *
  460.      */
  461.     public void eliminaBustaFromOutBox(String id, Date data) throws ProtocolException{
  462.         eliminaBusta(id,Costanti.OUTBOX, data);
  463.     }

  465.     public void eliminaBustaStatelessFromOutBox(String id) throws ProtocolException{
  466.         eliminaBustaStateless(id,Costanti.OUTBOX, null);
  467.     }
  468.     public void eliminaBustaStatelessFromOutBox(String id, Date dataRegistrazione) throws ProtocolException{
  469.         eliminaBustaStateless(id,Costanti.OUTBOX, dataRegistrazione);
  470.     }

  472.     /**
  473.      * Metodo che si occupa di impostare l'indicazione di utilizzo della busta da parte della PdD
  474.      *
  475.      * @param id identificativo della busta.
  476.      *
  477.      */
  478.     public void impostaUtilizzoPdDIntoOutBox(String id) throws ProtocolException{
  479.         impostaUtilizzoPdD(id,Costanti.OUTBOX);
  480.     }
  481.     
  482.     






  489.     /* ********  B U S T E     R I C E V U T E  ******** */
  490.     /**
  491.      * Metodo che si occupa di registrare una busta in entrata.
  492.      *
  493.      * @param busta Contiene le informazioni su di una busta in entrata (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  494.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  495.      *
  496.      */
  497.     public void registraBustaIntoInBox(Busta busta,long scadenza) throws ProtocolException{
  498.         registraBusta(busta,Costanti.INBOX,null,scadenza);
  499.     }
  500.     public void registraBustaIntoInBox(Busta busta,long scadenza, boolean saveServizioApplicativoFruitore) throws ProtocolException{
  501.         registraBusta(busta,Costanti.INBOX,null,scadenza, saveServizioApplicativoFruitore);
  502.     }
  503.     /**
  504.      * Metodo che si occupa di registrare una busta in uscita con errori.
  505.      *
  506.      * @param busta Contiene le informazioni su di una busta in uscita (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  507.      * @param errors un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se contenente errori di validazione.
  508.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  509.      *
  510.      */
  511.     public void registraBustaIntoInBox(Busta busta,List<Eccezione> errors,long scadenza) throws ProtocolException{
  512.         registraBusta(busta,Costanti.INBOX,errors,scadenza);
  513.     }
  514.     /**
  515.      * Metodo che si occupa di registrare una busta in entrata.
  516.      *
  517.      * @param id Identificativo della Richiesta
  518.      * @param soggettoFruitore Soggetto fruitore
  519.      * @param servizio Servizio invocato
  520.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  521.      *
  522.      */
  523.     public void registraBustaIntoInBox(String id,IDSoggetto soggettoFruitore,IDServizio servizio,long scadenza,
  524.             org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione profiloCollaborazione,boolean confermaRicezione,Inoltro inoltro) throws ProtocolException{
  525.         Busta busta = new Busta(this.protocolFactory.getProtocol());
  526.         busta.setID(id);
  527.         busta.setTipoMittente(soggettoFruitore.getTipo());
  528.         busta.setMittente(soggettoFruitore.getNome());
  529.         busta.setIdentificativoPortaMittente(soggettoFruitore.getCodicePorta());
  530.         busta.setTipoDestinatario(servizio.getSoggettoErogatore().getTipo());
  531.         busta.setDestinatario(servizio.getSoggettoErogatore().getNome());
  532.         busta.setIdentificativoPortaDestinatario(servizio.getSoggettoErogatore().getCodicePorta());
  533.         busta.setTipoServizio(servizio.getTipo());
  534.         busta.setServizio(servizio.getNome());
  535.         busta.setVersioneServizio(servizio.getVersione());
  536.         busta.setAzione(servizio.getAzione());
  537.         busta.setProfiloDiCollaborazione(profiloCollaborazione);
  538.         busta.setConfermaRicezione(confermaRicezione);
  539.         busta.setInoltro(inoltro,this.protocolFactory.createTraduttore().toString(inoltro));
  540.         registraBusta(busta,Costanti.INBOX,null,scadenza);
  541.     }

  543.     public void aggiornaProprietaBustaIntoInBox(Map<String, String> properties, String idBusta)throws ProtocolException{
  544.         this.aggiornaProprietaBusta(properties, idBusta, Costanti.INBOX);
  545.     }
  546.     
  547.     /**
  548.      * Aggiorna l'informazione di duplicati della busta.
  549.      *
  550.      * @param id identificativo della busta da ritornare.
  551.      *
  552.      */
  553.     public void aggiornaDuplicatiIntoInBox(String id)throws ProtocolException{
  554.         this.aggiornaDuplicati(id, Costanti.INBOX);
  555.     }

  557.     /**
  558.      * Aggiorna le informazioni di integrazione della busta in entrata.
  559.      *
  560.      * @param id identificativo della busta da ritornare.
  561.      * @param infoIntegrazione Informazioni di integrazione
  562.      *
  563.      */
  564.     public void aggiornaInfoIntegrazioneIntoInBox(String id,Integrazione infoIntegrazione)throws ProtocolException{
  565.         aggiornaInfoIntegrazione(id,Costanti.INBOX,infoIntegrazione);
  566.     }

  568.     /**
  569.      * Aggiorna il servizio applicativo di integrazione nel repositoryBuste della busta in entrata.
  570.      *
  571.      * @param id identificativo della busta da ritornare.
  572.      * @param servizioApplicativo Servizio Applicativo
  573.      *
  574.      */
  575.     public void aggiornaInfoIntegrazioneIntoInBox_ServizioApplicativo(String id,String servizioApplicativo)throws ProtocolException{
  576.         aggiornaInfoIntegrazione_ServizioApplicativo(id,Costanti.INBOX,servizioApplicativo);
  577.     }

  579.     /**
  580.      * Aggiorna lo scenario di integrazione del Msg gestito da OpenSPCoop della busta in entrata.
  581.      *
  582.      * @param id identificativo della busta da ritornare.
  583.      * @param scenario Scenario di integrazione
  584.      *
  585.      */
  586.     public void aggiornaInfoIntegrazioneIntoInBox_Scenario(String id,String scenario)throws ProtocolException{
  587.         aggiornaInfoIntegrazione_Scenario(id,Costanti.INBOX,scenario);
  588.     }

  590.     /**
  591.      * Metodo che si occupa di aggiornare i dati di una busta in entrata precedentemente inviata.
  592.      *
  593.      * @param busta Contiene le informazioni su di una busta in entrata (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  594.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  595.      *
  596.      */
  597.     public void aggiornaBustaIntoInBox(Busta busta,long scadenza) throws ProtocolException{
  598.         aggiornaBusta(busta,Costanti.INBOX,scadenza,null);
  599.     }
  600.     public void aggiornaBustaIntoInBox(Busta busta,long scadenza, boolean saveServizioApplicativoFruitore) throws ProtocolException{
  601.         aggiornaBusta(busta,Costanti.INBOX,scadenza,null,saveServizioApplicativoFruitore);
  602.     }
  603.     /**
  604.      * Metodo che si occupa di aggiornare i dati di una busta in entrata precedentemente inviata.
  605.      *
  606.      * @param busta Contiene le informazioni su di una busta in entrata (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  607.      * @param errors un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se contenente errori di validazione.
  608.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  609.      *
  610.      */
  611.     public void aggiornaBustaIntoInBox(Busta busta,long scadenza,List<Eccezione> errors) throws ProtocolException{
  612.         aggiornaBusta(busta,Costanti.INBOX,scadenza,errors);
  613.     }

  615.     /**
  616.      * Metodo che si occupa di aggiornare una busta in entrata.
  617.      *
  618.      * @param id Identificativo della Richiesta
  619.      * @param soggettoFruitore Soggetto fruitore
  620.      * @param servizio Servizio invocato
  621.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  622.      *
  623.      */
  624.     public void aggiornaBustaIntoInBox(String id,IDSoggetto soggettoFruitore,IDServizio servizio,long scadenza,
  625.             org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione profiloCollaborazione,boolean confermaRicezione,Inoltro inoltro) throws ProtocolException{
  626.         Busta bustaDaAggiornare = new Busta(this.protocolFactory.getProtocol());
  627.         bustaDaAggiornare.setID(id);
  628.         bustaDaAggiornare.setTipoMittente(soggettoFruitore.getTipo());
  629.         bustaDaAggiornare.setMittente(soggettoFruitore.getNome());
  630.         bustaDaAggiornare.setIdentificativoPortaMittente(soggettoFruitore.getCodicePorta());
  631.         bustaDaAggiornare.setTipoDestinatario(servizio.getSoggettoErogatore().getTipo());
  632.         bustaDaAggiornare.setDestinatario(servizio.getSoggettoErogatore().getNome());
  633.         bustaDaAggiornare.setIdentificativoPortaDestinatario(servizio.getSoggettoErogatore().getCodicePorta());
  634.         bustaDaAggiornare.setTipoServizio(servizio.getTipo());
  635.         bustaDaAggiornare.setServizio(servizio.getNome());
  636.         bustaDaAggiornare.setVersioneServizio(servizio.getVersione());
  637.         bustaDaAggiornare.setAzione(servizio.getAzione());
  638.         bustaDaAggiornare.setProfiloDiCollaborazione(profiloCollaborazione);
  639.         bustaDaAggiornare.setConfermaRicezione(confermaRicezione);
  640.         bustaDaAggiornare.setInoltro(inoltro,this.protocolFactory.createTraduttore().toString(inoltro));
  641.         aggiornaBusta(bustaDaAggiornare,Costanti.INBOX, scadenza, null);
  642.     }

  644.     /**
  645.      * Metodo che si occupa di aggiornare la collaborazione di una busta.
  646.      *
  647.      * @param id  Identificativo di una busta
  648.      * @param collaborazione ID di Collaborazione di una busta
  649.      *
  650.      */
  651.     public void aggiornaCollaborazioneIntoInBox(String id,String collaborazione) throws ProtocolException{
  652.         aggiornaCollaborazione(id,Costanti.INBOX,collaborazione);
  653.     }

  655.     /**
  656.      * Metodo che si occupa di aggiornare il numero di sequenza di una busta in entrata.
  657.      *
  658.      * @param id  Identificativo di una busta
  659.      * @param sequenza Numero di sequenza di una busta
  660.      *
  661.      */
  662.     public void aggiornaSequenzaIntoInBox(String id,long sequenza) throws ProtocolException{
  663.         aggiornaSequenza(id,Costanti.INBOX,sequenza);
  664.     }

  666.     /**
  667.      * Ritorna l'informazione se una busta in entrata e' gia stata precedentemente registrata.
  668.      *
  669.      * @param id identificativo della busta da ritornare.
  670.      * @return true se e' presente la busta richiesta.
  671.      *
  672.      */
  673.     public boolean isRegistrataIntoInBox(String id) throws ProtocolException{
  674.         return isRegistrata(id,Costanti.INBOX);
  675.     }

  677.     /**
  678.      * Metodo che si occupa di ritornare un oggetto {@link org.openspcoop2.protocol.sdk.Busta} contenente
  679.      * le informazioni di una busta in entrata, precedentemente salvata,
  680.      * prelevandola dalla tabella delle buste. Alla busta, al momento della registrazione,
  681.      * e' stato associato l'identificativo della busta, quindi attraverso esso sara' possibile trovarlo nella History.
  682.      *
  683.      * @param id identificativo della busta da ritornare.
  684.      * @return un oggetto {@link org.openspcoop2.protocol.sdk.Busta} se e' presente la busta richiesta.
  685.      *
  686.      */
  687.     public Busta getBustaFromInBox(String id) throws ProtocolException{
  688.         return getBusta(id,Costanti.INBOX);
  689.     }
  690.     public Busta getBustaFromInBox(String id, boolean readServizioApplicativoFruitore) throws ProtocolException{
  691.         return getBusta(id,Costanti.INBOX, readServizioApplicativoFruitore);
  692.     }

  694.     /**
  695.      * Metodo che si occupa di ritornare un oggetto contenente errori di validazione
  696.      * {@link org.openspcoop2.protocol.sdk.Eccezione} avvenuti durante la validazione di una busta.
  697.      *
  698.      * @param id identificativo della busta da ritornare.
  699.      * @return un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se e' presente la busta richiesta.
  700.      *
  701.      */
  702.     public List<Eccezione> getErrorsFromInBox(String id) throws ProtocolException{
  703.         return getErrors(id,Costanti.INBOX);
  704.     }

  706.     /**
  707.      * Ritorna alcuni campi associata alla busta.
  708.      *
  709.      * @param id identificativo della busta.
  710.      * @param parametri Indicazione sul tipo di busta inviata/ricevuta
  711.      * @return alcuni valori della busta
  712.      *
  713.      */
  714.     public Busta getSomeValuesFromInBox(String id,LetturaParametriBusta parametri) throws ProtocolException{
  715.         return getSomeValues(id,Costanti.INBOX,parametri,false, null);
  716.     }
  717.     public Busta getSomeValuesFromInBox(String id,LetturaParametriBusta parametri,boolean forzaLetturaDatabase) throws ProtocolException{
  718.         return getSomeValues(id,Costanti.INBOX,parametri,forzaLetturaDatabase, null);
  719.     }
  720.     public Busta getSomeValuesFromInBox(String id,LetturaParametriBusta parametri, Date dataRegistrazione) throws ProtocolException{
  721.         return getSomeValues(id,Costanti.INBOX,parametri,false,dataRegistrazione);
  722.     }
  723.     public Busta getSomeValuesFromInBox(String id,LetturaParametriBusta parametri,boolean forzaLetturaDatabase, Date dataRegistrazione) throws ProtocolException{
  724.         return getSomeValues(id,Costanti.INBOX,parametri,forzaLetturaDatabase,dataRegistrazione);
  725.     }
  726.     
  727.     /**
  728.      * Ritorna la collaborazione associata alla busta.
  729.      *
  730.      * @param id identificativo della busta.
  731.      * @return Collaborazione associata alla busta
  732.      *
  733.      */
  734.     public String getCollaborazioneFromInBox(String id) throws ProtocolException{
  735.         return getCollaborazione(id,Costanti.INBOX);
  736.     }

  738.     /**
  739.      * Ritorna il profilo di collaborazione associata alla busta.
  740.      *
  741.      * @param id identificativo della busta.
  742.      * @return Collaborazione associata alla busta
  743.      *
  744.      */
  745.     public org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione getProfiloCollaborazioneFromInBox(String id) throws ProtocolException{
  746.         return getProfiloCollaborazione(id,Costanti.INBOX);
  747.     }
  748.     
  749.     public String getProfiloCollaborazioneValueFromInBox(String id) throws ProtocolException{
  750.         return getProfiloCollaborazioneValue(id,Costanti.INBOX);
  751.     }

  753.     /**
  754.      * Ritorna la sequenza associata alla busta in entrata.
  755.      *
  756.      * @param id identificativo della busta.
  757.      * @return Sequenza associata alla busta
  758.      *
  759.      */
  760.     public long getSequenzaFromInBox(String id) throws ProtocolException{
  761.         return getSequenza(id,Costanti.INBOX);
  762.     }

  764.     /**
  765.      * Ritorna le informazioni di integrazione associate alla busta in entrata.
  766.      *
  767.      * @param id identificativo della busta.
  768.      * @return Informazioni di integrazione associate alla busta
  769.      *
  770.      */
  771.     public Integrazione getInfoIntegrazioneFromInBox(String id) throws ProtocolException{
  772.         return getInfoIntegrazione(id,Costanti.INBOX);
  773.     }

  775.     /**
  776.      * Metodo che si occupa di eliminare l'indicazione di utilizzo della busta da parte della PdD
  777.      *
  778.      * @param id identificativo della busta.
  779.      *
  780.      */
  781.     public void eliminaUtilizzoPdDFromInBox(String id) throws ProtocolException{
  782.         this.eliminaUtilizzoPdD(id,Costanti.INBOX,false, null);
  783.     }
  784.     public void eliminaUtilizzoPdDFromInBox(String id,boolean forzaUpdateDB) throws ProtocolException{
  785.         eliminaUtilizzoPdD(id,Costanti.INBOX,forzaUpdateDB, null);
  786.     }
  787.     public void eliminaUtilizzoPdDFromInBox(String id,boolean forzaUpdateDB,boolean savePreparedStatement) throws ProtocolException{
  788.         eliminaUtilizzoPdD(id,Costanti.INBOX,forzaUpdateDB,savePreparedStatement, null);
  789.     }
  790.     public void eliminaUtilizzoPdDFromInBox(String id, Date dataRegistrazione) throws ProtocolException{
  791.         this.eliminaUtilizzoPdD(id,Costanti.INBOX,false, dataRegistrazione);
  792.     }
  793.     public void eliminaUtilizzoPdDFromInBox(String id,boolean forzaUpdateDB, Date dataRegistrazione) throws ProtocolException{
  794.         eliminaUtilizzoPdD(id,Costanti.INBOX,forzaUpdateDB, dataRegistrazione);
  795.     }
  796.     public void eliminaUtilizzoPdDFromInBox(String id,boolean forzaUpdateDB,boolean savePreparedStatement, Date dataRegistrazione) throws ProtocolException{
  797.         eliminaUtilizzoPdD(id,Costanti.INBOX,forzaUpdateDB,savePreparedStatement, dataRegistrazione);
  798.     }

  800.     /**
  801.      * Metodo che si occupa di eliminare una busta precedentemente salvata.
  802.      * Alla busta, al momento della registrazione,
  803.      * e' stato associato l'identificativo della busta, quindi attraverso esso sara' possibile trovarlo nella History.
  804.      *
  805.      * @param id identificativo della busta.
  806.      *
  807.      */
  808.     public void eliminaBustaFromInBox(String id, Date data) throws ProtocolException{
  809.         eliminaBusta(id,Costanti.INBOX, data);
  810.     }

  812.     public void eliminaBustaStatelessFromInBox(String id) throws ProtocolException{
  813.         eliminaBustaStateless(id,Costanti.INBOX, null);
  814.     }
  815.     public void eliminaBustaStatelessFromInBox(String id, Date dataRegistrazione) throws ProtocolException{
  816.         eliminaBustaStateless(id,Costanti.INBOX, dataRegistrazione);
  817.     }

  819.     /**
  820.      * Metodo che si occupa di impostare l'indicazione di utilizzo della busta da parte della PdD
  821.      *
  822.      * @param id identificativo della busta.
  823.      *
  824.      */
  825.     public void impostaUtilizzoPdDIntoInBox(String id) throws ProtocolException{
  826.         impostaUtilizzoPdD(id,Costanti.INBOX);
  827.     }















  843.     /* ********  G E S T I O N E   B U S T E  ******** */
  844.     /**
  845.      * Metodo che si occupa di registrare una busta.
  846.      *
  847.      * @param busta Contiene le informazioni su di una busta  (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  848.      * @param scadenza Scadenza Scadenza in minuti associata ad una busta, se non possiede essa stessa una scadenza
  849.      *
  850.      */
  851.     public void registraBustaIntoInboxForHistory(Busta busta,long scadenza) throws ProtocolException{
  852.         
  853.         StateMessage stateMSG = (StateMessage)this.state;
  854.                 
  855.         Connection connectionDB = stateMSG.getConnectionDB();

  857.         PreparedStatement pstmtBusta = null;
  858.         
  859.         try{

  861.             Timestamp dataRegistrazione = DateManager.getTimestamp();
  862.             
  863.             //  Impostazione scadenza
  864.             Date scadenzaBusta = busta.getScadenza();
  865.             if(scadenzaBusta == null){
  866.                 scadenzaBusta = new Date(DateManager.getTimeMillis()+(scadenza*60*1000));
  867.             }
  868.             Timestamp scadenzaT = new Timestamp( scadenzaBusta.getTime()  );


  871.             /* Busta */

  873.             // Registrazione Busta
  874.             StringBuilder query = new StringBuilder();
  875.             query.append("INSERT INTO  ");
  876.             query.append(Costanti.REPOSITORY);
  877.             query.append(" (ID_MESSAGGIO,TIPO,MITTENTE,IDPORTA_MITTENTE,TIPO_MITTENTE,IND_TELEMATICO_MITT,DESTINATARIO,IDPORTA_DESTINATARIO,TIPO_DESTINATARIO,IND_TELEMATICO_DEST");
  878.             query.append(",VERSIONE_SERVIZIO,SERVIZIO,TIPO_SERVIZIO,AZIONE,PROFILO_DI_COLLABORAZIONE,SERVIZIO_CORRELATO,TIPO_SERVIZIO_CORRELATO");
  879.             query.append(",COLLABORAZIONE,SEQUENZA,INOLTRO_SENZA_DUPLICATI,CONFERMA_RICEZIONE,ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE");
  880.             query.append(",RIFERIMENTO_MESSAGGIO,SCADENZA_BUSTA,DUPLICATI,LOCATION_PD,SERVIZIO_APPLICATIVO,MODULO_IN_ATTESA,SCENARIO,PROTOCOLLO,DATA_REGISTRAZIONE,");
  881.             query.append(this.gestoreRepositoryBuste.createSQLFieldHistory());
  882.             query.append(") ");
  883.             query.append(" VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,");
  884.             query.append(this.gestoreRepositoryBuste.getSQLValueHistory(true));
  885.             query.append(")");
  886.             
  887.             pstmtBusta = connectionDB.prepareStatement(query.toString());
  888.             int index = 1;
  889.             pstmtBusta.setString(index++,busta.getID());
  890.             pstmtBusta.setString(index++,Costanti.INBOX);
  891.             pstmtBusta.setString(index++,busta.getMittente());
  892.             pstmtBusta.setString(index++,busta.getIdentificativoPortaMittente());
  893.             pstmtBusta.setString(index++,busta.getTipoMittente());
  894.             pstmtBusta.setString(index++,busta.getIndirizzoMittente());
  895.             pstmtBusta.setString(index++,busta.getDestinatario());
  896.             pstmtBusta.setString(index++,busta.getIdentificativoPortaDestinatario());
  897.             pstmtBusta.setString(index++,busta.getTipoDestinatario());
  898.             pstmtBusta.setString(index++,busta.getIndirizzoDestinatario());
  899.             pstmtBusta.setInt(index++,busta.getVersioneServizio());
  900.             pstmtBusta.setString(index++,busta.getServizio());
  901.             pstmtBusta.setString(index++,busta.getTipoServizio());
  902.             pstmtBusta.setString(index++,busta.getAzione());
  903.             pstmtBusta.setString(index++,busta.getProfiloDiCollaborazione().getEngineValue());
  904.             pstmtBusta.setString(index++,busta.getServizioCorrelato());
  905.             pstmtBusta.setString(index++,busta.getTipoServizioCorrelato());
  906.             pstmtBusta.setString(index++,busta.getCollaborazione());
  907.             pstmtBusta.setLong(index++, busta.getSequenza() );
  908.             if(Inoltro.SENZA_DUPLICATI.equals(busta.getInoltro()))
  909.                 pstmtBusta.setInt(index++,1);
  910.             else
  911.                 pstmtBusta.setInt(index++,0);
  912.             if(busta.isConfermaRicezione())
  913.                 pstmtBusta.setInt(index++,1);
  914.             else
  915.                 pstmtBusta.setInt(index++,0);
  916.             Timestamp oraRec = null;
  917.             TipoOraRegistrazione tipoOraRec = null;
  918.             if(busta.getOraRegistrazione()!=null && busta.getTipoOraRegistrazione()!=null){
  919.                 oraRec = new Timestamp( busta.getOraRegistrazione().getTime() );
  920.                 tipoOraRec = busta.getTipoOraRegistrazione();
  921.             }else{
  922.                 // poi sara' aggiornato.
  923.                 oraRec = dataRegistrazione;
  924.                 tipoOraRec = TipoOraRegistrazione.SINCRONIZZATO;
  925.             }
  926.             pstmtBusta.setTimestamp(index++,oraRec);
  927.             pstmtBusta.setString(index++,tipoOraRec.getEngineValue());
  928.             pstmtBusta.setString(index++,busta.getRiferimentoMessaggio());
  929.             pstmtBusta.setTimestamp(index++,scadenzaT);
  930.             pstmtBusta.setInt(index++,0);
  931.             pstmtBusta.setString(index++,null); // locationPD
  932.             pstmtBusta.setString(index++,null); // servizioApplicativo
  933.             pstmtBusta.setString(index++,null); // moduloInAttesa
  934.             pstmtBusta.setString(index++,null); // scenario
  935.             if(busta.getProtocollo()!=null)
  936.                 pstmtBusta.setString(index++,busta.getProtocollo()); // protocollo
  937.             else if(this.protocolFactory!=null){
  938.                 pstmtBusta.setString(index++,this.protocolFactory.getProtocol()); // protocollo
  939.             }
  940.             else{
  941.                 throw new ProtocolException("Protocol unknow");
  942.             }
  943.             pstmtBusta.setTimestamp(index++,dataRegistrazione);
  944.                 

  946.             // Add PreparedStatement
  947.             stateMSG.getPreparedStatement().put("INSERT RegistrazioneBustaForHistoryINBOX_"+busta.getID(),pstmtBusta);

  949.         } catch(Exception e) {
  950.             String id = busta.getID();
  951.             String errorMsg = "REPOSITORY_BUSTE, Errore di registrazione per History INBOX/"+id+": "+e.getMessage();
  952.             this.log.error(errorMsg,e);
  953.             try{
  954.                 if(pstmtBusta != null)
  955.                     pstmtBusta.close();
  956.             } catch(Exception er) {
  957.                 // Eccezione SQL.
  958.             }
  959.             throw new ProtocolException(errorMsg,e);
  960.         }
  961.     }
  962.     /**
  963.      * Metodo che si occupa di registrare una busta.
  964.      *
  965.      * @param busta Contiene le informazioni su di una busta  (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  966.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  967.      * @param errors Eventuali errori di validazione
  968.      * @param scadenza Scadenza Scadenza in minuti associata ad una busta, se non possiede essa stessa una scadenza
  969.      *
  970.      */
  971.     public void registraBusta(Busta busta,String tipoBusta,List<Eccezione> errors,long scadenza) throws ProtocolException{
  972.         registraBusta(busta,tipoBusta,errors,scadenza,false);
  973.     }
  974.     public void registraBusta(Busta busta,String tipoBusta,List<Eccezione> errors,long scadenza, boolean saveServizioApplicativoFruitore) throws ProtocolException{
  975.         
  976.         if (!this.isRichiesta && this.state instanceof StatelessMessage) {
  977.             ((StatelessMessage)this.state).setBusta(busta);
  978.             return;
  979.         }
  980.         
  981.         Timestamp dataRegistrazione = DateManager.getTimestamp();
  982.         
  983.         StateMessage stateMSG = (StateMessage)this.state;
  984.                 
  985.         Connection connectionDB = stateMSG.getConnectionDB();

  987.         PreparedStatement pstmtBusta = null;
  988.         PreparedStatement pstmtUpdateAccessoPdD = null;
  989.         PreparedStatement pstmtListaRiscontri = null;
  990.         PreparedStatement pstmtListaTrasmissioni = null;
  991.         PreparedStatement pstmtListaEccezioni = null;
  992.         PreparedStatement pstmtListaEccezioniValidazione = null;
  993.         PreparedStatement pstmtListaExtInfo = null;

  995.         try{

  997.             //  Impostazione scadenza
  998.             Date scadenzaBusta = busta.getScadenza();
  999.             if(scadenzaBusta == null){
  1000.                 scadenzaBusta = new Date(DateManager.getTimeMillis()+(scadenza*60*1000));
  1001.             }
  1002.             Timestamp scadenzaT = new Timestamp( scadenzaBusta.getTime()  );


  1005.             /* Busta */

  1007.             // Registrazione Busta
  1008.             StringBuilder query = new StringBuilder();
  1009.             query.append("INSERT INTO  ");
  1010.             query.append(Costanti.REPOSITORY);
  1011.             query.append(" (ID_MESSAGGIO,TIPO,MITTENTE,IDPORTA_MITTENTE,TIPO_MITTENTE,IND_TELEMATICO_MITT,DESTINATARIO,IDPORTA_DESTINATARIO,TIPO_DESTINATARIO,IND_TELEMATICO_DEST");
  1012.             query.append(",VERSIONE_SERVIZIO,SERVIZIO,TIPO_SERVIZIO,AZIONE,PROFILO_DI_COLLABORAZIONE,SERVIZIO_CORRELATO,TIPO_SERVIZIO_CORRELATO");
  1013.             query.append(",COLLABORAZIONE,SEQUENZA,INOLTRO_SENZA_DUPLICATI,CONFERMA_RICEZIONE,ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE");
  1014.             query.append(",RIFERIMENTO_MESSAGGIO,SCADENZA_BUSTA,DUPLICATI,LOCATION_PD,SERVIZIO_APPLICATIVO,MODULO_IN_ATTESA,SCENARIO,PROTOCOLLO,DATA_REGISTRAZIONE) ");
  1015.             query.append(" VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
  1016.             pstmtBusta = connectionDB.prepareStatement(query.toString());
  1017.             int index = 1;
  1018.             pstmtBusta.setString(index++,busta.getID());
  1019.             pstmtBusta.setString(index++,tipoBusta);
  1020.             pstmtBusta.setString(index++,busta.getMittente());
  1021.             pstmtBusta.setString(index++,busta.getIdentificativoPortaMittente());
  1022.             pstmtBusta.setString(index++,busta.getTipoMittente());
  1023.             pstmtBusta.setString(index++,busta.getIndirizzoMittente());
  1024.             pstmtBusta.setString(index++,busta.getDestinatario());
  1025.             pstmtBusta.setString(index++,busta.getIdentificativoPortaDestinatario());
  1026.             pstmtBusta.setString(index++,busta.getTipoDestinatario());
  1027.             pstmtBusta.setString(index++,busta.getIndirizzoDestinatario());
  1028.             pstmtBusta.setInt(index++,busta.getVersioneServizio());
  1029.             pstmtBusta.setString(index++,busta.getServizio());
  1030.             pstmtBusta.setString(index++,busta.getTipoServizio());
  1031.             pstmtBusta.setString(index++,busta.getAzione());
  1032.             pstmtBusta.setString(index++,busta.getProfiloDiCollaborazione() == null ? null : busta.getProfiloDiCollaborazione().getEngineValue());
  1033.             pstmtBusta.setString(index++,busta.getServizioCorrelato());
  1034.             pstmtBusta.setString(index++,busta.getTipoServizioCorrelato());
  1035.             pstmtBusta.setString(index++,busta.getCollaborazione());
  1036.             pstmtBusta.setLong(index++, busta.getSequenza() );
  1037.             if(Inoltro.SENZA_DUPLICATI.equals(busta.getInoltro()))
  1038.                 pstmtBusta.setInt(index++,1);
  1039.             else
  1040.                 pstmtBusta.setInt(index++,0);
  1041.             if(busta.isConfermaRicezione())
  1042.                 pstmtBusta.setInt(index++,1);
  1043.             else
  1044.                 pstmtBusta.setInt(index++,0);
  1045.             Timestamp oraRec = null;
  1046.             TipoOraRegistrazione tipoOraRec = null;
  1047.             if(busta.getOraRegistrazione()!=null && busta.getTipoOraRegistrazione()!=null){
  1048.                 oraRec = new Timestamp( busta.getOraRegistrazione().getTime() );
  1049.                 tipoOraRec = busta.getTipoOraRegistrazione();
  1050.             }else{
  1051.                 // poi sara' aggiornato.
  1052.                 oraRec = dataRegistrazione;
  1053.                 tipoOraRec = TipoOraRegistrazione.SINCRONIZZATO;
  1054.             }
  1055.             pstmtBusta.setTimestamp(index++,oraRec);
  1056.             pstmtBusta.setString(index++,tipoOraRec.getEngineValue());
  1057.             pstmtBusta.setString(index++,busta.getRiferimentoMessaggio());
  1058.             pstmtBusta.setTimestamp(index++,scadenzaT);
  1059.             pstmtBusta.setInt(index++,0);
  1060.             pstmtBusta.setString(index++,null); // locationPD
  1061.             if(saveServizioApplicativoFruitore) { // servizioApplicativo
  1062.                 pstmtBusta.setString(index++,busta.getServizioApplicativoFruitore()); 
  1063.             }
  1064.             else {
  1065.                 pstmtBusta.setString(index++,null);
  1066.             }
  1067.             pstmtBusta.setString(index++,null); // moduloInAttesa
  1068.             pstmtBusta.setString(index++,null); // scenario
  1069.             if(busta.getProtocollo()!=null)
  1070.                 pstmtBusta.setString(index++,busta.getProtocollo()); // protocollo
  1071.             else if(this.protocolFactory!=null){
  1072.                 pstmtBusta.setString(index++,this.protocolFactory.getProtocol()); // protocollo
  1073.             }
  1074.             else{
  1075.                 throw new ProtocolException("Protocol unknow");
  1076.             }
  1077.             pstmtBusta.setTimestamp(index++,dataRegistrazione);

  1079.             // Add PreparedStatement
  1080.             stateMSG.getPreparedStatement().put("INSERT RegistrazioneBusta"+tipoBusta+"_"+busta.getID(),pstmtBusta);

  1082.             
  1083.             // Update Accesso da Pdd
  1084.             query.delete(0,query.length());
  1085.             query.append("UPDATE ");
  1086.             query.append(Costanti.REPOSITORY);
  1087.             query.append(" SET ");
  1088.             query.append(this.gestoreRepositoryBuste.createSQLSet_PdD(true));
  1089.             query.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1090.             pstmtUpdateAccessoPdD = connectionDB.prepareStatement(query.toString());
  1091.             index = 1;
  1092.             pstmtUpdateAccessoPdD.setString(index++,busta.getID());
  1093.             pstmtUpdateAccessoPdD.setString(index++,tipoBusta);
  1094.             // Add PreparedStatement
  1095.             //stateMSG.getPreparedStatement().put("UPDATE RegistrazioneBustaAccessoPdD"+tipoBusta+"_"+busta.getID(),pstmtUpdateAccessoPdD);
  1096.             stateMSG.getPreparedStatement().put("INSERT RegistrazioneBusta"+tipoBusta+"_"+busta.getID()+" UPDATE RegistrazioneBustaAccessoPdD",pstmtUpdateAccessoPdD);
  1097.             
  1098.             
  1099.             if (this.state instanceof StatefulMessage ) {


  1102.                 /* Lista Riscontri */
  1103.                 for(int i=0; i<busta.sizeListaRiscontri(); i++){
  1104.                     Riscontro riscontro = busta.getRiscontro(i);
  1105.                     query.delete(0,query.length());
  1106.                     query.append("INSERT INTO  ");
  1107.                     query.append(Costanti.LISTA_RISCONTRI);
  1108.                     query.append(" (ID_MESSAGGIO,TIPO,ID_RISCONTRO,RICEVUTA,ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE,DATA_REGISTRAZIONE)");
  1109.                     query.append(" VALUES (?,?,?,?,?,?,?)");
  1110.                     pstmtListaRiscontri = connectionDB.prepareStatement(query.toString());
  1111.                     index = 1;
  1112.                     pstmtListaRiscontri.setString(index++,busta.getID());
  1113.                     pstmtListaRiscontri.setString(index++,tipoBusta);
  1114.                     pstmtListaRiscontri.setString(index++,riscontro.getID());
  1115.                     pstmtListaRiscontri.setString(index++,riscontro.getRicevuta());
  1116.                     Timestamp oraRecRiscontro = null;
  1117.                     if(riscontro.getOraRegistrazione()!=null ){
  1118.                         oraRecRiscontro = new Timestamp( riscontro.getOraRegistrazione().getTime() );
  1119.                     }
  1120.                     pstmtListaRiscontri.setTimestamp(index++,oraRecRiscontro);
  1121.                     pstmtListaRiscontri.setString(index++,riscontro.getTipoOraRegistrazione().getEngineValue());
  1122.                     pstmtListaRiscontri.setTimestamp(index++,dataRegistrazione);

  1124.                     // Add PreparedStatement
  1125.                     stateMSG.getPreparedStatement().put("INSERT RegistrazioneListaRiscontri_riscontro["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaRiscontri);
  1126.                 }

  1128.                 /* Lista Trasmissioni */
  1129.                 for(int i=0; i<busta.sizeListaTrasmissioni(); i++){

  1131.                     Trasmissione trasmissione = busta.getTrasmissione(i);
  1132.                     query.delete(0,query.length());
  1133.                     query.append("INSERT INTO  ");
  1134.                     query.append(Costanti.LISTA_TRASMISSIONI);
  1135.                     query.append(" (ID_MESSAGGIO,TIPO,ORIGINE,TIPO_ORIGINE,DESTINAZIONE,TIPO_DESTINAZIONE,ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE,DATA_REGISTRAZIONE)");
  1136.                     query.append(" VALUES (?,?,?,?,?,?,?,?,?)");
  1137.                     pstmtListaTrasmissioni = connectionDB.prepareStatement(query.toString());
  1138.                     index = 1;
  1139.                     pstmtListaTrasmissioni.setString(index++,busta.getID());
  1140.                     pstmtListaTrasmissioni.setString(index++,tipoBusta);
  1141.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getOrigine());
  1142.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getTipoOrigine());
  1143.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getDestinazione());
  1144.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getTipoDestinazione());
  1145.                     Timestamp oraRecTrasmissione = null;
  1146.                     if( trasmissione.getOraRegistrazione()!=null ){
  1147.                         oraRecTrasmissione = new Timestamp( trasmissione.getOraRegistrazione().getTime()  );
  1148.                     }
  1149.                     pstmtListaTrasmissioni.setTimestamp(index++,oraRecTrasmissione);
  1150.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getTempo().getEngineValue());
  1151.                     pstmtListaTrasmissioni.setTimestamp(index++,dataRegistrazione);

  1153.                     // Add PreparedStatement
  1154.                     stateMSG.getPreparedStatement().put("INSERT RegistrazioneListaTrasmissioni_trasmissione["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaTrasmissioni);
  1155.                 }

  1157.                 /* Lista Eccezioni */
  1158.                 for(int i=0; i<busta.sizeListaEccezioni(); i++){
  1159.                     Eccezione eccezione = busta.getEccezione(i);
  1160.                     query.delete(0,query.length());
  1161.                     query.append("INSERT INTO  ");
  1162.                     query.append(Costanti.LISTA_ECCEZIONI);
  1163.                     query.append(" (ID_MESSAGGIO,TIPO,VALIDAZIONE,CONTESTO,CODICE,RILEVANZA,POSIZIONE,DATA_REGISTRAZIONE)");
  1164.                     query.append(" VALUES (?,?,?,?,?,?,?,?)");
  1165.                     pstmtListaEccezioni = connectionDB.prepareStatement(query.toString());
  1166.                     index = 1;
  1167.                     pstmtListaEccezioni.setString(index++,busta.getID());
  1168.                     pstmtListaEccezioni.setString(index++,tipoBusta);
  1169.                     pstmtListaEccezioni.setInt(index++,0); // eccezione proprietaria delle busta
  1170.                     pstmtListaEccezioni.setString(index++,eccezione.getContestoCodifica().getEngineValue());
  1171.                     pstmtListaEccezioni.setInt(index++,eccezione.getCodiceEccezione().getCodice());
  1172.                     pstmtListaEccezioni.setString(index++,eccezione.getRilevanza().getEngineValue());
  1173.                     pstmtListaEccezioni.setString(index++,eccezione.getDescrizione(this.protocolFactory));
  1174.                     pstmtListaEccezioni.setTimestamp(index++,dataRegistrazione);

  1176.                     // Add PreparedStatement
  1177.                     stateMSG.getPreparedStatement().put("INSERT RegistrazioneListaEccezioni_eccezioneBusta["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaEccezioni);
  1178.                 }

  1180.                 /* Lista Eccezioni Validazione */
  1181.                 if(errors!=null){
  1182.                     for(int i=0; i<errors.size(); i++){
  1183.                         Eccezione eccezione = errors.get(i);
  1184.                         query.delete(0,query.length());
  1185.                         query.append("INSERT INTO  ");
  1186.                         query.append(Costanti.LISTA_ECCEZIONI);
  1187.                         query.append(" (ID_MESSAGGIO,TIPO,VALIDAZIONE,CONTESTO,CODICE,RILEVANZA,POSIZIONE,DATA_REGISTRAZIONE)");
  1188.                         query.append(" VALUES (?,?,?,?,?,?,?,?)");
  1189.                         pstmtListaEccezioniValidazione = connectionDB.prepareStatement(query.toString());
  1190.                         index = 1;
  1191.                         pstmtListaEccezioniValidazione.setString(index++,busta.getID());
  1192.                         pstmtListaEccezioniValidazione.setString(index++,tipoBusta);
  1193.                         pstmtListaEccezioniValidazione.setInt(index++,1); // eccezione arrivata dopo la validazione
  1194.                         pstmtListaEccezioniValidazione.setString(index++,eccezione.getContestoCodifica().getEngineValue());
  1195.                         pstmtListaEccezioniValidazione.setInt(index++,eccezione.getCodiceEccezione().getCodice());
  1196.                         pstmtListaEccezioniValidazione.setString(index++,eccezione.getRilevanza().getEngineValue());
  1197.                         pstmtListaEccezioniValidazione.setString(index++,eccezione.getDescrizione(this.protocolFactory));
  1198.                         pstmtListaEccezioniValidazione.setTimestamp(index++,dataRegistrazione);

  1200.                         // Add PreparedStatement
  1201.                         stateMSG.getPreparedStatement().put("INSERT RegistrazioneListaEccezioni_eccezioneValidazione["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaEccezioniValidazione);
  1202.                     }
  1203.                 }

  1205.                 /* Lista ExtProtocolInfo */
  1206.                 if(busta.sizeProperties()>0){
  1207.                     String[] names = busta.getPropertiesNames();
  1208.                     if(names!=null && names.length>0){
  1209.                         for (int i = 0; i < names.length; i++) {
  1210.                             String name = names[i];
  1211.                             String value = busta.getProperty(name);
  1212.                             
  1213.                             query.delete(0,query.length());
  1214.                             query.append("INSERT INTO  ");
  1215.                             query.append(Costanti.LISTA_EXT_INFO);
  1216.                             query.append(" (ID_MESSAGGIO,TIPO,NOME,VALORE,DATA_REGISTRAZIONE)");
  1217.                             query.append(" VALUES (?,?,?,?,?)");
  1218.                             pstmtListaExtInfo = connectionDB.prepareStatement(query.toString());
  1219.                             index = 1;
  1220.                             pstmtListaExtInfo.setString(index++,busta.getID());
  1221.                             pstmtListaExtInfo.setString(index++,tipoBusta);
  1222.                             pstmtListaExtInfo.setString(index++,name);
  1223.                             pstmtListaExtInfo.setString(index++,value);
  1224.                             pstmtListaExtInfo.setTimestamp(index++,dataRegistrazione);

  1226.                             // Add PreparedStatement
  1227.                             stateMSG.getPreparedStatement().put("INSERT RegistrazioneListaExtInfoProtocol_info["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaExtInfo);
  1228.                         }
  1229.                     }
  1230.                 }
  1231.                 
  1232.             }
  1233.         } catch(Exception e) {
  1234.             String id = busta.getID();
  1235.             String errorMsg = "REPOSITORY_BUSTE, Errore di registrazione "+tipoBusta+"/"+id+": "+e.getMessage();
  1236.             this.log.error(errorMsg,e);
  1237.             try{
  1238.                 if(pstmtBusta != null)
  1239.                     pstmtBusta.close();
  1240.             } catch(Exception er) {
  1241.                 // Eccezione SQL.
  1242.             }
  1243.             try{
  1244.                 if(pstmtUpdateAccessoPdD!= null)
  1245.                     pstmtUpdateAccessoPdD.close();
  1246.             } catch(Exception er) {
  1247.                 // Eccezione SQL.
  1248.             }
  1249.             try{
  1250.                 if(pstmtListaRiscontri != null)
  1251.                     pstmtListaRiscontri.close();
  1252.             } catch(Exception er) {
  1253.                 // Eccezione SQL.
  1254.             }
  1255.             try{
  1256.                 if(pstmtListaTrasmissioni != null)
  1257.                     pstmtListaTrasmissioni.close();
  1258.             } catch(Exception er) {
  1259.                 // Eccezione SQL.
  1260.             }
  1261.             try{
  1262.                 if(pstmtListaEccezioni != null)
  1263.                     pstmtListaEccezioni.close();
  1264.             } catch(Exception er) {
  1265.                 // Eccezione SQL.
  1266.             }
  1267.             try{
  1268.                 if(pstmtListaEccezioniValidazione != null)
  1269.                     pstmtListaEccezioniValidazione.close();
  1270.             } catch(Exception er) {
  1271.                 // Eccezione SQL.
  1272.             }
  1273.             try{
  1274.                 if(pstmtListaExtInfo != null)
  1275.                     pstmtListaExtInfo.close();
  1276.             } catch(Exception er) {
  1277.                 // Eccezione SQL.
  1278.             }
  1279.             throw new ProtocolException(errorMsg,e);
  1280.         }

  1282.         // tengo la busta anche nello state message per recuperarla senza passare dal db        
  1283.         if (stateMSG instanceof StatelessMessage) ((StatelessMessage)stateMSG).setBusta(busta);
  1284.     }

  1286.     
  1287.     public void aggiornaProprietaBusta(Map<String, String> properties, String idBusta,String tipoBusta) throws ProtocolException{
  1288.                 
  1289.         StateMessage stateMSG = (StateMessage)this.state;
  1290.                 
  1291.         Connection connectionDB = stateMSG.getConnectionDB();

  1293.         if(connectionDB==null){
  1294.             return ;
  1295.         }
  1296.         
  1297.         PreparedStatement pstmtDeleteListaExtInfo = null;
  1298.         PreparedStatement pstmtListaExtInfo = null;

  1300.         try{

  1302.             //  elimino lista ext-info
  1303.             StringBuilder queryDelete = new StringBuilder();
  1304.             queryDelete.delete(0,queryDelete.length());
  1305.             queryDelete.append("DELETE FROM ");
  1306.             queryDelete.append(Costanti.LISTA_EXT_INFO);
  1307.             queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  1308.             pstmtDeleteListaExtInfo = connectionDB.prepareStatement(queryDelete.toString());
  1309.             pstmtDeleteListaExtInfo.setString(1,idBusta);
  1310.             pstmtDeleteListaExtInfo.setString(2,tipoBusta);

  1312.             //  Add PreparedStatement
  1313.             stateMSG.getPreparedStatement().put("DELETE(UPDATE) AggiornamentoBusta_listaExtInfo"+tipoBusta+"_"+idBusta,pstmtDeleteListaExtInfo);
  1314.             
  1315.             /* Lista ExtProtocolInfo */
  1316.             if(properties.size()>0){
  1317.                 int index = 0;
  1318.                 for (String name : properties.keySet()) {
  1319.                     String value = properties.get(name);
  1320.                         
  1321.                     StringBuilder query = new StringBuilder();
  1322.                     query.delete(0,query.length());
  1323.                     query.append("INSERT INTO  ");
  1324.                     query.append(Costanti.LISTA_EXT_INFO);
  1325.                     query.append(" (ID_MESSAGGIO,TIPO,NOME,VALORE)");
  1326.                     query.append(" VALUES (?,?,?,?)");
  1327.                     pstmtListaExtInfo = connectionDB.prepareStatement(query.toString());
  1328.                     pstmtListaExtInfo.setString(1,idBusta);
  1329.                     pstmtListaExtInfo.setString(2,tipoBusta);
  1330.                     pstmtListaExtInfo.setString(3,name);
  1331.                     pstmtListaExtInfo.setString(4,value);

  1333.                     // Add PreparedStatement
  1334.                     stateMSG.getPreparedStatement().put("INSERT(UPDATE) RegistrazioneListaExtInfoProtocol_info["+index+"]_"+tipoBusta+"_"+idBusta,pstmtListaExtInfo);
  1335.                     
  1336.                     index++;
  1337.                 }
  1338.             }
  1339.                 
  1340.         } catch(Exception e) {
  1341.             String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento proprieta' "+tipoBusta+"/"+idBusta+": "+e.getMessage();
  1342.             this.log.error(errorMsg,e);
  1343.             try{
  1344.                 if(pstmtDeleteListaExtInfo != null)
  1345.                     pstmtDeleteListaExtInfo.close();
  1346.             } catch(Exception er) {
  1347.                 // Eccezione SQL.
  1348.             }
  1349.             try{
  1350.                 if(pstmtListaExtInfo != null)
  1351.                     pstmtListaExtInfo.close();
  1352.             } catch(Exception er) {
  1353.                 // Eccezione SQL.
  1354.             }
  1355.             throw new ProtocolException(errorMsg,e);
  1356.         }

  1358.     }
  1359.     
  1360.     /**
  1361.      * Metodo che si occupa di aggiornare i dati di una busta (non aggiorna le liste).
  1362.      *
  1363.      * @param busta Contiene le informazioni su di una busta  (tipo {@link org.openspcoop2.protocol.sdk.Busta})
  1364.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  1365.      * @param scadenza Scadenza Scadenza associata ad una busta, se non possiede essa stessa una scadenza
  1366.      * @param errors Eventuali errori di validazione
  1367.      *
  1368.      */
  1369.     public void aggiornaBusta(Busta busta,String tipoBusta,long scadenza,List<Eccezione> errors) throws ProtocolException{
  1370.         aggiornaBusta(busta, tipoBusta, scadenza, errors, false);
  1371.     }
  1372.     public void aggiornaBusta(Busta busta,String tipoBusta,long scadenza,List<Eccezione> errors, boolean saveServizioApplicativoFruitore) throws ProtocolException{
  1373.         
  1374.         if (!this.isRichiesta && this.state instanceof StatelessMessage) {
  1375.             ((StatelessMessage)this.state).setBusta(busta);
  1376.             return;
  1377.         }
  1378.         
  1379.         StateMessage stateMSG = (StateMessage)this.state;
  1380.         
  1381.         Connection connectionDB = stateMSG.getConnectionDB();

  1383.         PreparedStatement pstmtBusta = null;
  1384.         PreparedStatement pstmtDeleteListaRiscontri = null;
  1385.         PreparedStatement pstmtDeleteListaTrasmissioni = null;
  1386.         PreparedStatement pstmtDeleteListaEccezioni = null; // vale sia per validazione che per non...
  1387.         PreparedStatement pstmtDeleteListaExtInfo = null;
  1388.         PreparedStatement pstmtListaRiscontri = null;
  1389.         PreparedStatement pstmtListaTrasmissioni = null;
  1390.         PreparedStatement pstmtListaEccezioni = null;
  1391.         PreparedStatement pstmtListaEccezioniValidazione = null;
  1392.         PreparedStatement pstmtListaExtInfo = null;
  1393.         try{

  1395.             Timestamp dataRegistrazione = DateManager.getTimestamp();
  1396.             
  1397.             // Impostazione scadenza
  1398.             Date scadenzaBusta = busta.getScadenza();
  1399.             if(scadenzaBusta == null){
  1400.                 scadenzaBusta = new Date(DateManager.getTimeMillis()+(scadenza*60*1000));
  1401.             }
  1402.             Timestamp scadenzaT = new Timestamp( scadenzaBusta.getTime()  );

  1404.             /* Busta */

  1406.             // Registrazione Busta
  1407.             StringBuilder query = new StringBuilder();
  1408.             query.append("UPDATE  ");
  1409.             query.append(Costanti.REPOSITORY);
  1410.             query.append(" SET ");
  1411.             query.append("MITTENTE = ? ,");
  1412.             query.append("IDPORTA_MITTENTE = ? ,");
  1413.             query.append("TIPO_MITTENTE = ? ,");
  1414.             query.append("IND_TELEMATICO_MITT = ? ,");
  1415.             query.append("DESTINATARIO = ? ,");
  1416.             query.append("IDPORTA_DESTINATARIO = ? ,");
  1417.             query.append("TIPO_DESTINATARIO = ? ,");
  1418.             query.append("IND_TELEMATICO_DEST = ? ,");
  1419.             query.append("VERSIONE_SERVIZIO = ? ,");
  1420.             query.append("SERVIZIO = ? ,");
  1421.             query.append("TIPO_SERVIZIO = ? ,");
  1422.             query.append("AZIONE = ? ,");
  1423.             query.append("PROFILO_DI_COLLABORAZIONE = ? ,");
  1424.             query.append("SERVIZIO_CORRELATO = ? ,");
  1425.             query.append("TIPO_SERVIZIO_CORRELATO = ? ,");
  1426.             query.append("COLLABORAZIONE = ? ,");
  1427.             query.append("SEQUENZA = ? ,");
  1428.             query.append("INOLTRO_SENZA_DUPLICATI = ? ,");
  1429.             query.append("CONFERMA_RICEZIONE = ? ,");
  1430.             query.append("ORA_REGISTRAZIONE = ? ,");
  1431.             query.append("TIPO_ORA_REGISTRAZIONE = ? ,");
  1432.             query.append("RIFERIMENTO_MESSAGGIO = ? ,");
  1433.             query.append("SCADENZA_BUSTA = ? ,");
  1434.             query.append("DATA_REGISTRAZIONE = ? ");
  1435.             if(saveServizioApplicativoFruitore) {
  1436.                 query.append("SERVIZIO_APPLICATIVO = ? ");
  1437.             }
  1438.             query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  1439.             pstmtBusta = connectionDB.prepareStatement(query.toString());
  1440.             int index = 1;
  1441.             pstmtBusta.setString(index++,busta.getMittente());
  1442.             pstmtBusta.setString(index++,busta.getIdentificativoPortaMittente());
  1443.             pstmtBusta.setString(index++,busta.getTipoMittente());
  1444.             pstmtBusta.setString(index++,busta.getIndirizzoMittente());
  1445.             pstmtBusta.setString(index++,busta.getDestinatario());
  1446.             pstmtBusta.setString(index++,busta.getIdentificativoPortaDestinatario());
  1447.             pstmtBusta.setString(index++,busta.getTipoDestinatario());
  1448.             pstmtBusta.setString(index++,busta.getIndirizzoDestinatario());
  1449.             pstmtBusta.setInt(index++,busta.getVersioneServizio());
  1450.             pstmtBusta.setString(index++,busta.getServizio());
  1451.             pstmtBusta.setString(index++,busta.getTipoServizio());
  1452.             pstmtBusta.setString(index++,busta.getAzione());
  1453.             pstmtBusta.setString(index++,busta.getProfiloDiCollaborazione() == null ? null : busta.getProfiloDiCollaborazione().getEngineValue());
  1454.             pstmtBusta.setString(index++,busta.getServizioCorrelato());
  1455.             pstmtBusta.setString(index++,busta.getTipoServizioCorrelato());
  1456.             pstmtBusta.setString(index++,busta.getCollaborazione());
  1457.             pstmtBusta.setLong(index++, busta.getSequenza());
  1458.             if(Inoltro.SENZA_DUPLICATI.equals(busta.getInoltro()))
  1459.                 pstmtBusta.setInt(index++,1);
  1460.             else
  1461.                 pstmtBusta.setInt(index++,0);
  1462.             if(busta.isConfermaRicezione())
  1463.                 pstmtBusta.setInt(index++,1);
  1464.             else
  1465.                 pstmtBusta.setInt(index++,0);
  1466.             Timestamp oraRec = null;
  1467.             TipoOraRegistrazione tipoOraRec = null;
  1468.             if(busta.getOraRegistrazione()!=null && busta.getTipoOraRegistrazione()!=null){
  1469.                 oraRec = new Timestamp( busta.getOraRegistrazione().getTime() );
  1470.                 tipoOraRec = busta.getTipoOraRegistrazione();
  1471.             }
  1472.             pstmtBusta.setTimestamp(index++,oraRec);
  1473.             pstmtBusta.setString(index++,tipoOraRec!=null ? tipoOraRec.getEngineValue() : null);
  1474.             pstmtBusta.setString(index++,busta.getRiferimentoMessaggio());
  1475.             pstmtBusta.setTimestamp(index++,scadenzaT);
  1476.             pstmtBusta.setTimestamp(index++,dataRegistrazione);
  1477.             if(saveServizioApplicativoFruitore) {
  1478.                 pstmtBusta.setString(index++,busta.getServizioApplicativoFruitore());
  1479.             }
  1480.             
  1481.             pstmtBusta.setString(index++,busta.getID());
  1482.             pstmtBusta.setString(index++,tipoBusta);

  1484.             // Add PreparedStatement
  1485.             stateMSG.getPreparedStatement().put("UPDATE AggiornamentoBusta"+tipoBusta+"_"+busta.getID(),pstmtBusta);

  1487.             if(errors!=null){

  1489.                 // cancella liste
  1490.                 //  elimino lista trasmiossioni
  1491.                 StringBuilder queryDelete = new StringBuilder();
  1492.                 queryDelete.append("DELETE FROM ");
  1493.                 queryDelete.append(Costanti.LISTA_TRASMISSIONI);
  1494.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  1495.                 pstmtDeleteListaRiscontri = connectionDB.prepareStatement(queryDelete.toString());
  1496.                 index = 1;
  1497.                 pstmtDeleteListaRiscontri.setString(index++,busta.getID());
  1498.                 pstmtDeleteListaRiscontri.setString(index++,tipoBusta);

  1500.                 //  Add PreparedStatement
  1501.                 stateMSG.getPreparedStatement().put("DELETE(UPDATE) AggiornamentoBusta_listaRiscontri"+tipoBusta+"_"+busta.getID(),pstmtDeleteListaRiscontri);

  1503.                 //  elimino lista riscontri
  1504.                 queryDelete.delete(0,queryDelete.length());
  1505.                 queryDelete.append("DELETE FROM ");
  1506.                 queryDelete.append(Costanti.LISTA_RISCONTRI);
  1507.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  1508.                 pstmtDeleteListaTrasmissioni = connectionDB.prepareStatement(queryDelete.toString());
  1509.                 index = 1;
  1510.                 pstmtDeleteListaTrasmissioni.setString(index++,busta.getID());
  1511.                 pstmtDeleteListaTrasmissioni.setString(index++,tipoBusta);

  1513.                 //  Add PreparedStatement
  1514.                 stateMSG.getPreparedStatement().put("DELETE(UPDATE) AggiornamentoBusta_listaTrasmissioni"+tipoBusta+"_"+busta.getID(),pstmtDeleteListaTrasmissioni);

  1516.                 //  elimino lista eccezioni
  1517.                 queryDelete.delete(0,queryDelete.length());
  1518.                 queryDelete.append("DELETE FROM ");
  1519.                 queryDelete.append(Costanti.LISTA_ECCEZIONI);
  1520.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  1521.                 pstmtDeleteListaEccezioni = connectionDB.prepareStatement(queryDelete.toString());
  1522.                 index = 1;
  1523.                 pstmtDeleteListaEccezioni.setString(index++,busta.getID());
  1524.                 pstmtDeleteListaEccezioni.setString(index++,tipoBusta);

  1526.                 //  Add PreparedStatement
  1527.                 stateMSG.getPreparedStatement().put("DELETE(UPDATE) AggiornamentoBusta_listaEccezioni"+tipoBusta+"_"+busta.getID(),pstmtDeleteListaEccezioni);
  1528.                 
  1529.                 //  elimino lista ext-info
  1530.                 queryDelete.delete(0,queryDelete.length());
  1531.                 queryDelete.append("DELETE FROM ");
  1532.                 queryDelete.append(Costanti.LISTA_EXT_INFO);
  1533.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  1534.                 pstmtDeleteListaExtInfo = connectionDB.prepareStatement(queryDelete.toString());
  1535.                 index = 1;
  1536.                 pstmtDeleteListaExtInfo.setString(index++,busta.getID());
  1537.                 pstmtDeleteListaExtInfo.setString(index++,tipoBusta);

  1539.                 //  Add PreparedStatement
  1540.                 stateMSG.getPreparedStatement().put("DELETE(UPDATE) AggiornamentoBusta_listaExtInfo"+tipoBusta+"_"+busta.getID(),pstmtDeleteListaExtInfo);
  1541.                 

  1543.                 // Inserisco nuove liste

  1545.                 /* Lista Riscontri */
  1546.                 for(int i=0; i<busta.sizeListaRiscontri(); i++){
  1547.                     Riscontro riscontro = busta.getRiscontro(i);
  1548.                     query.delete(0,query.length());
  1549.                     query.append("INSERT INTO  ");
  1550.                     query.append(Costanti.LISTA_RISCONTRI);
  1551.                     query.append(" (ID_MESSAGGIO,TIPO,ID_RISCONTRO,RICEVUTA,ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE,DATA_REGISTRAZIONE)");
  1552.                     query.append(" VALUES (?,?,?,?,?,?,?)");
  1553.                     pstmtListaRiscontri = connectionDB.prepareStatement(query.toString());
  1554.                     index = 1;
  1555.                     pstmtListaRiscontri.setString(index++,busta.getID());
  1556.                     pstmtListaRiscontri.setString(index++,tipoBusta);
  1557.                     pstmtListaRiscontri.setString(index++,riscontro.getID());
  1558.                     pstmtListaRiscontri.setString(index++,riscontro.getRicevuta());
  1559.                     Timestamp oraRecRiscontro = null;
  1560.                     if(riscontro.getOraRegistrazione()!=null ){
  1561.                         oraRecRiscontro = new Timestamp( riscontro.getOraRegistrazione().getTime() );
  1562.                     }
  1563.                     pstmtListaRiscontri.setTimestamp(index++,oraRecRiscontro);
  1564.                     pstmtListaRiscontri.setString(index++,riscontro.getTipoOraRegistrazione().getEngineValue());
  1565.                     pstmtListaRiscontri.setTimestamp(index++,dataRegistrazione);

  1567.                     // Add PreparedStatement
  1568.                     stateMSG.getPreparedStatement().put("INSERT(UPDATE) RegistrazioneListaRiscontri_riscontro["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaRiscontri);
  1569.                 }

  1571.                 /* Lista Trasmissioni */
  1572.                 for(int i=0; i<busta.sizeListaTrasmissioni(); i++){
  1573.                     Trasmissione trasmissione = busta.getTrasmissione(i);
  1574.                     query.delete(0,query.length());
  1575.                     query.append("INSERT INTO  ");
  1576.                     query.append(Costanti.LISTA_TRASMISSIONI);
  1577.                     query.append(" (ID_MESSAGGIO,TIPO,ORIGINE,TIPO_ORIGINE,DESTINAZIONE,TIPO_DESTINAZIONE,ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE,DATA_REGISTRAZIONE)");
  1578.                     query.append(" VALUES (?,?,?,?,?,?,?,?,?)");
  1579.                     pstmtListaTrasmissioni = connectionDB.prepareStatement(query.toString());
  1580.                     index = 1;
  1581.                     pstmtListaTrasmissioni.setString(index++,busta.getID());
  1582.                     pstmtListaTrasmissioni.setString(index++,tipoBusta);
  1583.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getOrigine());
  1584.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getTipoOrigine());
  1585.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getDestinazione());
  1586.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getTipoDestinazione());
  1587.                     Timestamp oraRecTrasmissione = null;
  1588.                     if( trasmissione.getOraRegistrazione()!=null ){
  1589.                         oraRecTrasmissione = new Timestamp( trasmissione.getOraRegistrazione().getTime()  );
  1590.                     }
  1591.                     pstmtListaTrasmissioni.setTimestamp(index++,oraRecTrasmissione);
  1592.                     pstmtListaTrasmissioni.setString(index++,trasmissione.getTempo().getEngineValue());
  1593.                     pstmtListaTrasmissioni.setTimestamp(index++,dataRegistrazione);

  1595.                     // Add PreparedStatement
  1596.                     stateMSG.getPreparedStatement().put("INSERT(UPDATE) RegistrazioneListaTrasmissioni_trasmissione["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaTrasmissioni);
  1597.                 }

  1599.                 /* Lista Eccezioni */
  1600.                 for(int i=0; i<busta.sizeListaEccezioni(); i++){
  1601.                     Eccezione eccezione = busta.getEccezione(i);
  1602.                     query.delete(0,query.length());
  1603.                     query.append("INSERT INTO  ");
  1604.                     query.append(Costanti.LISTA_ECCEZIONI);
  1605.                     query.append(" (ID_MESSAGGIO,TIPO,VALIDAZIONE,CONTESTO,CODICE,RILEVANZA,POSIZIONE,DATA_REGISTRAZIONE)");
  1606.                     query.append(" VALUES (?,?,?,?,?,?,?,?)");
  1607.                     pstmtListaEccezioni = connectionDB.prepareStatement(query.toString());
  1608.                     index = 1;
  1609.                     pstmtListaEccezioni.setString(index++,busta.getID());
  1610.                     pstmtListaEccezioni.setString(index++,tipoBusta);
  1611.                     pstmtListaEccezioni.setInt(index++,0); // eccezione proprietaria delle busta
  1612.                     pstmtListaEccezioni.setString(index++,eccezione.getContestoCodifica().getEngineValue());
  1613.                     pstmtListaEccezioni.setInt(index++,eccezione.getCodiceEccezione().getCodice());
  1614.                     pstmtListaEccezioni.setString(index++,eccezione.getRilevanza().getEngineValue());
  1615.                     pstmtListaEccezioni.setString(index++,eccezione.getDescrizione(this.protocolFactory));
  1616.                     pstmtListaEccezioni.setTimestamp(index++,dataRegistrazione);

  1618.                     // Add PreparedStatement
  1619.                     stateMSG.getPreparedStatement().put("INSERT(UPDATE) RegistrazioneListaEccezioni_eccezioneBusta["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaEccezioni);
  1620.                 }

  1622.                 /* Lista Eccezioni Validazione */
  1623.                 for(int i=0; i<errors.size(); i++){
  1624.                     Eccezione eccezione = errors.get(i);
  1625.                     query.delete(0,query.length());
  1626.                     query.append("INSERT INTO  ");
  1627.                     query.append(Costanti.LISTA_ECCEZIONI);
  1628.                     query.append(" (ID_MESSAGGIO,TIPO,VALIDAZIONE,CONTESTO,CODICE,RILEVANZA,POSIZIONE,DATA_REGISTRAZIONE)");
  1629.                     query.append(" VALUES (?,?,?,?,?,?,?,?)");
  1630.                     pstmtListaEccezioniValidazione = connectionDB.prepareStatement(query.toString());
  1631.                     index = 1;
  1632.                     pstmtListaEccezioniValidazione.setString(index++,busta.getID());
  1633.                     pstmtListaEccezioniValidazione.setString(index++,tipoBusta);
  1634.                     pstmtListaEccezioniValidazione.setInt(index++,1); // eccezione arrivata dopo la validazione
  1635.                     pstmtListaEccezioniValidazione.setString(index++,eccezione.getContestoCodifica().getEngineValue());
  1636.                     pstmtListaEccezioniValidazione.setInt(index++,eccezione.getCodiceEccezione().getCodice());
  1637.                     pstmtListaEccezioniValidazione.setString(index++,eccezione.getRilevanza().getEngineValue());
  1638.                     pstmtListaEccezioniValidazione.setString(index++,eccezione.getDescrizione(this.protocolFactory));
  1639.                     pstmtListaEccezioniValidazione.setTimestamp(index++,dataRegistrazione);

  1641.                     // Add PreparedStatement
  1642.                     stateMSG.getPreparedStatement().put("INSERT(UPDATE) RegistrazioneListaEccezioni_eccezioneValidazione["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaEccezioniValidazione);
  1643.                 }
  1644.                 
  1645.                 /* Lista ExtProtocolInfo */
  1646.                 if(busta.sizeProperties()>0){
  1647.                     String[] names = busta.getPropertiesNames();
  1648.                     if(names!=null && names.length>0){
  1649.                         for (int i = 0; i < names.length; i++) {
  1650.                             String name = names[i];
  1651.                             String value = busta.getProperty(name);
  1652.                             
  1653.                             query.delete(0,query.length());
  1654.                             query.append("INSERT INTO  ");
  1655.                             query.append(Costanti.LISTA_EXT_INFO);
  1656.                             query.append(" (ID_MESSAGGIO,TIPO,NOME,VALORE,DATA_REGISTRAZIONE)");
  1657.                             query.append(" VALUES (?,?,?,?,?)");
  1658.                             pstmtListaExtInfo = connectionDB.prepareStatement(query.toString());
  1659.                             index = 1;
  1660.                             pstmtListaExtInfo.setString(index++,busta.getID());
  1661.                             pstmtListaExtInfo.setString(index++,tipoBusta);
  1662.                             pstmtListaExtInfo.setString(index++,name);
  1663.                             pstmtListaExtInfo.setString(index++,value);
  1664.                             pstmtListaExtInfo.setTimestamp(index++,dataRegistrazione);

  1666.                             // Add PreparedStatement
  1667.                             stateMSG.getPreparedStatement().put("INSERT(UPDATE) RegistrazioneListaExtInfoProtocol_info["+i+"]_"+tipoBusta+"_"+busta.getID(),pstmtListaExtInfo);
  1668.                         }
  1669.                     }
  1670.                 }
  1671.             }


  1674.         } catch(Exception e) {
  1675.             String id = busta.getID();
  1676.             String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento "+tipoBusta+"/"+id+": "+e.getMessage();
  1677.             this.log.error(errorMsg,e);
  1678.             try{
  1679.                 if(pstmtBusta != null)
  1680.                     pstmtBusta.close();
  1681.             } catch(Exception er) {
  1682.                 // Eccezione SQL.
  1683.             }
  1684.             try{
  1685.                 if(pstmtDeleteListaRiscontri!= null)
  1686.                     pstmtDeleteListaRiscontri.close();
  1687.             } catch(Exception er) {
  1688.                 // Eccezione SQL.
  1689.             }
  1690.             try{
  1691.                 if(pstmtDeleteListaTrasmissioni!= null)
  1692.                     pstmtDeleteListaTrasmissioni.close();
  1693.             } catch(Exception er) {
  1694.                 // Eccezione SQL.
  1695.             }
  1696.             try{
  1697.                 if(pstmtDeleteListaEccezioni!= null)
  1698.                     pstmtDeleteListaEccezioni.close();
  1699.             } catch(Exception er) {
  1700.                 // Eccezione SQL.
  1701.             }
  1702.             try{
  1703.                 if(pstmtDeleteListaExtInfo!= null)
  1704.                     pstmtDeleteListaExtInfo.close();
  1705.             } catch(Exception er) {
  1706.                 // Eccezione SQL.
  1707.             }
  1708.             try{
  1709.                 if(pstmtListaRiscontri != null)
  1710.                     pstmtListaRiscontri.close();
  1711.             } catch(Exception er) {
  1712.                 // Eccezione SQL.
  1713.             }
  1714.             try{
  1715.                 if(pstmtListaTrasmissioni != null)
  1716.                     pstmtListaTrasmissioni.close();
  1717.             } catch(Exception er) {
  1718.                 // Eccezione SQL.
  1719.             }
  1720.             try{
  1721.                 if(pstmtListaEccezioni != null)
  1722.                     pstmtListaEccezioni.close();
  1723.             } catch(Exception er) {
  1724.                 // Eccezione SQL.
  1725.             }
  1726.             try{
  1727.                 if(pstmtListaEccezioniValidazione != null)
  1728.                     pstmtListaEccezioniValidazione.close();
  1729.             } catch(Exception er) {
  1730.                 // Eccezione SQL.
  1731.             }
  1732.             try{
  1733.                 if(pstmtListaExtInfo != null)
  1734.                     pstmtListaExtInfo.close();
  1735.             } catch(Exception er) {
  1736.                 // Eccezione SQL.
  1737.             }
  1738.             throw new ProtocolException(errorMsg,e);
  1739.         }

  1741.         if (stateMSG instanceof StatelessMessage)   ((StatelessMessage)this.state).setBusta(busta);

  1743.     }

  1745.     /**
  1746.      * Aggiorna l'informazione di duplicati della busta.
  1747.      *
  1748.      * @param id identificativo della busta da ritornare.
  1749.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  1750.      *
  1751.      */
  1752.     private void aggiornaDuplicati(String id,String tipoBusta)throws ProtocolException{

  1754.         StateMessage stateMSG = (StateMessage)this.state;
  1755.         Connection connectionDB = stateMSG.getConnectionDB();

  1757.         PreparedStatement pstmt = null;
  1758.         try{

  1760.             // Costruzione Query
  1761.             StringBuilder query = new StringBuilder();
  1762.             query.append("UPDATE ");
  1763.             query.append(Costanti.REPOSITORY);
  1764.             query.append(" SET DUPLICATI=(DUPLICATI+1) WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1765.             pstmt = connectionDB.prepareStatement(query.toString());
  1766.             pstmt.setString(1,id);
  1767.             pstmt.setString(2,tipoBusta);

  1769.             // Add PreparedStatement
  1770.             stateMSG.getPreparedStatement().put("UPDATE aggiornaDuplicati "+tipoBusta+"_"+id,pstmt);

  1772.         } catch(Exception e) {
  1773.             String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento informazioni pacchetti duplicati "+tipoBusta+"/"+id+": "+e.getMessage();
  1774.             try{
  1775.                 if(pstmt != null)
  1776.                     pstmt.close();
  1777.             } catch(Exception er) {
  1778.                 // close
  1779.             }
  1780.             this.log.error(errorMsg,e);
  1781.             throw new ProtocolException(errorMsg,e);
  1782.         }
  1783.     }

  1785.     /**  Aggiorna le informazioni di integrazione della busta.
  1786.      *
  1787.      * @param id identificativo della busta da ritornare.
  1788.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  1789.      * @param infoIntegrazione Informazioni di integrazione
  1790.      *
  1791.      */
  1792.     public void aggiornaInfoIntegrazione(String id,String tipoBusta,Integrazione infoIntegrazione)throws ProtocolException{

  1794.         boolean registrazioneInfoIntegrazione = false;
  1795.         
  1796.         if( this.state instanceof StatefulMessage) {
  1797.             registrazioneInfoIntegrazione = true;
  1798.         }else if(this.isRichiesta && Costanti.OUTBOX.equals(tipoBusta)){
  1799.             StatelessMessage stateless = (StatelessMessage)this.state;
  1800.             Busta busta = stateless.getBusta();
  1801.             if( org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(busta.getProfiloDiCollaborazione()) &&
  1802.                     busta.isConfermaRicezione()){
  1803.                 // Le informazioni di integrazione servono per i riscontri
  1804.                 registrazioneInfoIntegrazione = true;
  1805.             }else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) &&
  1806.                     busta.getRiferimentoMessaggio()==null){
  1807.                 // Le informazioni di integrazione servono per consegnare la risposta
  1808.                 registrazioneInfoIntegrazione = true;
  1809.             }
  1810.         }
  1811.         
  1812.         if( registrazioneInfoIntegrazione ) {

  1814.             StateMessage stateMSG = (StateMessage)this.state;
  1815.             Connection connectionDB = stateMSG.getConnectionDB();

  1817.             PreparedStatement pstmt = null;
  1818.             try{

  1820.                 // Costruzione Query
  1821.                 StringBuilder query = new StringBuilder();
  1822.                 query.append("UPDATE ");
  1823.                 query.append(Costanti.REPOSITORY);
  1824.                 query.append(" SET LOCATION_PD=? , SERVIZIO_APPLICATIVO=? , MODULO_IN_ATTESA=? , SCENARIO=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1825.                 pstmt = connectionDB.prepareStatement(query.toString());
  1826.                 pstmt.setString(1,infoIntegrazione.getNomePorta());
  1827.                 pstmt.setString(2,infoIntegrazione.getServizioApplicativo());
  1828.                 pstmt.setString(3,infoIntegrazione.getIdModuloInAttesa());
  1829.                 pstmt.setString(4,infoIntegrazione.getScenario());
  1830.                 pstmt.setString(5,id);
  1831.                 pstmt.setString(6,tipoBusta);

  1833.                 // Add PreparedStatement
  1834.                 stateMSG.getPreparedStatement().put("UPDATE aggiornaInformazioniIntegrazione "+tipoBusta+"_"+id,pstmt);

  1836.             } catch(Exception e) {
  1837.                 String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento informazioni di Integrazione "+tipoBusta+"/"+id+": "+e.getMessage();
  1838.                 try{
  1839.                     if(pstmt != null)
  1840.                         pstmt.close();
  1841.                 } catch(Exception er) {
  1842.                     // close
  1843.                 }
  1844.                 this.log.error(errorMsg,e);
  1845.                 throw new ProtocolException(errorMsg,e);
  1846.             }
  1847.         }else{
  1848.             //NOP
  1849.         }
  1850.     }

  1852.     /**
  1853.      * Aggiorna il servizio applicativo di integrazione nel repositoryBuste.
  1854.      *
  1855.      * @param id identificativo della busta da ritornare.
  1856.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  1857.      * @param servizioApplicativo Servizio Applicativo
  1858.      *
  1859.      */
  1860.     private void aggiornaInfoIntegrazione_ServizioApplicativo(String id,String tipoBusta,String servizioApplicativo)throws ProtocolException{

  1862.         if(this.state instanceof StatefulMessage) {

  1864.             StatefulMessage stateful = (StatefulMessage)this.state;
  1865.             Connection connectionDB = stateful.getConnectionDB();
  1866.             PreparedStatement pstmt = null;
  1867.             try{

  1869.                 // Costruzione Query
  1870.                 StringBuilder query = new StringBuilder();
  1871.                 query.append("UPDATE ");
  1872.                 query.append(Costanti.REPOSITORY);
  1873.                 query.append(" SET SERVIZIO_APPLICATIVO=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1874.                 pstmt = connectionDB.prepareStatement(query.toString());
  1875.                 pstmt.setString(1,servizioApplicativo);
  1876.                 pstmt.setString(2,id);
  1877.                 pstmt.setString(3,tipoBusta);

  1879.                 // Add PreparedStatement
  1880.                 stateful.getPreparedStatement().put("UPDATE aggiornaInformazioniIntegrazione_ServizioApplicativo_"+tipoBusta+"_"+id,pstmt);

  1882.             } catch(Exception e) {
  1883.                 String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento informazioni di Integrazione "+tipoBusta+"/"+id+" (ServizioApplicativo): "+e.getMessage();
  1884.                 try{
  1885.                     if(pstmt != null)
  1886.                         pstmt.close();
  1887.                 } catch(Exception er) {
  1888.                     // close
  1889.                 }
  1890.                 this.log.error(errorMsg,e);
  1891.                 throw new ProtocolException(errorMsg,e);
  1892.             }
  1893.         }else{

  1895.             // NOP
  1896.         }

  1898.     }

  1900.     /**
  1901.      * Aggiorna lo scenario di integrazione del Msg gestito da OpenSPCoop.
  1902.      *
  1903.      * @param id identificativo della busta da ritornare.
  1904.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  1905.      * @param scenario Scenario di integrazione
  1906.      *
  1907.      */
  1908.     private void aggiornaInfoIntegrazione_Scenario(String id,String tipoBusta,String scenario)throws ProtocolException{

  1910.         if(this.state instanceof StatefulMessage) {

  1912.             StatefulMessage stateful = (StatefulMessage)this.state;
  1913.             Connection connectionDB = stateful.getConnectionDB();
  1914.             PreparedStatement pstmt = null;
  1915.             try{

  1917.                 // Costruzione Query
  1918.                 StringBuilder query = new StringBuilder();
  1919.                 query.append("UPDATE ");
  1920.                 query.append(Costanti.REPOSITORY);
  1921.                 query.append(" SET SCENARIO=? WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  1922.                 pstmt = connectionDB.prepareStatement(query.toString());
  1923.                 pstmt.setString(1,scenario);
  1924.                 pstmt.setString(2,id);
  1925.                 pstmt.setString(3,tipoBusta);

  1927.                 // Add PreparedStatement
  1928.                 stateful.getPreparedStatement().put("UPDATE aggiornaInformazioniIntegrazione_Scenario_"+tipoBusta+"_"+id,pstmt);

  1930.             } catch(Exception e) {
  1931.                 String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento informazioni di Integrazione "+tipoBusta+"/"+id+" (Scenario): "+e.getMessage();
  1932.                 try{
  1933.                     if(pstmt != null)
  1934.                         pstmt.close();
  1935.                 } catch(Exception er) {
  1936.                     // close
  1937.                 }
  1938.                 this.log.error(errorMsg,e);
  1939.                 throw new ProtocolException(errorMsg,e);
  1940.             }
  1941.         }else{
  1942.             // NOP
  1943.         }
  1944.     }

  1946.     /**
  1947.      * Metodo che si occupa di aggiornare la collaborazione di una busta.
  1948.      *
  1949.      * @param id  Identificativo di una busta
  1950.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  1951.      * @param collaborazione ID di Collaborazione di una busta
  1952.      *
  1953.      */
  1954.     private void aggiornaCollaborazione(String id,String tipoBusta,String collaborazione) throws ProtocolException{

  1956.         if(this.state instanceof StatefulMessage) {

  1958.             StatefulMessage stateful = (StatefulMessage)this.state;
  1959.             Connection connectionDB = stateful.getConnectionDB();
  1960.             PreparedStatement pstmtBusta = null;
  1961.             try{
  1962.                 // Registrazione Sequenza
  1963.                 StringBuilder query = new StringBuilder();
  1964.                 query.append("UPDATE  ");
  1965.                 query.append(Costanti.REPOSITORY);
  1966.                 query.append(" SET ");
  1967.                 query.append("COLLABORAZIONE = ?");
  1968.                 query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  1969.                 pstmtBusta = connectionDB.prepareStatement(query.toString());
  1970.                 pstmtBusta.setString(1, collaborazione);
  1971.                 pstmtBusta.setString(2,id);
  1972.                 pstmtBusta.setString(3,tipoBusta);

  1974.                 // Add PreparedStatement
  1975.                 stateful.getPreparedStatement().put("UPDATE AggiornamentoCollaborazione"+tipoBusta+"_"+id,pstmtBusta);

  1977.             } catch(Exception e) {
  1978.                 String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento collaborazione "+tipoBusta+"/"+id+": "+e.getMessage();
  1979.                 this.log.error(errorMsg,e);
  1980.                 try{
  1981.                     if(pstmtBusta != null)
  1982.                         pstmtBusta.close();
  1983.                 } catch(Exception er) {
  1984.                     // Eccezione SQL.
  1985.                 }
  1986.                 throw new ProtocolException(errorMsg,e);
  1987.             }
  1988.         }else{

  1990.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  1991.             statelessMsg.getBusta().setCollaborazione(collaborazione);
  1992.         }

  1994.     }

  1996.     /**
  1997.      * Metodo che si occupa di aggiornare il numero di sequenza di una busta.
  1998.      *
  1999.      * @param id  Identificativo di una busta
  2000.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2001.      * @param sequenza Numero di sequenza di una busta
  2002.      *
  2003.      */
  2004.     private void aggiornaSequenza(String id,String tipoBusta,long sequenza) throws ProtocolException{

  2006.         if(this.state instanceof StatefulMessage) {

  2008.             StatefulMessage stateful = (StatefulMessage)this.state;
  2009.             Connection connectionDB = stateful.getConnectionDB();
  2010.             PreparedStatement pstmtBusta = null;
  2011.             try{
  2012.                 // Registrazione Sequenza
  2013.                 StringBuilder query = new StringBuilder();
  2014.                 query.append("UPDATE  ");
  2015.                 query.append(Costanti.REPOSITORY);
  2016.                 query.append(" SET ");
  2017.                 query.append("SEQUENZA = ?");
  2018.                 query.append(" WHERE ID_MESSAGGIO=? AND TIPO=?");
  2019.                 pstmtBusta = connectionDB.prepareStatement(query.toString());
  2020.                 pstmtBusta.setLong(1, sequenza);
  2021.                 pstmtBusta.setString(2,id);
  2022.                 pstmtBusta.setString(3,tipoBusta);

  2024.                 // Add PreparedStatement
  2025.                 stateful.getPreparedStatement().put("UPDATE AggiornamentoSequenza"+tipoBusta+"_"+id,pstmtBusta);

  2027.             } catch(Exception e) {
  2028.                 String errorMsg = "REPOSITORY_BUSTE, Errore di aggiornamento sequenza "+tipoBusta+"/"+id+": "+e.getMessage();
  2029.                 this.log.error(errorMsg,e);
  2030.                 try{
  2031.                     if(pstmtBusta != null)
  2032.                         pstmtBusta.close();
  2033.                 } catch(Exception er) {
  2034.                     // Eccezione SQL.
  2035.                 }
  2036.                 throw new ProtocolException(errorMsg,e);
  2037.             }

  2039.         }else{

  2041.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2042.             statelessMsg.getBusta().setSequenza(sequenza);
  2043.         }

  2045.     }

  2047.     /**
  2048.      * Ritorna l'informazione se una busta e' gia stata precedentemente registrata.
  2049.      *
  2050.      * @param id identificativo della busta da ritornare.
  2051.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2052.      * @return true se e' presente la busta richiesta.
  2053.      *
  2054.      */
  2055.     public boolean isRegistrata(String id, String tipoBusta) throws ProtocolException {

  2057.         Connection connectionDB = ((StateMessage) this.state).getConnectionDB();

  2059.         PreparedStatement pstmt = null;
  2060.         ResultSet rs = null;
  2061.         try {   // busta

  2063.             StringBuilder query = new StringBuilder();
  2064.             query.append("select ID_MESSAGGIO from ");
  2065.             query.append(Costanti.REPOSITORY);
  2066.             query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  2067.             pstmt = connectionDB.prepareStatement(query.toString());
  2068.             pstmt.setString(1, id);
  2069.             pstmt.setString(2, tipoBusta);

  2071.             // Esecuzione comando SQL
  2072.             rs = pstmt.executeQuery();
  2073.             if (rs == null) {
  2074.                 throw new ProtocolException("RS Null?");
  2075.             }
  2076.             boolean value = rs.next();

  2078.             rs.close();
  2079.             pstmt.close();

  2081.             return value;


  2084.         } catch (Exception e) {
  2085.             String errorMsg = "REPOSITORY_BUSTE, Errore durante isRegistrata " + tipoBusta + "/" + id + ": " + e.getMessage();
  2086.             this.log.error(errorMsg, e);
  2087.             try {
  2088.                 if (rs != null) {
  2089.                     rs.close();
  2090.                 }
  2091.             } catch (Exception er) {
  2092.                 // Eccezione SQL.
  2093.             }
  2094.             try {
  2095.                 if (pstmt != null) {
  2096.                     pstmt.close();
  2097.                 }
  2098.             } catch (Exception er) {
  2099.                 // Eccezione SQL.
  2100.             }
  2101.             throw new ProtocolException(errorMsg, e);
  2102.         }


  2105.     }





  2111.     /**
  2112.      * Metodo che si occupa di ritornare un oggetto {@link org.openspcoop2.protocol.sdk.Busta} contenente
  2113.      * le informazioni di una busta, precedentemente salvata,
  2114.      * prelevandola dalla tabella delle buste. Alla busta, al momento della registrazione,
  2115.      * e' stato associato l'identificativo della busta, quindi attraverso esso sara' possibile trovarlo nella History.
  2116.      *
  2117.      * @param id identificativo della busta da ritornare.
  2118.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2119.      * @return un oggetto {@link org.openspcoop2.protocol.sdk.Busta} se e' presente la busta richiesta.
  2120.      *
  2121.      */
  2122.     private Busta getBusta(String id, String tipoBusta) throws ProtocolException{
  2123.         return getBusta(id, tipoBusta, false);
  2124.     }
  2125.     private Busta getBusta(String id, String tipoBusta, boolean readServizioApplicativoFruitore) throws ProtocolException{

  2127.         if(this.state instanceof StatefulMessage) {

  2129.             StatefulMessage stateful = (StatefulMessage)this.state;
  2130.             Connection connectionDB = stateful.getConnectionDB();

  2132.             PreparedStatement pstmt = null;
  2133.             ResultSet rs = null;
  2134.             try{

  2136.                 // busta

  2138.                 StringBuilder query = new StringBuilder();
  2139.                 query.append("select * from ");
  2140.                 query.append(Costanti.REPOSITORY);
  2141.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");

  2143.                 pstmt = connectionDB.prepareStatement(query.toString());
  2144.                 pstmt.setString(1,id);
  2145.                 pstmt.setString(2,tipoBusta);

  2147.                 // Esecuzione comando SQL
  2148.                 rs = pstmt.executeQuery();
  2149.                 if(rs == null) {
  2150.                     throw new ProtocolException("RS Null?");
  2151.                 }
  2152.                 if (rs.next() == false) {
  2153.                     throw new ProtocolException("Busta non trovata");
  2154.                 }

  2156.                 // Lettura parametri busta
  2157.                 Busta busta = new Busta(rs.getString("PROTOCOLLO"));
  2158.                 if(this.protocolFactory==null){
  2159.                     if(busta.getProtocollo()!=null){
  2160.                         this.protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(busta.getProtocollo());
  2161.                     }
  2162.                     else{
  2163.                         throw new ProtocolException("Protocol unknown");
  2164.                     }
  2165.                 }
  2166.                 busta.setID(rs.getString("ID_MESSAGGIO"));
  2167.                 busta.setTipoMittente(rs.getString("TIPO_MITTENTE"));
  2168.                 busta.setMittente(rs.getString("MITTENTE"));
  2169.                 busta.setIdentificativoPortaMittente(rs.getString("IDPORTA_MITTENTE"));
  2170.                 busta.setIndirizzoMittente(rs.getString("IND_TELEMATICO_MITT"));
  2171.                 //log.info("TipoMitt["+busta.getTipoMittente()+"] Mitt["+ busta.getMittente()+"]");
  2172.                 busta.setTipoDestinatario(rs.getString("TIPO_DESTINATARIO"));
  2173.                 busta.setDestinatario(rs.getString("DESTINATARIO"));
  2174.                 busta.setIdentificativoPortaDestinatario(rs.getString("IDPORTA_DESTINATARIO"));
  2175.                 busta.setIndirizzoDestinatario(rs.getString("IND_TELEMATICO_DEST"));
  2176.                 //log.info("TipoDest["+busta.getTipoDestinatario()+"] DEst["+ busta.getDestinatario()+"]");
  2177.                 busta.setVersioneServizio(rs.getInt("VERSIONE_SERVIZIO"));
  2178.                 busta.setServizio(rs.getString("SERVIZIO"));
  2179.                 busta.setTipoServizio(rs.getString("TIPO_SERVIZIO"));
  2180.                 busta.setAzione(rs.getString("AZIONE"));
  2181.                 //log.info("Servizio["+busta.getServizio()+"] Azione["+ busta.getAzione()+"]");
  2182.                 String profiloCollaborazione = rs.getString("PROFILO_DI_COLLABORAZIONE");
  2183.                 if(profiloCollaborazione!=null){
  2184.                     busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.toProfiloDiCollaborazione(profiloCollaborazione));
  2185.                 }
  2186.                 busta.setServizioCorrelato(rs.getString("SERVIZIO_CORRELATO"));
  2187.                 busta.setTipoServizioCorrelato(rs.getString("TIPO_SERVIZIO_CORRELATO"));
  2188.                 busta.setCollaborazione(rs.getString("COLLABORAZIONE"));
  2189.                 busta.setSequenza(rs.getLong("SEQUENZA"));
  2190.                 //log.info("COLL["+ busta.getCollaborazione()+"] SEQ["+busta.getSequenza()+"]");

  2192.                 if(rs.getInt("INOLTRO_SENZA_DUPLICATI") != 0)
  2193.                     busta.setInoltro(Inoltro.SENZA_DUPLICATI,this.protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));
  2194.                 else
  2195.                     busta.setInoltro(Inoltro.CON_DUPLICATI,this.protocolFactory.createTraduttore().toString(Inoltro.CON_DUPLICATI));
  2196.                 //log.info("INOLTRO["+busta.getInoltro()+"]");
  2197.                 if(rs.getInt("CONFERMA_RICEZIONE") != 0)
  2198.                     busta.setConfermaRicezione(true);
  2199.                 else
  2200.                     busta.setConfermaRicezione(false);
  2201.                 //log.info("ConfermaRicezione["+busta.getConfermaRicezione()+"]");
  2202.                 busta.setOraRegistrazione(rs.getTimestamp("ORA_REGISTRAZIONE"));
  2203.                 TipoOraRegistrazione tipoOraRegistrazione = TipoOraRegistrazione.toTipoOraRegistrazione(rs.getString("TIPO_ORA_REGISTRAZIONE")); 
  2204.                 busta.setTipoOraRegistrazione(tipoOraRegistrazione,this.protocolFactory.createTraduttore().toString(tipoOraRegistrazione));
  2205.                 busta.setRiferimentoMessaggio(rs.getString("RIFERIMENTO_MESSAGGIO"));
  2206.                 busta.setScadenza(rs.getTimestamp("SCADENZA_BUSTA"));
  2207.                 
  2208.                 if(readServizioApplicativoFruitore) {
  2209.                     busta.setServizioApplicativoFruitore(rs.getString("SERVIZIO_APPLICATIVO"));
  2210.                 }

  2212.                 rs.close();
  2213.                 pstmt.close();


  2216.                 // Lista Tramsmissioni
  2217.                 query.delete(0,query.length());
  2218.                 query.append("select * from ");
  2219.                 query.append(Costanti.LISTA_TRASMISSIONI);
  2220.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");

  2222.                 pstmt = connectionDB.prepareStatement(query.toString());
  2223.                 pstmt.setString(1,id);
  2224.                 pstmt.setString(2,tipoBusta);

  2226.                 // Esecuzione comando SQL
  2227.                 rs = pstmt.executeQuery();
  2228.                 if(rs == null) {
  2229.                     throw new ProtocolException("RS Null?");
  2230.                 }


  2233.                 // Lettura parametri busta
  2234.                 while(rs.next()){
  2235.                     Trasmissione trasmissione = new Trasmissione();
  2236.                     trasmissione.setOrigine(rs.getString("ORIGINE"));
  2237.                     trasmissione.setTipoOrigine(rs.getString("TIPO_ORIGINE"));
  2238.                     trasmissione.setDestinazione(rs.getString("DESTINAZIONE"));
  2239.                     trasmissione.setTipoDestinazione(rs.getString("TIPO_DESTINAZIONE"));
  2240.                     trasmissione.setOraRegistrazione(rs.getTimestamp("ORA_REGISTRAZIONE"));
  2241.                     trasmissione.setTempo(TipoOraRegistrazione.toTipoOraRegistrazione(rs.getString("TIPO_ORA_REGISTRAZIONE")));
  2242.                     busta.addTrasmissione(trasmissione);
  2243.                 }

  2245.                 rs.close();
  2246.                 pstmt.close();


  2249.                 //  Lista Riscontri
  2250.                 query.delete(0,query.length());
  2251.                 query.append("select * from ");
  2252.                 query.append(Costanti.LISTA_RISCONTRI);
  2253.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");

  2255.                 pstmt = connectionDB.prepareStatement(query.toString());
  2256.                 pstmt.setString(1,id);
  2257.                 pstmt.setString(2,tipoBusta);

  2259.                 // Esecuzione comando SQL
  2260.                 rs = pstmt.executeQuery();
  2261.                 if(rs == null) {
  2262.                     throw new ProtocolException("RS Null?");
  2263.                 }


  2266.                 // Lettura parametri busta
  2267.                 while(rs.next()){
  2268.                     Riscontro riscontro = new Riscontro();
  2269.                     riscontro.setID(rs.getString("ID_RISCONTRO"));
  2270.                     riscontro.setRicevuta(rs.getString("RICEVUTA"));
  2271.                     riscontro.setOraRegistrazione(rs.getTimestamp("ORA_REGISTRAZIONE"));
  2272.                     riscontro.setTipoOraRegistrazione(TipoOraRegistrazione.toTipoOraRegistrazione(rs.getString("TIPO_ORA_REGISTRAZIONE")));
  2273.                     busta.addRiscontro(riscontro);
  2274.                 }

  2276.                 rs.close();
  2277.                 pstmt.close();


  2280.                 // Lista Eccezioni
  2281.                 query.delete(0,query.length());
  2282.                 query.append("select * from ");
  2283.                 query.append(Costanti.LISTA_ECCEZIONI);
  2284.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ? AND VALIDAZIONE=0");

  2286.                 pstmt = connectionDB.prepareStatement(query.toString());
  2287.                 pstmt.setString(1,id);
  2288.                 pstmt.setString(2,tipoBusta);

  2290.                 // Esecuzione comando SQL
  2291.                 rs = pstmt.executeQuery();
  2292.                 if(rs == null) {
  2293.                     throw new ProtocolException("RS Null?");
  2294.                 }


  2297.                 // Lettura parametri busta
  2298.                 while(rs.next()){
  2299.                     Eccezione eccezione = Eccezione.newEccezione();
  2300.                     eccezione.setContestoCodifica(ContestoCodificaEccezione.toContestoCodificaEccezione(rs.getString("CONTESTO")));
  2301.                     eccezione.setCodiceEccezione(CodiceErroreCooperazione.toCodiceErroreCooperazione((rs.getInt("CODICE"))));
  2302.                     eccezione.setRilevanza(LivelloRilevanza.toLivelloRilevanza(rs.getString("RILEVANZA")));
  2303.                     eccezione.setDescrizione(rs.getString("POSIZIONE"));
  2304.                     busta.addEccezione(eccezione);
  2305.                 }

  2307.                 rs.close();
  2308.                 pstmt.close();

  2310.                 
  2311.                 
  2312.                 // Lista ExtInfo
  2313.                 query.delete(0,query.length());
  2314.                 query.append("select * from ");
  2315.                 query.append(Costanti.LISTA_EXT_INFO);
  2316.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");

  2318.                 pstmt = connectionDB.prepareStatement(query.toString());
  2319.                 pstmt.setString(1,id);
  2320.                 pstmt.setString(2,tipoBusta);

  2322.                 // Esecuzione comando SQL
  2323.                 rs = pstmt.executeQuery();
  2324.                 if(rs == null) {
  2325.                     throw new ProtocolException("RS Null?");
  2326.                 }


  2329.                 // Lettura parametri busta
  2330.                 while(rs.next()){
  2331.                     busta.addProperty(rs.getString("NOME"), rs.getString("VALORE"));
  2332.                 }

  2334.                 rs.close();
  2335.                 pstmt.close();
  2336.                 
  2337.                 
  2338.                 

  2340.                 return busta;


  2343.             } catch(Exception e) {
  2344.                 String errorMsg = "REPOSITORY_BUSTE, Errore durante la getBusta "+tipoBusta+"/"+id+": "+e.getMessage();
  2345.                 this.log.error(errorMsg,e);
  2346.                 try{
  2347.                     if(rs!=null)
  2348.                         rs.close();
  2349.                 } catch(Exception er) {
  2350.                     // Eccezione SQL.
  2351.                 }
  2352.                 try{
  2353.                     if(pstmt != null)
  2354.                         pstmt.close();
  2355.                 } catch(Exception er) {
  2356.                     // Eccezione SQL.
  2357.                 }
  2358.                 throw new ProtocolException(errorMsg,e);
  2359.             }
  2360.         }else{
  2361.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2362.             return statelessMsg.getBusta();
  2363.         }

  2365.     }

  2367.     /**
  2368.      * Metodo che si occupa di ritornare un oggetto contenente errori di validazione
  2369.      * {@link org.openspcoop2.protocol.sdk.Eccezione} avvenuti durante la validazione di una busta.
  2370.      *
  2371.      * @param id identificativo della busta da ritornare.
  2372.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2373.      * @return un oggetto List&lt;{@link org.openspcoop2.protocol.sdk.Eccezione}&gt; se e' presente la busta richiesta.
  2374.      *
  2375.      */
  2376.     private List<Eccezione> getErrors(String id,String tipoBusta) throws ProtocolException{

  2378.         if(this.state instanceof StatefulMessage) {

  2380.             StatefulMessage stateful = (StatefulMessage)this.state;
  2381.             Connection connectionDB = stateful.getConnectionDB();

  2383.             PreparedStatement pstmt = null;
  2384.             ResultSet rs = null;
  2385.             List<Eccezione> errors = new ArrayList<>();
  2386.             try{

  2388.                 // Costruzione Query
  2389.                 StringBuilder query = new StringBuilder();
  2390.                 query.append("select * from ");
  2391.                 query.append(Costanti.LISTA_ECCEZIONI);
  2392.                 query.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ? AND VALIDAZIONE=1");

  2394.                 pstmt = connectionDB.prepareStatement(query.toString());
  2395.                 pstmt.setString(1,id);
  2396.                 pstmt.setString(2,tipoBusta);

  2398.                 // Esecuzione comando SQL
  2399.                 rs = pstmt.executeQuery();
  2400.                 if(rs == null) {
  2401.                     throw new ProtocolException("RS Null?");
  2402.                 }


  2405.                 // Lettura parametri busta
  2406.                 while(rs.next()){
  2407.                     Eccezione eccezione = Eccezione.newEccezione();
  2408.                     eccezione.setContestoCodifica(ContestoCodificaEccezione.toContestoCodificaEccezione(rs.getString("CONTESTO")));
  2409.                     eccezione.setCodiceEccezione(CodiceErroreCooperazione.toCodiceErroreCooperazione(rs.getInt("CODICE")));
  2410.                     eccezione.setRilevanza(LivelloRilevanza.toLivelloRilevanza(rs.getString("RILEVANZA")));
  2411.                     eccezione.setDescrizione(rs.getString("POSIZIONE"));
  2412.                     errors.add(eccezione);
  2413.                 }

  2415.                 rs.close();
  2416.                 pstmt.close();

  2418.                 return errors;


  2421.             } catch(Exception e) {
  2422.                 String errorMsg = "REPOSITORY_BUSTE, Errore durante la getErrors "+tipoBusta+"/"+id+": "+e.getMessage();
  2423.                 this.log.error(errorMsg,e);
  2424.                 try{
  2425.                     if(rs!=null)
  2426.                         rs.close();
  2427.                 } catch(Exception er) {
  2428.                     // Eccezione SQL.
  2429.                 }
  2430.                 try{
  2431.                     if(pstmt != null)
  2432.                         pstmt.close();
  2433.                 } catch(Exception er) {
  2434.                     // Eccezione SQL.
  2435.                 }
  2436.                 throw new ProtocolException(errorMsg,e);
  2437.             }
  2438.         }else{
  2439.             // NOP
  2440.             return null;
  2441.         }

  2443.     }

  2445.     /**
  2446.      * Ritorna alcuni campi associata alla busta.
  2447.      *
  2448.      * @param id identificativo della busta.
  2449.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2450.      * @return alcuni valori della busta
  2451.      *
  2452.      */
  2453.     private Busta getSomeValues(String id,String tipoBusta, LetturaParametriBusta parametri,boolean forzaLetturaSuDatabase, Date dataRegistrazione) throws ProtocolException{

  2455.         if((this.state instanceof StatefulMessage) || (forzaLetturaSuDatabase)) {

  2457.             StateMessage state = (StateMessage)this.state;
  2458.             Connection connectionDB = state.getConnectionDB();

  2460.             PreparedStatement pstmt = null;
  2461.             ResultSet rs = null;
  2462.             String protocollo = null;
  2463.             if(this.protocolFactory!=null){
  2464.                 protocollo = this.protocolFactory.getProtocol();
  2465.             }
  2466.                     
  2467.             Busta busta = new Busta(protocollo);
  2468.             try{
  2469.                 // Costruzione Query
  2470.                 StringBuilder bf = new StringBuilder();
  2471.                 bf.append("SELECT ");
  2472.                 bf.append("PROTOCOLLO");
  2473.                 boolean first = false;
  2474.                 if(parametri.isMittente()){
  2475.                     if(first==false)
  2476.                         bf.append(",");
  2477.                     else
  2478.                         first = false;
  2479.                     bf.append("MITTENTE,TIPO_MITTENTE,IDPORTA_MITTENTE");
  2480.                     first = false;
  2481.                 }
  2482.                 if(parametri.isDestinatario()){
  2483.                     if(first==false)
  2484.                         bf.append(",");
  2485.                     else
  2486.                         first = false;
  2487.                     bf.append("DESTINATARIO,TIPO_DESTINATARIO,IDPORTA_DESTINATARIO");
  2488.                 }
  2489.                 if(parametri.isIndirizziTelematici()){
  2490.                     if(first==false)
  2491.                         bf.append(",");
  2492.                     else
  2493.                         first = false;
  2494.                     bf.append("IND_TELEMATICO_MITT,IND_TELEMATICO_DEST");
  2495.                 }
  2496.                 if(parametri.isServizio()){
  2497.                     if(first==false)
  2498.                         bf.append(",");
  2499.                     else
  2500.                         first = false;
  2501.                     bf.append("SERVIZIO,TIPO_SERVIZIO,VERSIONE_SERVIZIO");
  2502.                 }
  2503.                 if(parametri.isAzione()){
  2504.                     if(first==false)
  2505.                         bf.append(",");
  2506.                     else
  2507.                         first = false;
  2508.                     bf.append("AZIONE");
  2509.                 }
  2510.                 if(parametri.isProfiloDiCollaborazione()){
  2511.                     if(first==false)
  2512.                         bf.append(",");
  2513.                     else
  2514.                         first = false;
  2515.                     bf.append("PROFILO_DI_COLLABORAZIONE");
  2516.                 }
  2517.                 if(parametri.isServizioCorrelato()){
  2518.                     if(first==false)
  2519.                         bf.append(",");
  2520.                     else
  2521.                         first = false;
  2522.                     bf.append("SERVIZIO_CORRELATO,TIPO_SERVIZIO_CORRELATO");
  2523.                 }
  2524.                 if(parametri.isCollaborazione()){
  2525.                     if(first==false)
  2526.                         bf.append(",");
  2527.                     else
  2528.                         first = false;
  2529.                     bf.append("COLLABORAZIONE");
  2530.                 }
  2531.                 if(parametri.isSequenza()){
  2532.                     if(first==false)
  2533.                         bf.append(",");
  2534.                     else
  2535.                         first = false;
  2536.                     bf.append("SEQUENZA");
  2537.                 }
  2538.                 if(parametri.isProfiloTrasmissione()){
  2539.                     if(first==false)
  2540.                         bf.append(",");
  2541.                     else
  2542.                         first = false;
  2543.                     bf.append("INOLTRO_SENZA_DUPLICATI,CONFERMA_RICEZIONE");
  2544.                 }
  2545.                 if(parametri.isOraRegistrazione()){
  2546.                     if(first==false)
  2547.                         bf.append(",");
  2548.                     else
  2549.                         first = false;
  2550.                     bf.append("ORA_REGISTRAZIONE,TIPO_ORA_REGISTRAZIONE");
  2551.                 }
  2552.                 if(parametri.isRiferimentoMessaggio()){
  2553.                     if(first==false)
  2554.                         bf.append(",");
  2555.                     else
  2556.                         first = false;
  2557.                     bf.append("RIFERIMENTO_MESSAGGIO");
  2558.                 }
  2559.                 if(parametri.isScadenza()){
  2560.                     if(first==false)
  2561.                         bf.append(",");
  2562.                     else
  2563.                         first = false;
  2564.                     bf.append("SCADENZA_BUSTA");
  2565.                 }
  2566.                 bf.append(" FROM ");
  2567.                 bf.append(Costanti.REPOSITORY);
  2568.                 bf.append(" WHERE ");
  2569.                 if(dataRegistrazione!=null) {
  2570.                     bf.append("(DATA_REGISTRAZIONE BETWEEN ? AND ?) AND ");
  2571.                 }
  2572.                 bf.append("ID_MESSAGGIO=? AND TIPO=?");

  2574.                 //log.debug("Query: "+query);
  2575.                 pstmt = connectionDB.prepareStatement(bf.toString());
  2576.                 int index = 1;
  2577.                 
  2578.                 Timestamp leftValue = null;
  2579.                 Timestamp rightValue = null;
  2580.                 if(dataRegistrazione!=null) {
  2581.                     leftValue = new Timestamp(dataRegistrazione.getTime() - (1000*60*5));
  2582.                     rightValue = new Timestamp(dataRegistrazione.getTime() + (1000*60*5));
  2583.                     pstmt.setTimestamp(index++,leftValue);
  2584.                     pstmt.setTimestamp(index++,rightValue);
  2585.                 }
  2586.                 
  2587.                 pstmt.setString(index++,id);
  2588.                 pstmt.setString(index++,tipoBusta);
  2589.                 rs = pstmt.executeQuery();
  2590.                 if(rs == null) {
  2591.                     throw new ProtocolException("RS Null?");
  2592.                 }
  2593.                 if(rs.next()){
  2594.                     String protocolloRead = rs.getString("PROTOCOLLO");
  2595.                     if(busta.getProtocollo()==null){
  2596.                         busta.setProtocollo(protocolloRead);
  2597.                     }
  2598.                     if(this.protocolFactory==null){
  2599.                         this.protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocolloRead);
  2600.                     }
  2601.                     if(parametri.isMittente()){
  2602.                         busta.setTipoMittente(rs.getString("TIPO_MITTENTE"));
  2603.                         busta.setMittente(rs.getString("MITTENTE"));
  2604.                         busta.setIdentificativoPortaMittente(rs.getString("IDPORTA_MITTENTE"));
  2605.                     }
  2606.                     if(parametri.isDestinatario()){
  2607.                         busta.setTipoDestinatario(rs.getString("TIPO_DESTINATARIO"));
  2608.                         busta.setDestinatario(rs.getString("DESTINATARIO"));
  2609.                         busta.setIdentificativoPortaDestinatario(rs.getString("IDPORTA_DESTINATARIO"));
  2610.                     }
  2611.                     if(parametri.isIndirizziTelematici()){
  2612.                         busta.setIndirizzoMittente(rs.getString("IND_TELEMATICO_MITT"));
  2613.                         busta.setIndirizzoDestinatario(rs.getString("IND_TELEMATICO_DEST"));
  2614.                     }
  2615.                     if(parametri.isServizio()){
  2616.                         busta.setTipoServizio(rs.getString("TIPO_SERVIZIO"));
  2617.                         busta.setServizio(rs.getString("SERVIZIO"));
  2618.                         busta.setVersioneServizio(rs.getInt("VERSIONE_SERVIZIO"));
  2619.                     }
  2620.                     if(parametri.isAzione()){
  2621.                         busta.setAzione(rs.getString("AZIONE"));
  2622.                     }
  2623.                     if(parametri.isProfiloDiCollaborazione()){
  2624.                         busta.setProfiloDiCollaborazione(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.toProfiloDiCollaborazione(rs.getString("PROFILO_DI_COLLABORAZIONE")));
  2625.                     }
  2626.                     if(parametri.isServizioCorrelato()){
  2627.                         busta.setTipoServizioCorrelato(rs.getString("TIPO_SERVIZIO_CORRELATO"));
  2628.                         busta.setServizioCorrelato(rs.getString("SERVIZIO_CORRELATO"));
  2629.                     }
  2630.                     if(parametri.isCollaborazione()){
  2631.                         busta.setCollaborazione(rs.getString("COLLABORAZIONE"));
  2632.                     }
  2633.                     if(parametri.isSequenza()){
  2634.                         busta.setSequenza(rs.getLong("SEQUENZA"));
  2635.                     }
  2636.                     if(parametri.isProfiloTrasmissione()){
  2637.                         if(rs.getInt("INOLTRO_SENZA_DUPLICATI") != 0)
  2638.                             busta.setInoltro(Inoltro.SENZA_DUPLICATI,this.protocolFactory.createTraduttore().toString(Inoltro.SENZA_DUPLICATI));
  2639.                         else
  2640.                             busta.setInoltro(Inoltro.CON_DUPLICATI,this.protocolFactory.createTraduttore().toString(Inoltro.CON_DUPLICATI));
  2641.                         //log.info("INOLTRO["+busta.getInoltro()+"]");
  2642.                         if(rs.getInt("CONFERMA_RICEZIONE") != 0)
  2643.                             busta.setConfermaRicezione(true);
  2644.                         else
  2645.                             busta.setConfermaRicezione(false);
  2646.                     }
  2647.                     if(parametri.isOraRegistrazione()){
  2648.                         busta.setOraRegistrazione(rs.getTimestamp("ORA_REGISTRAZIONE"));
  2649.                         TipoOraRegistrazione tipoOraRegistrazione = TipoOraRegistrazione.toTipoOraRegistrazione(rs.getString("TIPO_ORA_REGISTRAZIONE")); 
  2650.                         busta.setTipoOraRegistrazione(tipoOraRegistrazione,this.protocolFactory.createTraduttore().toString(tipoOraRegistrazione));
  2651.                     }
  2652.                     if(parametri.isRiferimentoMessaggio()){
  2653.                         busta.setRiferimentoMessaggio(rs.getString("RIFERIMENTO_MESSAGGIO"));
  2654.                     }
  2655.                     if(parametri.isScadenza()){
  2656.                         busta.setScadenza(rs.getTimestamp("SCADENZA_BUSTA"));
  2657.                     }
  2658.                 }else{
  2659.                     throw new ProtocolException("Busta non trovata");
  2660.                 }
  2661.                 rs.close();
  2662.                 pstmt.close();

  2664.                 return busta;

  2666.             } catch(Exception e) {
  2667.                 String errorMsg = "REPOSITORY_BUSTE, Errore  getSomeValues "+tipoBusta+"/"+id+": "+e.getMessage();
  2668.                 try{
  2669.                     if(rs != null)
  2670.                         rs.close();
  2671.                 } catch(Exception er) {
  2672.                     // close
  2673.                 }
  2674.                 try{
  2675.                     if(pstmt != null)
  2676.                         pstmt.close();
  2677.                 } catch(Exception er) {
  2678.                     // close
  2679.                 }
  2680.                 this.log.error(errorMsg,e);
  2681.                 throw new ProtocolException(errorMsg,e);
  2682.             }
  2683.         }else{
  2684.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2685.             Busta busta = statelessMsg.getBusta().newInstance(); // Per evitare che venga modificato l'oggetto richiesta durante il salvataggio.
  2686.             if(parametri.isMittente()==false){
  2687.                 busta.setTipoMittente(null);
  2688.                 busta.setMittente(null);
  2689.             }
  2690.             if(parametri.isDestinatario()==false){
  2691.                 busta.setTipoDestinatario(null);
  2692.                 busta.setDestinatario(null);
  2693.             }
  2694.             if(parametri.isIndirizziTelematici()==false){
  2695.                 busta.setIndirizzoMittente(null);
  2696.                 busta.setIndirizzoDestinatario(null);
  2697.             }
  2698.             if(parametri.isServizio()==false){
  2699.                 busta.setTipoServizio(null);
  2700.                 busta.setServizio(null);
  2701.             }
  2702.             if(parametri.isAzione()==false){
  2703.                 busta.setAzione(null);
  2704.             }
  2705.             if(parametri.isProfiloDiCollaborazione()==false){
  2706.                 busta.setProfiloDiCollaborazione(null);
  2707.             }
  2708.             if(parametri.isServizioCorrelato()==false){
  2709.                 busta.setTipoServizioCorrelato(null);
  2710.                 busta.setServizioCorrelato(null);
  2711.             }
  2712.             if(parametri.isCollaborazione()==false){
  2713.                 busta.setCollaborazione(null);
  2714.             }
  2715.             if(parametri.isSequenza()==false){
  2716.                 busta.setSequenza(-1);
  2717.             }
  2718.             if(parametri.isProfiloTrasmissione()==false){
  2719.                 busta.setInoltro(null,null);
  2720.                 busta.setConfermaRicezione(false);
  2721.             }
  2722.             if(parametri.isOraRegistrazione()==false){
  2723.                 busta.setOraRegistrazione(null);
  2724.                 busta.setTipoOraRegistrazione(null,null);
  2725.             }
  2726.             if(parametri.isRiferimentoMessaggio()==false){
  2727.                 busta.setRiferimentoMessaggio(null);
  2728.             }
  2729.             if(parametri.isScadenza()==false){
  2730.                 busta.setScadenza(null);
  2731.             }
  2732.             for(int i=0;i<busta.sizeListaEccezioni();i++){
  2733.                 busta.removeEccezione(i);
  2734.             }
  2735.             for(int i=0;i<busta.sizeListaTrasmissioni();i++){
  2736.                 busta.removeTrasmissione(i);
  2737.             }
  2738.             for(int i=0;i<busta.sizeListaRiscontri();i++){
  2739.                 busta.removeRiscontro(i);
  2740.             }
  2741.             if(busta.sizeProperties()>0){
  2742.                 String [] pNames = busta.getPropertiesNames();
  2743.                 for(int i=0; i<pNames.length; i++){
  2744.                     busta.removeProperty(pNames[i]);
  2745.                 }
  2746.             }
  2747.             
  2748.             
  2749.             return busta;
  2750.         }
  2751.     }

  2753.     /**
  2754.      * Ritorna la collaborazione associata alla busta.
  2755.      *
  2756.      * @param id identificativo della busta.
  2757.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2758.      * @return Collaborazione associata alla busta
  2759.      *
  2760.      */
  2761.     private String getCollaborazione(String id,String tipoBusta) throws ProtocolException{

  2763.         if(this.state instanceof StatefulMessage) {

  2765.             StatefulMessage stateful = (StatefulMessage)this.state;
  2766.             Connection connectionDB = stateful.getConnectionDB();
  2767.             PreparedStatement pstmt = null;
  2768.             ResultSet rs = null;
  2769.             try{
  2770.                 // Costruzione Query
  2771.                 String query = "SELECT COLLABORAZIONE FROM "+Costanti.REPOSITORY+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  2772.                 //log.debug("Query: "+query);
  2773.                 pstmt = connectionDB.prepareStatement(query);
  2774.                 pstmt.setString(1,id);
  2775.                 pstmt.setString(2,tipoBusta);
  2776.                 rs = pstmt.executeQuery();
  2777.                 if(rs == null) {
  2778.                     throw new ProtocolException("RS Null?");
  2779.                 }
  2780.                 String collaborazione = null;
  2781.                 if(rs.next()){
  2782.                     collaborazione = rs.getString("COLLABORAZIONE");
  2783.                 }
  2784.                 rs.close();
  2785.                 pstmt.close();

  2787.                 return collaborazione;

  2789.             } catch(Exception e) {
  2790.                 String errorMsg = "REPOSITORY_BUSTE, Errore  getCollaborazione "+tipoBusta+"/"+id+": "+e.getMessage();
  2791.                 try{
  2792.                     if(rs != null)
  2793.                         rs.close();
  2794.                 } catch(Exception er) {
  2795.                     // close
  2796.                 }
  2797.                 try{
  2798.                     if(pstmt != null)
  2799.                         pstmt.close();
  2800.                 } catch(Exception er) {
  2801.                     // close
  2802.                 }
  2803.                 this.log.error(errorMsg,e);
  2804.                 throw new ProtocolException(errorMsg,e);
  2805.             }
  2806.         }else{
  2807.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2808.             Busta busta = statelessMsg.getBusta();
  2809.             return busta.getCollaborazione();
  2810.         }
  2811.     }

  2813.     /**
  2814.      * Ritorna la collaborazione associata alla busta.
  2815.      *
  2816.      * @param id identificativo della busta.
  2817.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2818.      * @return Collaborazione associata alla busta
  2819.      *
  2820.      */
  2821.     private org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione getProfiloCollaborazione(String id,String tipoBusta) throws ProtocolException{

  2823.         if(this.state instanceof StatefulMessage) {

  2825.             StatefulMessage stateful = (StatefulMessage)this.state;
  2826.             Connection connectionDB = stateful.getConnectionDB();
  2827.             PreparedStatement pstmt = null;
  2828.             ResultSet rs = null;
  2829.             try{
  2830.                 // Costruzione Query
  2831.                 String query = "SELECT PROFILO_DI_COLLABORAZIONE FROM "+Costanti.REPOSITORY+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  2832.                 //log.debug("Query: "+query);
  2833.                 pstmt = connectionDB.prepareStatement(query);
  2834.                 pstmt.setString(1,id);
  2835.                 pstmt.setString(2,tipoBusta);
  2836.                 rs = pstmt.executeQuery();
  2837.                 if(rs == null) {
  2838.                     throw new ProtocolException("RS Null?");
  2839.                 }
  2840.                 org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione profiloCollaborazione = null;
  2841.                 if(rs.next()){
  2842.                     profiloCollaborazione = org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.toProfiloDiCollaborazione(rs.getString("PROFILO_DI_COLLABORAZIONE"));
  2843.                 }
  2844.                 rs.close();
  2845.                 pstmt.close();

  2847.                 return profiloCollaborazione;

  2849.             } catch(Exception e) {
  2850.                 String errorMsg = "REPOSITORY_BUSTE, Errore  getProfiloCollaborazione "+tipoBusta+"/"+id+": "+e.getMessage();
  2851.                 try{
  2852.                     if(rs != null)
  2853.                         rs.close();
  2854.                 } catch(Exception er) {
  2855.                     // close
  2856.                 }
  2857.                 try{
  2858.                     if(pstmt != null)
  2859.                         pstmt.close();
  2860.                 } catch(Exception er) {
  2861.                     // close
  2862.                 }
  2863.                 this.log.error(errorMsg,e);
  2864.                 throw new ProtocolException(errorMsg,e);
  2865.             }
  2866.         }   else{
  2867.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2868.             Busta busta = statelessMsg.getBusta();
  2869.             return busta.getProfiloDiCollaborazione();
  2870.         }
  2871.     }
  2872.     
  2873.     /**
  2874.      * Ritorna la collaborazione associata alla busta.
  2875.      *
  2876.      * @param id identificativo della busta.
  2877.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2878.      * @return Collaborazione associata alla busta
  2879.      *
  2880.      */
  2881.     private String getProfiloCollaborazioneValue(String id,String tipoBusta) throws ProtocolException{

  2883.         if(this.state instanceof StatefulMessage) {

  2885.             return null; // info non disponibile, poiche' non salvata nel repository

  2887.         }   else{
  2888.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2889.             Busta busta = statelessMsg.getBusta();
  2890.             return busta.getProfiloDiCollaborazioneValue();
  2891.         }
  2892.     }

  2894.     /**
  2895.      * Ritorna la sequenza associata alla busta.
  2896.      *
  2897.      * @param id identificativo della busta.
  2898.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2899.      * @return Sequenza associata alla busta
  2900.      *
  2901.      */
  2902.     private long getSequenza(String id,String tipoBusta) throws ProtocolException{

  2904.         if(this.state instanceof StatefulMessage) {

  2906.             StatefulMessage stateful = (StatefulMessage)this.state;
  2907.             Connection connectionDB = stateful.getConnectionDB();
  2908.             PreparedStatement pstmt = null;
  2909.             ResultSet rs = null;
  2910.             try{
  2911.                 // Costruzione Query
  2912.                 String query = "SELECT SEQUENZA FROM "+Costanti.REPOSITORY+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  2913.                 //log.debug("Query: "+query);
  2914.                 pstmt = connectionDB.prepareStatement(query);
  2915.                 pstmt.setString(1,id);
  2916.                 pstmt.setString(2,tipoBusta);
  2917.                 rs = pstmt.executeQuery();
  2918.                 if(rs == null) {
  2919.                     throw new ProtocolException("RS Null?");
  2920.                 }
  2921.                 long sequenza = -1;
  2922.                 if(rs.next()){
  2923.                     sequenza = rs.getLong("SEQUENZA");
  2924.                 }
  2925.                 rs.close();
  2926.                 pstmt.close();

  2928.                 return sequenza;

  2930.             } catch(Exception e) {
  2931.                 String errorMsg = "REPOSITORY_BUSTE, Errore  getSequenza "+tipoBusta+"/"+id+": "+e.getMessage();
  2932.                 try{
  2933.                     if(rs != null)
  2934.                         rs.close();
  2935.                 } catch(Exception er) {
  2936.                     // close
  2937.                 }
  2938.                 try{
  2939.                     if(pstmt != null)
  2940.                         pstmt.close();
  2941.                 } catch(Exception er) {
  2942.                     // close
  2943.                 }
  2944.                 this.log.error(errorMsg,e);
  2945.                 throw new ProtocolException(errorMsg,e);
  2946.             }
  2947.         }else{

  2949.             StatelessMessage statelessMsg = ((StatelessMessage)this.state);
  2950.             Busta busta = statelessMsg.getBusta();
  2951.             return busta.getSequenza();
  2952.         }
  2953.     }

  2955.     /**
  2956.      * Ritorna le informazioni di integrazione associate alla busta.
  2957.      *
  2958.      * @param id identificativo della busta.
  2959.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  2960.      * @return Informazioni di integrazione associate alla busta
  2961.      *
  2962.      */
  2963.     private Integrazione getInfoIntegrazione(String id,String tipoBusta) throws ProtocolException{

  2965.         StateMessage stateful = (StateMessage)this.state;
  2966.         Connection connectionDB = stateful.getConnectionDB();
  2967.         PreparedStatement pstmt = null;
  2968.         ResultSet rs = null;
  2969.         try{
  2970.             // Costruzione Query
  2971.             String query = "SELECT LOCATION_PD,SERVIZIO_APPLICATIVO,MODULO_IN_ATTESA,SCENARIO FROM "+Costanti.REPOSITORY+" WHERE ID_MESSAGGIO=? AND TIPO=?";
  2972.             //log.debug("Query: "+query);
  2973.             pstmt = connectionDB.prepareStatement(query);
  2974.             pstmt.setString(1,id);
  2975.             pstmt.setString(2,tipoBusta);
  2976.             rs = pstmt.executeQuery();
  2977.             if(rs == null) {
  2978.                 throw new ProtocolException("RS Null?");
  2979.             }
  2980.             Integrazione infoIntegrazione = new Integrazione();
  2981.             if(rs.next()){
  2982.                 infoIntegrazione.setIdModuloInAttesa(rs.getString("MODULO_IN_ATTESA"));
  2983.                 infoIntegrazione.setNomePorta(rs.getString("LOCATION_PD"));
  2984.                 infoIntegrazione.setScenario(rs.getString("SCENARIO"));
  2985.                 infoIntegrazione.setServizioApplicativo(rs.getString("SERVIZIO_APPLICATIVO"));
  2986.             }
  2987.             rs.close();
  2988.             pstmt.close();

  2990.             return infoIntegrazione;

  2992.         } catch(Exception e) {
  2993.             String errorMsg = "REPOSITORY_BUSTE, Errore  getInfoIntegrazione "+tipoBusta+"/"+id+": "+e.getMessage();
  2994.             try{
  2995.                 if(rs != null)
  2996.                     rs.close();
  2997.             } catch(Exception er) {
  2998.                 // close
  2999.             }
  3000.             try{
  3001.                 if(pstmt != null)
  3002.                     pstmt.close();
  3003.             } catch(Exception er) {
  3004.                 // close
  3005.             }
  3006.             this.log.error(errorMsg,e);
  3007.             throw new ProtocolException(errorMsg,e);
  3008.         }
  3009.     }

  3011.     /**
  3012.      * Metodo che si occupa di eliminare l'indicazione di utilizzo della busta dalla PdD
  3013.      *
  3014.      * @param id identificativo della busta.
  3015.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  3016.      *
  3017.      */
  3018.     private void eliminaUtilizzoPdD(String id,String tipoBusta,boolean forzaEliminazioneDB, Date dataRegistrazione) throws ProtocolException{
  3019.         this.eliminaUtilizzoPdD(id, tipoBusta, forzaEliminazioneDB, true, dataRegistrazione);
  3020.     }
  3021.     private void eliminaUtilizzoPdD(String id,String tipoBusta,boolean forzaEliminazioneDB, boolean savePreparedStatement, Date dataRegistrazione) throws ProtocolException{

  3023.         if(this.state instanceof StatefulMessage || forzaEliminazioneDB) {

  3025.             StateMessage stateMSG = (StateMessage)this.state;
  3026.             Connection connectionDB = stateMSG.getConnectionDB();

  3028.             PreparedStatement pstmtUpdate = null;
  3029.             try{

  3031.                 StringBuilder queryUpdate = new StringBuilder();
  3032.                 queryUpdate.append("UPDATE ");
  3033.                 queryUpdate.append(Costanti.REPOSITORY);
  3034.                 queryUpdate.append(" SET ");
  3035.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_PdD(false));
  3036.                 queryUpdate.append(" WHERE ");
  3037.                 if(dataRegistrazione!=null) {
  3038.                     queryUpdate.append("(DATA_REGISTRAZIONE BETWEEN ? AND ?) AND ");
  3039.                 }
  3040.                 queryUpdate.append("ID_MESSAGGIO = ? AND TIPO=?");
  3041.                             
  3042.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  3043.                 int index = 1;
  3044.                 
  3045.                 Timestamp leftValue = null;
  3046.                 Timestamp rightValue = null;
  3047.                 if(dataRegistrazione!=null) {
  3048.                     leftValue = new Timestamp(dataRegistrazione.getTime() - (1000*60*5));
  3049.                     rightValue = new Timestamp(dataRegistrazione.getTime() + (1000*60*5));
  3050.                     pstmtUpdate.setTimestamp(index++,leftValue);
  3051.                     pstmtUpdate.setTimestamp(index++,rightValue);
  3052.                 }
  3053.                 
  3054.                 pstmtUpdate.setString(index++,id);
  3055.                 pstmtUpdate.setString(index++,tipoBusta);

  3057.                 // Add PreparedStatement
  3058.                 if(savePreparedStatement)
  3059.                     stateMSG.getPreparedStatement().put("UPDATE AggiornamentoBusta"+tipoBusta+"_"+id,pstmtUpdate);
  3060.                 else
  3061.                     pstmtUpdate.executeUpdate();

  3063.             } catch(Exception e) {
  3064.                 String errorMsg = "REPOSITORY_BUSTE, Errore di cancellazione utilizzo from PdD "+tipoBusta+"/"+id+": "+e.getMessage();
  3065.                 this.log.error(errorMsg,e);
  3066.                 try{
  3067.                     if(pstmtUpdate != null)
  3068.                         pstmtUpdate.close();
  3069.                 } catch(Exception er) {
  3070.                     // Eccezione SQL.
  3071.                 }
  3072.                 throw new ProtocolException(errorMsg,e);
  3073.             }
  3074.         }

  3076.     }


  3079.     /**
  3080.      * Metodo che si occupa di eliminare l'indicazione di utilizzo della busta dalla PdD
  3081.      *
  3082.      * @param id identificativo della busta.
  3083.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  3084.      *
  3085.      */
  3086.     private void eliminaBustaStateless(String id,String tipoBusta, Date dataRegistrazione) throws ProtocolException{

  3088.         StateMessage stateMSG = (StateMessage)this.state;
  3089.         Connection connectionDB = stateMSG.getConnectionDB();

  3091.         PreparedStatement pstmtUpdate = null;
  3092.         try{

  3094.             StringBuilder queryUpdate = new StringBuilder();
  3095.             queryUpdate.append("UPDATE ");
  3096.             queryUpdate.append(Costanti.REPOSITORY);
  3097.             queryUpdate.append(" SET ");
  3098.             queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_PdD(false));
  3099.             queryUpdate.append(" WHERE ");
  3100.             if(dataRegistrazione!=null) {
  3101.                 queryUpdate.append("(DATA_REGISTRAZIONE BETWEEN ? AND ?) AND ");
  3102.             }
  3103.             queryUpdate.append("ID_MESSAGGIO = ? AND TIPO=?");
  3104.                     
  3105.             pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  3106.             int index = 1;
  3107.             
  3108.             Timestamp leftValue = null;
  3109.             Timestamp rightValue = null;
  3110.             if(dataRegistrazione!=null) {
  3111.                 leftValue = new Timestamp(dataRegistrazione.getTime() - (1000*60*5));
  3112.                 rightValue = new Timestamp(dataRegistrazione.getTime() + (1000*60*5));
  3113.                 pstmtUpdate.setTimestamp(index++,leftValue);
  3114.                 pstmtUpdate.setTimestamp(index++,rightValue);
  3115.             }
  3116.             
  3117.             pstmtUpdate.setString(index++,id);
  3118.             pstmtUpdate.setString(index++,tipoBusta);

  3120.             // Add PreparedStatement
  3121.             stateMSG.getPreparedStatement().put("UPDATE AggiornamentoBusta"+tipoBusta+"_"+id,pstmtUpdate);
  3122.             
  3123.         } catch(Exception e) {
  3124.             String errorMsg = "REPOSITORY_BUSTE, Errore di cancellazione utilizzo from PdD "+tipoBusta+"/"+id+": "+e.getMessage();
  3125.             this.log.error(errorMsg,e);
  3126.             try{
  3127.                 if(pstmtUpdate != null)
  3128.                     pstmtUpdate.close();
  3129.             } catch(Exception er) {
  3130.                 // Eccezione SQL.
  3131.             }
  3132.             throw new ProtocolException(errorMsg,e);
  3133.         }

  3135.     }   
  3136.     
  3137.     
  3138.     /**
  3139.      * Metodo che si occupa di eliminare una busta, precedentemente registrata.
  3140.      * Alla busta, al momento della registrazione e' stato associato
  3141.      * l'identificativo della busta, quindi attraverso esso sara' possibile trovarlo
  3142.      *
  3143.      * @param id identificativo della busta da eliminare.
  3144.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  3145.      *
  3146.      */
  3147.     private void eliminaBusta(String id, String tipoBusta, Date data) throws ProtocolException{

  3149.         StateMessage state = (StateMessage)this.state;
  3150.         Connection connectionDB = state.getConnectionDB();
  3151.         PreparedStatement pstmtDelete = null;
  3152.         try{

  3154.             // Eliminazione dati applicativi

  3156.             // eliminazione di richieste delegata
  3157.             if(Costanti.OUTBOX.equals(tipoBusta)){

  3159.                 // Eliminazione ricezione riscontro
  3160.                 if(this.state instanceof StatefulMessage) {
  3161.                     Riscontri riscontri = new Riscontri(state,this.log);
  3162.                     riscontri.validazioneRiscontroRicevuto(id);
  3163.                     state.executePreparedStatement();
  3164.                 }

  3166.                 // Eliminazione invio asincrono
  3167.                 ProfiloDiCollaborazione profilo = new ProfiloDiCollaborazione(state, this.log, this.protocolFactory);
  3168.                 profilo.asincrono_eliminaRegistrazione(id, Costanti.OUTBOX, data);
  3169.                 state.executePreparedStatement();

  3171.             }
  3172.             // eliminazione di richieste applicativa
  3173.             else if(Costanti.INBOX.equals(tipoBusta)){

  3175.                 //  Eliminazione ricezione asincrono
  3176.                 ProfiloDiCollaborazione profilo = new ProfiloDiCollaborazione(state, this.log, this.protocolFactory);
  3177.                 profilo.asincrono_eliminaRegistrazione(id, Costanti.INBOX, data);
  3178.                 state.executePreparedStatement();
  3179.             }

  3181.             java.sql.Timestamp nowT = null;
  3182.             if(data!=null) {
  3183.                 nowT = new java.sql.Timestamp(data.getTime());
  3184.             }

  3186.             if(this.state instanceof StatefulMessage) {
  3187.             
  3188.                 // elimino lista trasmissioni
  3189.                 StringBuilder queryDelete = new StringBuilder();
  3190.                 queryDelete.append("DELETE FROM ");
  3191.                 queryDelete.append(Costanti.LISTA_TRASMISSIONI);
  3192.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  3193.                 if(data!=null) {
  3194.                     queryDelete.append(" AND DATA_REGISTRAZIONE<=?");
  3195.                 }
  3196.                 pstmtDelete = connectionDB.prepareStatement(queryDelete.toString());
  3197.                 pstmtDelete.setString(1,id);
  3198.                 pstmtDelete.setString(2,tipoBusta);
  3199.                 if(data!=null) {
  3200.                     pstmtDelete.setTimestamp(3,nowT);
  3201.                 }
  3202.                 pstmtDelete.execute();
  3203.                 pstmtDelete.close();
  3204.     
  3205.                 //  elimino lista riscontri
  3206.                 queryDelete.delete(0,queryDelete.length());
  3207.                 queryDelete.append("DELETE FROM ");
  3208.                 queryDelete.append(Costanti.LISTA_RISCONTRI);
  3209.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  3210.                 if(data!=null) {
  3211.                     queryDelete.append(" AND DATA_REGISTRAZIONE<=?");
  3212.                 }
  3213.                 pstmtDelete = connectionDB.prepareStatement(queryDelete.toString());
  3214.                 pstmtDelete.setString(1,id);
  3215.                 pstmtDelete.setString(2,tipoBusta);
  3216.                 if(data!=null) {
  3217.                     pstmtDelete.setTimestamp(3,nowT);
  3218.                 }
  3219.                 pstmtDelete.execute();
  3220.                 pstmtDelete.close();
  3221.     
  3222.                 //  elimino lista eccezioni
  3223.                 queryDelete.delete(0,queryDelete.length());
  3224.                 queryDelete.append("DELETE FROM ");
  3225.                 queryDelete.append(Costanti.LISTA_ECCEZIONI);
  3226.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  3227.                 if(data!=null) {
  3228.                     queryDelete.append(" AND DATA_REGISTRAZIONE<=?");
  3229.                 }
  3230.                 pstmtDelete = connectionDB.prepareStatement(queryDelete.toString());
  3231.                 pstmtDelete.setString(1,id);
  3232.                 pstmtDelete.setString(2,tipoBusta);
  3233.                 if(data!=null) {
  3234.                     pstmtDelete.setTimestamp(3,nowT);
  3235.                 }
  3236.                 pstmtDelete.execute();
  3237.                 pstmtDelete.close();
  3238.                 
  3239.                 // elimino lista ext
  3240.                 queryDelete.delete(0,queryDelete.length());
  3241.                 queryDelete.append("DELETE FROM ");
  3242.                 queryDelete.append(Costanti.LISTA_EXT_INFO);
  3243.                 queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  3244.                 if(data!=null) {
  3245.                     queryDelete.append(" AND DATA_REGISTRAZIONE<=?");
  3246.                 }
  3247.                 pstmtDelete = connectionDB.prepareStatement(queryDelete.toString());
  3248.                 pstmtDelete.setString(1,id);
  3249.                 pstmtDelete.setString(2,tipoBusta);
  3250.                 if(data!=null) {
  3251.                     pstmtDelete.setTimestamp(3,nowT);
  3252.                 }
  3253.                 pstmtDelete.execute();
  3254.                 pstmtDelete.close();
  3255.             }

  3257.             // Elimino busta
  3258.             StringBuilder queryDelete = new StringBuilder();
  3259.             queryDelete.append("DELETE FROM ");
  3260.             queryDelete.append(Costanti.REPOSITORY);
  3261.             queryDelete.append(" WHERE ID_MESSAGGIO = ? AND TIPO = ?");
  3262.             if(data!=null) {
  3263.                 queryDelete.append(" AND DATA_REGISTRAZIONE<=?");
  3264.             }
  3265.             pstmtDelete = connectionDB.prepareStatement(queryDelete.toString());
  3266.             pstmtDelete.setString(1,id);
  3267.             pstmtDelete.setString(2,tipoBusta);
  3268.             if(data!=null) {
  3269.                 pstmtDelete.setTimestamp(3,nowT);
  3270.             }
  3271.             pstmtDelete.execute();
  3272.             pstmtDelete.close();

  3274.         } catch(Exception e) {
  3275.             String errorMsg = "REPOSITORY_BUSTE, Errore di cancellazione from "+Costanti.REPOSITORY+" "+tipoBusta+"/"+id+": "+e.getMessage();
  3276.             this.log.error(errorMsg,e);
  3277.             try{
  3278.                 if( pstmtDelete != null )
  3279.                     pstmtDelete.close();
  3280.             } catch(Exception er) {
  3281.                 // Eccezione SQL.
  3282.             }
  3283.             throw new ProtocolException(errorMsg,e);
  3284.         }
  3285.     }





  3291.     
  3292.     
  3293.     
  3294.     /* ------------- UTILITY PER LETTURA MESSAGGI DA ELIMINARE -------------- */
  3295.     
  3296.     public static Date getDataRegistrazioneBustaMassima(Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws ProtocolException{
  3297.         return _getDataRegistrazioneBusta(false, connectionDB , tipoDatabase, logQuery, logger);
  3298.     }
  3299.     public static Date getDataRegistrazioneBustaMinima(Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws ProtocolException{
  3300.         return _getDataRegistrazioneBusta(true, connectionDB , tipoDatabase, logQuery, logger);
  3301.     }
  3302.     private static Date _getDataRegistrazioneBusta(boolean min, Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws ProtocolException{
  3303.     
  3304.         PreparedStatement pstmt = null;
  3305.         ResultSet rs = null;
  3306.         String queryString = null;
  3307.         try{    
  3308.         
  3309.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  3310.             if(min) {
  3311.                 sqlQueryObject.addSelectMinField(Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE, "check_data");
  3312.             }
  3313.             else {
  3314.                 sqlQueryObject.addSelectMaxField(Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE, "check_data");
  3315.             }
  3316.             sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  3317.             sqlQueryObject.setANDLogicOperator(true);
  3318.             queryString = sqlQueryObject.createSQLQuery();
  3319.             if(logQuery) {
  3320.                 logger.debug("Esecuzione query ["+queryString+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  3321.             }
  3322.             
  3323.             pstmt = connectionDB.prepareStatement(queryString);
  3324.             rs = pstmt.executeQuery();
  3325.             
  3326.             if(logQuery) {
  3327.                 logger.debug("Esecuzione query ["+queryString+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata");
  3328.             }
  3329.             
  3330.             if(rs.next()) {
  3331.                 return rs.getTimestamp("check_data");
  3332.             }
  3333.             return null;
  3334.         
  3335.         } catch(Exception e) {
  3336.             String errorMsg = "[RepositoryBuste.getDataRegistrazioneBusta] errore, queryString["+queryString+"]: "+e.getMessage();
  3337.             throw new ProtocolException(errorMsg,e);
  3338.         }
  3339.         finally {
  3340.             try{
  3341.                 if(rs != null)
  3342.                     rs.close();
  3343.             } catch(Exception er) {
  3344.                 // close
  3345.             }
  3346.             try{
  3347.                 if(pstmt != null)
  3348.                     pstmt.close();
  3349.             } catch(Exception er) {
  3350.                 // close
  3351.             }
  3352.         }
  3353.     }
  3354.     
  3355.     public static Date getDataScadenzaBustaMassima(Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws ProtocolException{
  3356.         return _getDataScadenzaBusta(false, connectionDB , tipoDatabase, logQuery, logger);
  3357.     }
  3358.     public static Date getDataScadenzaBustaMinima(Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws ProtocolException{
  3359.         return _getDataScadenzaBusta(true, connectionDB , tipoDatabase, logQuery, logger);
  3360.     }
  3361.     private static Date _getDataScadenzaBusta(boolean min, Connection connectionDB , String tipoDatabase, boolean logQuery, Logger logger) throws ProtocolException{
  3362.     
  3363.         PreparedStatement pstmt = null;
  3364.         ResultSet rs = null;
  3365.         String queryString = null;
  3366.         try{    
  3367.         
  3368.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  3369.             if(min) {
  3370.                 sqlQueryObject.addSelectMinField(Costanti.REPOSITORY_COLUMN_SCADENZA, "check_data");
  3371.             }
  3372.             else {
  3373.                 sqlQueryObject.addSelectMaxField(Costanti.REPOSITORY_COLUMN_SCADENZA, "check_data");
  3374.             }
  3375.             sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  3376.             sqlQueryObject.setANDLogicOperator(true);
  3377.             queryString = sqlQueryObject.createSQLQuery();
  3378.             if(logQuery) {
  3379.                 logger.debug("Esecuzione query ["+queryString+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  3380.             }
  3381.             
  3382.             pstmt = connectionDB.prepareStatement(queryString);
  3383.             rs = pstmt.executeQuery();
  3384.             
  3385.             if(logQuery) {
  3386.                 logger.debug("Esecuzione query ["+queryString+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata");
  3387.             }
  3388.             
  3389.             if(rs.next()) {
  3390.                 return rs.getTimestamp("check_data");
  3391.             }
  3392.             return null;
  3393.         
  3394.         } catch(Exception e) {
  3395.             String errorMsg = "[RepositoryBuste.getDataScadenzaBusta] errore, queryString["+queryString+"]: "+e.getMessage();
  3396.             throw new ProtocolException(errorMsg,e);
  3397.         }
  3398.         finally {
  3399.             try{
  3400.                 if(rs != null)
  3401.                     rs.close();
  3402.             } catch(Exception er) {
  3403.                 // close
  3404.             }
  3405.             try{
  3406.                 if(pstmt != null)
  3407.                     pstmt.close();
  3408.             } catch(Exception er) {
  3409.                 // close
  3410.             }
  3411.         }
  3412.     }
  3413.     
  3414.     public static int countBusteInutiliIntoInBox(Connection connectionDB , String tipoDatabase, 
  3415.             boolean logQuery, Logger logger,
  3416.             IGestoreRepository repository,
  3417.             Date leftDate, Date rightDate, boolean useDataRegistrazione) throws ProtocolException{
  3418.         return _countBusteIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, false, repository, leftDate, rightDate, useDataRegistrazione);
  3419.     }
  3420.     public static int countBusteInutiliIntoOutBox(Connection connectionDB , String tipoDatabase, 
  3421.             boolean logQuery, Logger logger,
  3422.             IGestoreRepository repository,
  3423.             Date leftDate, Date rightDate, boolean useDataRegistrazione) throws ProtocolException{
  3424.         return _countBusteIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, false, repository, leftDate, rightDate, useDataRegistrazione);
  3425.     }
  3426.     public static int countBusteScaduteIntoInBox(Connection connectionDB , String tipoDatabase, 
  3427.             boolean logQuery, Logger logger,
  3428.             IGestoreRepository repository) throws ProtocolException{
  3429.         return _countBusteIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, true, repository, null, null, false);
  3430.     }
  3431.     public static int countBusteScaduteIntoOutBox(Connection connectionDB , String tipoDatabase, 
  3432.             boolean logQuery, Logger logger,
  3433.             IGestoreRepository repository) throws ProtocolException{
  3434.         return _countBusteIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, true, repository, null, null, false);
  3435.     }
  3436.     private static int _countBusteIntoBox(boolean searchIntoInbox, Connection connectionDB , String tipoDatabase, 
  3437.             boolean logQuery, Logger logger,
  3438.             boolean scadenzaMsg, IGestoreRepository repository,
  3439.             Date leftDate, Date rightDate, boolean useDataRegistrazione) throws ProtocolException{
  3440.         
  3441.         // Le buste da eliminare sono quelle che
  3442.         // -1 sono scadute e non possiedono l'accesso da pdd o l'accesso da profilo
  3443.         // -2 non possiedono piu' accessi da nessuna fonte
  3444.         //      se possiedono ancora l'accesso da pdd, vuole dire che un msg e' in rollback,
  3445.         //        e sara' eliminato l'accesso una volta consegnato con successo il msg,
  3446.         //        o una volta scaduto il msg (rollback)
  3447.         //      se possiedono ancora l'accesso da profilo, vuole dire che un msg e' in rollback,
  3448.         //        e sara' eliminato una volta terminato il profilo,
  3449.         //        o una volta scaduto il msg (rollback)
  3450.         
  3451.         String tipo = null; 
  3452.         if(searchIntoInbox)
  3453.             tipo = Costanti.INBOX;
  3454.         else
  3455.             tipo = Costanti.OUTBOX;
  3456.     
  3457.         PreparedStatement pstmt = null;
  3458.         ResultSet rs = null;
  3459.         String queryString = null;
  3460.         try{    
  3461.         
  3462.             // Query per Ricerca messaggi scaduti
  3463.             java.sql.Timestamp nowT = null;
  3464.             if(scadenzaMsg) {
  3465.                 nowT = DateManager.getTimestamp();
  3466.             }
  3467.             
  3468.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  3469.             sqlQueryObject.addSelectCountField("totale_msg");
  3470.             sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  3471.             
  3472.             if(leftDate!=null) {
  3473.                 sqlQueryObject.addWhereCondition((useDataRegistrazione ? Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE : Costanti.REPOSITORY_COLUMN_SCADENZA)+">=?");
  3474.             }
  3475.             if(rightDate!=null) {
  3476.                 sqlQueryObject.addWhereCondition((useDataRegistrazione ? Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE : Costanti.REPOSITORY_COLUMN_SCADENZA)+"<=?");
  3477.             }
  3478.             if(scadenzaMsg) {
  3479.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY_COLUMN_SCADENZA+" < ?");
  3480.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  3481.                 // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3482.                 //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3483.                 //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3484.                 sqlQueryObject.addWhereCondition(repository.createSQLCondition_enableOnlyHistory());
  3485.             }
  3486.             else {
  3487.                 sqlQueryObject.addWhereCondition(Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  3488.             // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3489.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_History(false));
  3490.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3491.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3492.                 sqlQueryObject.addWhereCondition(repository.createSQLCondition_disabledAll());
  3493.             }
  3494.             sqlQueryObject.setANDLogicOperator(true);
  3495.             queryString = sqlQueryObject.createSQLQuery();

  3497.             pstmt = connectionDB.prepareStatement(queryString);
  3498.             int index = 1;
  3499.             List<Object> objects = new ArrayList<>();
  3500.             if(leftDate!=null) {
  3501.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  3502.                 pstmt.setTimestamp(index++, leftDateT);
  3503.                 if(logQuery) {
  3504.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDateT));
  3505.                 }
  3506.             }
  3507.             if(rightDate!=null) {
  3508.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  3509.                 pstmt.setTimestamp(index++, rightDateT);
  3510.                 if(logQuery) {
  3511.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDateT));
  3512.                 }
  3513.             }
  3514.             if(scadenzaMsg) {
  3515.                 pstmt.setTimestamp(index++,nowT);
  3516.                 if(logQuery) {
  3517.                     objects.add(DateUtils.getSimpleDateFormatMs().format(nowT));
  3518.                 }
  3519.                 pstmt.setString(index++,tipo);
  3520.                 if(logQuery) {
  3521.                     objects.add(tipo);
  3522.                 }
  3523.             }
  3524.             else {
  3525.                 pstmt.setString(index++,tipo);
  3526.                 if(logQuery) {
  3527.                     objects.add(tipo);
  3528.                 }
  3529.             }
  3530.             
  3531.             String query = null;
  3532.             if(logQuery) {
  3533.                 query = DBUtils.formatSQLString(queryString, objects.toArray());
  3534.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  3535.             }
  3536.             rs = pstmt.executeQuery();
  3537.             
  3538.             int res = 0;
  3539.             if(rs.next()) {
  3540.                 res = rs.getInt("totale_msg");
  3541.             }
  3542.             
  3543.             if(logQuery) {
  3544.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; trovati "+res+" risultati");
  3545.             }
  3546.             
  3547.             return res;
  3548.         
  3549.         } catch(Exception e) {
  3550.             String errorMsg = "[RepositoryBuste.countBusteIntoBox] errore, queryString["+queryString+"]: "+e.getMessage();
  3551.             throw new ProtocolException(errorMsg,e);
  3552.         }
  3553.         finally {
  3554.             try{
  3555.                 if(rs != null)
  3556.                     rs.close();
  3557.             } catch(Exception er) {
  3558.                 // close
  3559.             }
  3560.             try{
  3561.                 if(pstmt != null)
  3562.                     pstmt.close();
  3563.             } catch(Exception er) {
  3564.                 // close
  3565.             }
  3566.         }
  3567.     }
  3568.     
  3569.     
  3570.     
  3571.     
  3572.     public static SortedMap<Integer> deleteBusteInutiliIntoInBox(Connection connectionDB , String tipoDatabase, 
  3573.             boolean logQuery, Logger logger,
  3574.             IGestoreRepository repository,
  3575.             Date leftDate, Date rightDate, boolean useDataRegistrazione) throws ProtocolException{
  3576.         return _deleteBusteIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, false, repository, leftDate, rightDate, useDataRegistrazione);
  3577.     }
  3578.     public static SortedMap<Integer> deleteBusteInutiliIntoOutBox(Connection connectionDB , String tipoDatabase, 
  3579.             boolean logQuery, Logger logger,
  3580.             IGestoreRepository repository,
  3581.             Date leftDate, Date rightDate, boolean useDataRegistrazione) throws ProtocolException{
  3582.         return _deleteBusteIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, false, repository, leftDate, rightDate, useDataRegistrazione);
  3583.     }
  3584.     public static SortedMap<Integer> deleteBusteScaduteIntoInBox(Connection connectionDB , String tipoDatabase, 
  3585.             boolean logQuery, Logger logger,
  3586.             IGestoreRepository repository) throws ProtocolException{
  3587.         return _deleteBusteIntoBox(true, connectionDB, tipoDatabase, logQuery, logger, true, repository, null, null, false);
  3588.     }
  3589.     public static SortedMap<Integer> deleteBusteScaduteIntoOutBox(Connection connectionDB , String tipoDatabase, 
  3590.             boolean logQuery, Logger logger,
  3591.             IGestoreRepository repository) throws ProtocolException{
  3592.         return _deleteBusteIntoBox(false, connectionDB, tipoDatabase, logQuery, logger, true, repository, null, null, false);
  3593.     }
  3594.     private static SortedMap<Integer> _deleteBusteIntoBox(boolean searchIntoInbox, Connection connectionDB , String tipoDatabase, 
  3595.             boolean logQuery, Logger logger,
  3596.             boolean scadenzaMsg, IGestoreRepository repository,
  3597.             Date leftDate, Date rightDate, boolean useDataRegistrazione) throws ProtocolException{
  3598.         
  3599.         SortedMap<Integer> mapTabelleRigheEliminate = new SortedMap<Integer>();
  3600.         
  3601.         String tipo = null; 
  3602.         if(searchIntoInbox)
  3603.             tipo = Costanti.INBOX;
  3604.         else
  3605.             tipo = Costanti.OUTBOX;
  3606.         
  3607.         PreparedStatement pstmt = null;
  3608.         String deleteString = null;
  3609.         try{    
  3610.         
  3611.             // Query per Ricerca messaggi scaduti
  3612.             java.sql.Timestamp nowT = null;
  3613.             if(scadenzaMsg) {
  3614.                 nowT = DateManager.getTimestamp();
  3615.             }

  3617.             // Le buste da eliminare sono quelle che
  3618.             // -1 sono scadute e non possiedono l'accesso da pdd o l'accesso da profilo
  3619.             // -2 non possiedono piu' accessi da nessuna fonte
  3620.             //      se possiedono ancora l'accesso da pdd, vuole dire che un msg e' in rollback,
  3621.             //        e sara' eliminato l'accesso una volta consegnato con successo il msg,
  3622.             //        o una volta scaduto il msg (rollback)
  3623.             //      se possiedono ancora l'accesso da profilo, vuole dire che un msg e' in rollback,
  3624.             //        e sara' eliminato una volta terminato il profilo,
  3625.             //        o una volta scaduto il msg (rollback)
  3626.                 
  3627.             // lista 
  3628.             ISQLQueryObject sqlQueryObjectRepositoryBusteJoin = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  3629.             sqlQueryObjectRepositoryBusteJoin.addSelectField(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY_COLUMN_ID_MESSAGGIO);
  3630.             sqlQueryObjectRepositoryBusteJoin.addFromTable(Costanti.REPOSITORY);
  3631.             if(leftDate!=null) {
  3632.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition((useDataRegistrazione ? Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE : Costanti.REPOSITORY_COLUMN_SCADENZA)+">=?");
  3633.             }
  3634.             if(rightDate!=null) {
  3635.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition((useDataRegistrazione ? Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE : Costanti.REPOSITORY_COLUMN_SCADENZA)+"<=?");
  3636.             }
  3637.             if(scadenzaMsg) {
  3638.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(Costanti.REPOSITORY_COLUMN_SCADENZA+" < ?");
  3639.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  3640.                 // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3641.                 //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3642.                 //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3643.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(repository.createSQLCondition_enableOnlyHistory());
  3644.             }
  3645.             else {
  3646.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  3647.             // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3648.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_History(false));
  3649.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3650.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3651.                 sqlQueryObjectRepositoryBusteJoin.addWhereCondition(repository.createSQLCondition_disabledAll());
  3652.             }
  3653.             sqlQueryObjectRepositoryBusteJoin.setANDLogicOperator(true);
  3654.             
  3655.             
  3656.             _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  3657.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_RISCONTRI, 
  3658.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_RISCONTRI_COLUMN_TIPO_MESSAGGIO, 
  3659.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_RISCONTRI_COLUMN_ID_MESSAGGIO,
  3660.                     tipo, nowT, sqlQueryObjectRepositoryBusteJoin,
  3661.                     leftDate, rightDate,
  3662.                     mapTabelleRigheEliminate);
  3663.             
  3664.             _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  3665.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_TRASMISSIONI, 
  3666.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_TRASMISSIONI_COLUMN_TIPO_MESSAGGIO, 
  3667.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_TRASMISSIONI_COLUMN_ID_MESSAGGIO,
  3668.                     tipo, nowT, sqlQueryObjectRepositoryBusteJoin,
  3669.                     leftDate, rightDate,
  3670.                     mapTabelleRigheEliminate);
  3671.             
  3672.             _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  3673.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_ECCEZIONI, 
  3674.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_ECCEZIONI_COLUMN_TIPO_MESSAGGIO, 
  3675.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_ECCEZIONI_COLUMN_ID_MESSAGGIO,
  3676.                     tipo, nowT, sqlQueryObjectRepositoryBusteJoin,
  3677.                     leftDate, rightDate,
  3678.                     mapTabelleRigheEliminate);
  3679.             
  3680.             _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  3681.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_EXT_INFO, 
  3682.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_EXT_INFO_COLUMN_TIPO_MESSAGGIO, 
  3683.                     org.openspcoop2.protocol.engine.constants.Costanti.LISTA_EXT_INFO_COLUMN_ID_MESSAGGIO,
  3684.                     tipo, nowT, sqlQueryObjectRepositoryBusteJoin,
  3685.                     leftDate, rightDate,
  3686.                     mapTabelleRigheEliminate);
  3687.             
  3688.             _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  3689.                     org.openspcoop2.protocol.engine.constants.Costanti.PROFILO_ASINCRONO, 
  3690.                     org.openspcoop2.protocol.engine.constants.Costanti.PROFILO_ASINCRONO_COLUMN_TIPO_MESSAGGIO, 
  3691.                     org.openspcoop2.protocol.engine.constants.Costanti.PROFILO_ASINCRONO_COLUMN_ID_MESSAGGIO,
  3692.                     tipo, nowT, sqlQueryObjectRepositoryBusteJoin,
  3693.                     leftDate, rightDate,
  3694.                     mapTabelleRigheEliminate);
  3695.             
  3696.             if(!searchIntoInbox){
  3697.                 _deleteListaRepositoryBuste(tipoDatabase, connectionDB, logQuery, logger,
  3698.                         org.openspcoop2.protocol.engine.constants.Costanti.RISCONTRI_DA_RICEVERE, 
  3699.                         null, 
  3700.                         org.openspcoop2.protocol.engine.constants.Costanti.RISCONTRI_COLUMN_ID_MESSAGGIO,
  3701.                         tipo, nowT, sqlQueryObjectRepositoryBusteJoin,
  3702.                         leftDate, rightDate,
  3703.                         mapTabelleRigheEliminate);
  3704.             }
  3705.                 
  3706.             
  3707.             // Eliminazione busta reale
  3708.             
  3709.             ISQLQueryObject sqlQueryObjectRepositoryBuste = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  3710.             sqlQueryObjectRepositoryBuste.addDeleteTable(Costanti.REPOSITORY);
  3711.             if(leftDate!=null) {
  3712.                 sqlQueryObjectRepositoryBuste.addWhereCondition((useDataRegistrazione ? Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE : Costanti.REPOSITORY_COLUMN_SCADENZA)+">=?");
  3713.             }
  3714.             if(rightDate!=null) {
  3715.                 sqlQueryObjectRepositoryBuste.addWhereCondition((useDataRegistrazione ? Costanti.REPOSITORY_COLUMN_DATA_REGISTRAZIONE : Costanti.REPOSITORY_COLUMN_SCADENZA)+"<=?");
  3716.             }
  3717.             if(scadenzaMsg) {
  3718.                 sqlQueryObjectRepositoryBuste.addWhereCondition(Costanti.REPOSITORY_COLUMN_SCADENZA+" < ?");
  3719.                 sqlQueryObjectRepositoryBuste.addWhereCondition(Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  3720.                 // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3721.                 //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3722.                 //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3723.                 sqlQueryObjectRepositoryBuste.addWhereCondition(repository.createSQLCondition_enableOnlyHistory());
  3724.             }
  3725.             else {
  3726.                 sqlQueryObjectRepositoryBuste.addWhereCondition(Costanti.REPOSITORY_COLUMN_TIPO_MESSAGGIO+"=?");
  3727.             // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3728.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_History(false));
  3729.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3730.     //          sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3731.                 sqlQueryObjectRepositoryBuste.addWhereCondition(repository.createSQLCondition_disabledAll());
  3732.             }
  3733.             sqlQueryObjectRepositoryBuste.setANDLogicOperator(true);
  3734.             
  3735.             deleteString = sqlQueryObjectRepositoryBuste.createSQLDelete();
  3736.             pstmt = connectionDB.prepareStatement(deleteString);
  3737.             int index = 1;
  3738.             List<Object> objects = new ArrayList<>();
  3739.             if(leftDate!=null) {
  3740.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  3741.                 pstmt.setTimestamp(index++, leftDateT);
  3742.                 if(logQuery) {
  3743.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDateT));
  3744.                 }
  3745.             }
  3746.             if(rightDate!=null) {
  3747.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  3748.                 pstmt.setTimestamp(index++, rightDateT);
  3749.                 if(logQuery) {
  3750.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDateT));
  3751.                 }
  3752.             }
  3753.             if(scadenzaMsg) {
  3754.                 pstmt.setTimestamp(index++,nowT);
  3755.                 if(logQuery) {
  3756.                     objects.add(DateUtils.getSimpleDateFormatMs().format(nowT));
  3757.                 }
  3758.                 pstmt.setString(index++,tipo);
  3759.                 if(logQuery) {
  3760.                     objects.add(tipo);
  3761.                 }
  3762.             }
  3763.             else {
  3764.                 pstmt.setString(index++,tipo);
  3765.                 if(logQuery) {
  3766.                     objects.add(tipo);
  3767.                 }
  3768.             }
  3769.             
  3770.             String query = null;
  3771.             if(logQuery) {
  3772.                 query = DBUtils.formatSQLString(deleteString, objects.toArray());
  3773.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  3774.             }
  3775.             int result = pstmt.executeUpdate();
  3776.             pstmt.close();
  3777.             pstmt = null;
  3778.             
  3779.             if(logQuery) {
  3780.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  3781.             }
  3782.             mapTabelleRigheEliminate.add(org.openspcoop2.protocol.engine.constants.Costanti.REPOSITORY, result);
  3783.             
  3784.             
  3785.             return mapTabelleRigheEliminate;
  3786.         
  3787.         } catch(Exception e) {
  3788.             String errorMsg = "[RepositoryBuste.deleteBusteIntoBox] errore, deleteString["+deleteString+"]: "+e.getMessage();
  3789.             throw new ProtocolException(errorMsg,e);
  3790.         } finally {
  3791.             try{
  3792.                 if(pstmt != null)
  3793.                     pstmt.close();
  3794.             } catch(Exception er) { 
  3795.                 // close
  3796.             }
  3797.         }
  3798.     }
  3799.     
  3800.     
  3801.     private static void _deleteListaRepositoryBuste(String tipoDatabase, Connection connectionDB, boolean logQuery, Logger logger,
  3802.             String nomeTabella, String nomeColonnaTipoMessaggio, String nomeColonnaIdMessaggio,
  3803.             String tipo, Timestamp scandenzaT, ISQLQueryObject sqlQueryObjectRepositoryBusteJoin,
  3804.             Date leftDate, Date rightDate,
  3805.             SortedMap<Integer> mapTabelleRigheEliminate) throws Exception {
  3806.         
  3807.         // Eliminazione busta reale
  3808.         
  3809.         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDatabase);
  3810.         sqlQueryObject.addDeleteTable(nomeTabella);
  3811.         if(nomeColonnaTipoMessaggio!=null) {
  3812.             sqlQueryObject.addWhereCondition(nomeColonnaTipoMessaggio+"=?");
  3813.         }
  3814.         sqlQueryObject.addWhereINSelectSQLCondition(false, nomeColonnaIdMessaggio, sqlQueryObjectRepositoryBusteJoin);
  3815.         sqlQueryObject.setANDLogicOperator(true);
  3816.         
  3817.         String deleteString = sqlQueryObject.createSQLDelete();
  3818.         PreparedStatement pstmt = null;
  3819.         try{    
  3820.             pstmt = connectionDB.prepareStatement(deleteString);
  3821.             int index = 1;
  3822.             List<Object> objects = new ArrayList<>();
  3823.             if(nomeColonnaTipoMessaggio!=null) {
  3824.                 pstmt.setString(index++,tipo);
  3825.                 if(logQuery) {
  3826.                     objects.add(tipo);
  3827.                 }
  3828.             }
  3829.             
  3830.             if(leftDate!=null) {
  3831.                 java.sql.Timestamp leftDateT = new java.sql.Timestamp(leftDate.getTime());
  3832.                 pstmt.setTimestamp(index++, leftDateT);
  3833.                 if(logQuery) {
  3834.                     objects.add(DateUtils.getSimpleDateFormatMs().format(leftDateT));
  3835.                 }
  3836.             }
  3837.             if(rightDate!=null) {
  3838.                 java.sql.Timestamp rightDateT = new java.sql.Timestamp(rightDate.getTime());
  3839.                 pstmt.setTimestamp(index++, rightDateT);
  3840.                 if(logQuery) {
  3841.                     objects.add(DateUtils.getSimpleDateFormatMs().format(rightDateT));
  3842.                 }
  3843.             }
  3844.             if(scandenzaT!=null) {
  3845.                 pstmt.setTimestamp(index++,scandenzaT);
  3846.                 if(logQuery) {
  3847.                     objects.add(DateUtils.getSimpleDateFormatMs().format(scandenzaT));
  3848.                 }
  3849.                 pstmt.setString(index++,tipo);
  3850.                 if(logQuery) {
  3851.                     objects.add(tipo);
  3852.                 }
  3853.             }
  3854.             else {
  3855.                 pstmt.setString(index++,tipo);
  3856.                 if(logQuery) {
  3857.                     objects.add(tipo);
  3858.                 }
  3859.             }
  3860.             
  3861.             String query = null;
  3862.             if(logQuery) {
  3863.                 query = DBUtils.formatSQLString(deleteString, objects.toArray());
  3864.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") ...");
  3865.             }
  3866.             int result = pstmt.executeUpdate();
  3867.             pstmt.close();
  3868.             pstmt = null;
  3869.             
  3870.             if(logQuery) {
  3871.                 logger.debug("Esecuzione query ["+query+"] ("+DateUtils.getSimpleDateFormatMs().format(DateManager.getDate())+") completata; "+result+" righe eliminate");
  3872.             }
  3873.             mapTabelleRigheEliminate.add(nomeTabella, result);
  3874.         } finally {
  3875.             try{
  3876.                 if(pstmt != null)
  3877.                     pstmt.close();
  3878.             } catch(Exception er) { 
  3879.                 // close
  3880.             }
  3881.         }
  3882.     }
  3883.     
  3884.     








  3893.     /**
  3894.      * Ritorna le buste salvate scadute o inutilizzate (tutti gli accessi uguale a 0) nella INBOX
  3895.      *
  3896.      * @return List di stringhe contenenti gli ID delle buste scadute e/o inutilizzate con il tipo passato come parametro.
  3897.      *
  3898.      */
  3899.     public List<String> getBusteDaEliminareFromInBox(int limit,boolean logQuery,boolean forceIndex,boolean filtraBustaScadetureRispettoOraRegistrazione,boolean orderBy, Date data) throws ProtocolException{
  3900.         return this.getBusteDaEliminare(Costanti.INBOX,limit,logQuery,forceIndex,filtraBustaScadetureRispettoOraRegistrazione,orderBy, data);
  3901.     }

  3903.     /**
  3904.      * Ritorna le buste salvate scadute o inutilizzate (tutti gli accessi uguale a 0) nella OUTBOX
  3905.      *
  3906.      * @return List di stringhe contenenti gli ID delle buste scadute e/o inutilizzate con il tipo passato come parametro.
  3907.      *
  3908.      */
  3909.     public List<String> getBusteDaEliminareFromOutBox(int limit,boolean logQuery,boolean forceIndex,boolean filtraBustaScadetureRispettoOraRegistrazione,boolean orderBy, Date data) throws ProtocolException{
  3910.         return this.getBusteDaEliminare(Costanti.OUTBOX,limit,logQuery,forceIndex,filtraBustaScadetureRispettoOraRegistrazione,orderBy, data);
  3911.     }


  3914.     /**
  3915.      * Ritorna le buste salvate scadute o inutilizzate (tutti gli accessi uguale a 0)
  3916.      *
  3917.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  3918.      * @return List di stringhe contenenti gli ID delle buste scadute e/o inutilizzate con il tipo passato come parametro.
  3919.      *
  3920.      */
  3921.     private List<String> getBusteDaEliminare(String tipoBusta,int limit,boolean logQuery,boolean forceIndex,boolean filtraBustaScadetureRispettoOraRegistrazione,boolean orderBy, Date data) throws ProtocolException{

  3923.         if(this.state instanceof StatefulMessage) {

  3925.             StatefulMessage stateful = (StatefulMessage)this.state;
  3926.             Connection connectionDB = stateful.getConnectionDB();

  3928.             java.sql.Timestamp nowT = null;
  3929.             if(data!=null) {
  3930.                 nowT = new java.sql.Timestamp(data.getTime());
  3931.             }
  3932.             
  3933.             PreparedStatement pstmt = null;
  3934.             ResultSet rs = null;
  3935.             List<String> idBuste = new ArrayList<>();
  3936.             IGestoreRepository gestorerepositoryBuste = Configurazione.getGestoreRepositoryBuste();
  3937.             String queryString = null;
  3938.             try{

  3940.                 // Le buste da eliminare sono quelle che
  3941.                 // -1 sono scadute e non possiedono l'accesso da pdd o l'accesso da profilo
  3942.                 // -2 non possiedono piu' accessi da nessuna fonte
  3943.                 //      se possiedono ancora l'accesso da pdd, vuole dire che un msg e' in rollback,
  3944.                 //        e sara' eliminato l'accesso una volta consegnato con successo il msg,
  3945.                 //        o una volta scaduto il msg (rollback)
  3946.                 //      se possiedono ancora l'accesso da profilo, vuole dire che un msg e' in rollback,
  3947.                 //        e sara' eliminato una volta terminato il profilo,
  3948.                 //        o una volta scaduto il msg (rollback)

  3950.                 
  3951.                 // 1 sono scadute e non possiedono l'accesso da pdd o l'accesso da profilo 
  3952.                 // Viene effettuato tale filtro SOLO se il filtro delle buste scadute rispetto all'ora di registrazione è attivo. 
  3953.                 // Se invece tale opzione viene disabilitata, le informazioni per effettuare il filtro duplicati 
  3954.                 // vengono mantenute all'infinito.
  3955.                 // Sara' necessaria una manutenzione sistemistica del database per prevenire una crescita
  3956.                 // del database che comporta un esaurimento di risorse
  3957.                 if(filtraBustaScadetureRispettoOraRegistrazione){
  3958.                     if(Configurazione.getSqlQueryObjectType()==null){
  3959.                         StringBuilder query = new StringBuilder();
  3960.                         query.append("SELECT ");
  3961.                         if(forceIndex){
  3962.                             query.append("/*+ index("+Costanti.REPOSITORY+" "+Costanti.REPOSITORY_INDEX_SCADENZA_SEARCH+") */");
  3963.                         }
  3964.                         query.append(" ID_MESSAGGIO FROM ");
  3965.                         query.append(Costanti.REPOSITORY);
  3966.                         query.append(" WHERE SCADENZA_BUSTA < ? AND TIPO=? AND ");
  3967.                         // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3968.                         //query.append(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3969.                         //query.append(" AND ");
  3970.                         //query.append(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3971.                         query.append(gestorerepositoryBuste.createSQLCondition_enableOnlyHistory());
  3972.                         if(data!=null) {
  3973.                             query.append(" AND DATA_REGISTRAZIONE<=?");
  3974.                         }
  3975.                         queryString = query.toString();
  3976.                     }else{
  3977.                         ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  3978.                         if(forceIndex){
  3979.                             sqlQueryObject.addSelectForceIndex(Costanti.REPOSITORY, Costanti.REPOSITORY_INDEX_SCADENZA_SEARCH);
  3980.                         }
  3981.                         sqlQueryObject.addSelectField("ID_MESSAGGIO");
  3982.                         sqlQueryObject.addSelectField("ORA_REGISTRAZIONE");
  3983.                         sqlQueryObject.addSelectField("SCADENZA_BUSTA");
  3984.                         sqlQueryObject.addSelectField("TIPO");
  3985.                         sqlQueryObject.addSelectField(gestorerepositoryBuste.createSQLFields());
  3986.                         sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  3987.                         sqlQueryObject.addWhereCondition("SCADENZA_BUSTA < ?");
  3988.                         sqlQueryObject.addWhereCondition("TIPO=?");
  3989.                         // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  3990.                         //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  3991.                         //sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  3992.                         sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_enableOnlyHistory());
  3993.                         if(data!=null) {
  3994.                             sqlQueryObject.addWhereCondition("DATA_REGISTRAZIONE<=?");
  3995.                         }
  3996.                         sqlQueryObject.setANDLogicOperator(true);
  3997.                         if(orderBy){
  3998.                             //sqlQueryObject.addOrderBy("ORA_REGISTRAZIONE");
  3999.                             sqlQueryObject.addOrderBy("SCADENZA_BUSTA"); // almeno si usa l'indice
  4000.                             sqlQueryObject.setSortType(true);
  4001.                         }
  4002.                         sqlQueryObject.setLimit(limit);
  4003.                         queryString = sqlQueryObject.createSQLQuery();
  4004.                     }
  4005.     
  4006.                     Timestamp now = DateManager.getTimestamp();
  4007.                     //System.out.println("STRING QUERY REPOSITORY1 ["+queryString+"] 1["+now+"] 2["+tipoBusta+"]");
  4008.                     pstmt = connectionDB.prepareStatement(queryString);
  4009.                     pstmt.setTimestamp(1,now);
  4010.                     pstmt.setString(2,tipoBusta);
  4011.                     if(data!=null) {
  4012.                         pstmt.setTimestamp(3,nowT);
  4013.                     }
  4014.     
  4015.                     long startDateSQLCommand = DateManager.getTimeMillis();
  4016.                     if(logQuery)
  4017.                         this.log.debug("[QUERY] (repositoryBuste.busteScadute) ["+queryString+"] 1["+now+"] 2["+tipoBusta+"] 3["+nowT+"]...");
  4018.                     rs = pstmt.executeQuery();
  4019.                     long endDateSQLCommand = DateManager.getTimeMillis();
  4020.                     long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  4021.                     if(logQuery)
  4022.                         this.log.debug("[QUERY] (repositoryBuste.busteScadute) ["+queryString+"] 1["+now+"] 2["+tipoBusta+"] 3["+nowT+"] effettuata in "+secondSQLCommand+" secondi");
  4023.     
  4024.                     int countLimit = 0;
  4025.                     while(rs.next()){
  4026.                         idBuste.add(rs.getString("ID_MESSAGGIO"));
  4027.                         // LIMIT Applicativo
  4028.                         if(Configurazione.getSqlQueryObjectType()==null){
  4029.                             countLimit++;
  4030.                             if(countLimit==limit)
  4031.                                 break;
  4032.                         }
  4033.                     }
  4034.                     rs.close();
  4035.                     pstmt.close();
  4036.                 }

  4038.                 queryString = null;
  4039.                 if(Configurazione.getSqlQueryObjectType()==null){
  4040.                     StringBuilder query = new StringBuilder();
  4041.                     query.append("SELECT ");
  4042.                     if(forceIndex){
  4043.                         query.append("/*+ index("+Costanti.REPOSITORY+" "+Costanti.REPOSITORY_INDEX_TIPO_SEARCH+") */");
  4044.                     }
  4045.                     query.append(" ID_MESSAGGIO FROM ");
  4046.                     query.append(Costanti.REPOSITORY);
  4047.                     query.append(" WHERE TIPO=? AND ");
  4048.                     // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  4049. //                  query.append(gestorerepositoryBuste.createSQLCondition_History(false));
  4050. //                  query.append(" AND ");
  4051. //                  query.append(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  4052. //                  query.append(" AND ");
  4053. //                  query.append(gestorerepositoryBuste.createSQLCondition_PdD(false));
  4054.                     query.append(gestorerepositoryBuste.createSQLCondition_disabledAll());
  4055.                     if(data!=null) {
  4056.                         query.append(" AND DATA_REGISTRAZIONE<=?");
  4057.                     }
  4058.                     queryString = query.toString();
  4059.                 }else{
  4060.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  4061.                     if(forceIndex){
  4062.                         sqlQueryObject.addSelectForceIndex(Costanti.REPOSITORY, Costanti.REPOSITORY_INDEX_TIPO_SEARCH);
  4063.                     }
  4064.                     sqlQueryObject.addSelectField("ID_MESSAGGIO");
  4065.                     sqlQueryObject.addSelectField("ORA_REGISTRAZIONE");
  4066.                     sqlQueryObject.addSelectField("TIPO");
  4067.                     sqlQueryObject.addSelectField(gestorerepositoryBuste.createSQLFields());
  4068.                     sqlQueryObject.addFromTable(Costanti.REPOSITORY);
  4069.                     sqlQueryObject.addWhereCondition("TIPO=?");
  4070.                     // Inefficiente. Si usa il nuovo metodo dell'interfaccia
  4071. //                  sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_History(false));
  4072. //                  sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_ProfiloCollaborazione(false));
  4073. //                  sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_PdD(false));
  4074.                     sqlQueryObject.addWhereCondition(gestorerepositoryBuste.createSQLCondition_disabledAll());
  4075.                     if(data!=null) {
  4076.                         sqlQueryObject.addWhereCondition("DATA_REGISTRAZIONE<=?");
  4077.                     }
  4078.                     sqlQueryObject.setANDLogicOperator(true);
  4079.                     if(orderBy){
  4080.                         //sqlQueryObject.addOrderBy("ORA_REGISTRAZIONE");
  4081.                         sqlQueryObject.addOrderBy("SCADENZA_BUSTA"); // almeno si usa l'indice
  4082.                         sqlQueryObject.setSortType(true);
  4083.                     }
  4084.                     sqlQueryObject.setLimit(limit);
  4085.                     queryString = sqlQueryObject.createSQLQuery();
  4086.                 }
  4087.                 //System.out.println("STRING QUERY REPOSITORY2 ["+queryString+"] 1["+tipoBusta+"]");
  4088.                 pstmt = connectionDB.prepareStatement(queryString.toString());
  4089.                 pstmt.setString(1,tipoBusta);
  4090.                 if(data!=null) {
  4091.                     pstmt.setTimestamp(2,nowT);
  4092.                 }

  4094.                 long startDateSQLCommand = DateManager.getTimeMillis();
  4095.                 if(logQuery)
  4096.                     this.log.debug("[QUERY] (repositoryBuste.busteCancellateLogicamente) ["+queryString+"] 1["+tipoBusta+"] 2["+nowT+"]...");
  4097.                 rs = pstmt.executeQuery();
  4098.                 long endDateSQLCommand = DateManager.getTimeMillis();
  4099.                 long secondSQLCommand = (endDateSQLCommand - startDateSQLCommand) / 1000;
  4100.                 if(logQuery)
  4101.                     this.log.debug("[QUERY] (repositoryBuste.busteCancellateLogicamente) ["+queryString+"] 1["+tipoBusta+"] 2["+nowT+"] effettuata in "+secondSQLCommand+" secondi");

  4103.                 int countLimit = 0;
  4104.                 while(rs.next()){
  4105.                     idBuste.add(rs.getString("ID_MESSAGGIO"));
  4106.                     // LIMIT Applicativo
  4107.                     if(Configurazione.getSqlQueryObjectType()==null){
  4108.                         countLimit++;
  4109.                         if(countLimit==limit)
  4110.                             break;
  4111.                     }
  4112.                 }
  4113.                 rs.close();
  4114.                 pstmt.close();

  4116.                 return idBuste;

  4118.             } catch(Exception e) {
  4119.                 String errorMsg = "[repositoryBuste.getBusteDaEliminare] errore, queryString["+queryString+"]: "+e.getMessage();
  4120.                 this.log.error(errorMsg,e);
  4121.                 try{
  4122.                     if(rs != null)
  4123.                         rs.close();
  4124.                 } catch(Exception er) {
  4125.                     // Eccezione SQL.
  4126.                 }
  4127.                 try{
  4128.                     if(pstmt != null)
  4129.                         pstmt.close();
  4130.                 } catch(Exception er) {
  4131.                     // Eccezione SQL.
  4132.                 }
  4133.                 throw new ProtocolException(errorMsg,e);
  4134.             }
  4135.         }else{
  4136.             throw new ProtocolException("Metodo non invocabile in stateless mode");
  4137.         }
  4138.     }

  4140.     
  4141.     
  4142.     /**
  4143.      * Metodo che si occupa di impostare l'indicazione di utilizzo della busta dalla PdD
  4144.      *
  4145.      * @param id identificativo della busta.
  4146.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  4147.      *
  4148.      */
  4149.     public void impostaUtilizzoPdD(String id,String tipoBusta) throws ProtocolException{

  4151.         StateMessage stateMSG = (StateMessage)this.state;
  4152.         Connection connectionDB = stateMSG.getConnectionDB();

  4154.         PreparedStatement pstmtUpdate = null;
  4155.         try{

  4157.             StringBuilder queryUpdate = new StringBuilder();
  4158.             queryUpdate.append("UPDATE ");
  4159.             queryUpdate.append(Costanti.REPOSITORY);
  4160.             queryUpdate.append(" SET ");
  4161.             queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_PdD(true));
  4162.             queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  4163.             pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  4164.             pstmtUpdate.setString(1,id);
  4165.             pstmtUpdate.setString(2,tipoBusta);

  4167.             // Add PreparedStatement
  4168.             stateMSG.getPreparedStatement().put("UPDATE AggiornamentoBusta_setUtilizzoPdD"+tipoBusta+"_"+id,pstmtUpdate);

  4170.         } catch(Exception e) {
  4171.             String errorMsg = "REPOSITORY_BUSTE, Errore di impostazione utilizzo from PdD "+tipoBusta+"/"+id+": "+e.getMessage();
  4172.             this.log.error(errorMsg,e);
  4173.             try{
  4174.                 if(pstmtUpdate != null)
  4175.                     pstmtUpdate.close();
  4176.             } catch(Exception er) {
  4177.                 // Eccezione SQL.
  4178.             }
  4179.             throw new ProtocolException(errorMsg,e);
  4180.         }

  4182.     }

  4184.     
  4185.     
  4186.     public boolean exists(String id,String tipoBusta) throws ProtocolException{

  4188.         StateMessage stateMSG = (StateMessage)this.state;
  4189.         Connection connectionDB = stateMSG.getConnectionDB();

  4191.         PreparedStatement pstmt = null;
  4192.         ResultSet rs = null;
  4193.         try{

  4195.             StringBuilder queryUpdate = new StringBuilder();
  4196.             queryUpdate.append("SELECT ID_MESSAGGIO FROM ");
  4197.             queryUpdate.append(Costanti.REPOSITORY);
  4198.             queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=? AND (");
  4199.             queryUpdate.append(this.gestoreRepositoryBuste.createSQLCondition_History(true));
  4200.             queryUpdate.append(" OR ");
  4201.             queryUpdate.append(this.gestoreRepositoryBuste.createSQLCondition_PdD(true));
  4202.             queryUpdate.append(" OR ");
  4203.             queryUpdate.append(this.gestoreRepositoryBuste.createSQLCondition_ProfiloCollaborazione(true));
  4204.             queryUpdate.append(" ) ");
  4205.             pstmt = connectionDB.prepareStatement(queryUpdate.toString());
  4206.             pstmt.setString(1,id);
  4207.             pstmt.setString(2,tipoBusta);
  4208.             rs = pstmt.executeQuery();
  4209.             if(rs==null){
  4210.                 throw new Exception("Result set is null??");
  4211.             }
  4212.             boolean value = rs.next();
  4213.             rs.close();
  4214.             pstmt.close();
  4215.             return value;

  4217.         } catch(Exception e) {
  4218.             String errorMsg = "REPOSITORY_BUSTE, Errore durante l'utilizzo di exists "+tipoBusta+"/"+id+": "+e.getMessage();
  4219.             this.log.error(errorMsg,e);
  4220.             try{
  4221.                 if(rs != null)
  4222.                     rs.close();
  4223.             } catch(Exception er) {
  4224.                 // Eccezione SQL.
  4225.             }
  4226.             try{
  4227.                 if(pstmt != null)
  4228.                     pstmt.close();
  4229.             } catch(Exception er) {
  4230.                 // Eccezione SQL.
  4231.             }
  4232.             throw new ProtocolException(errorMsg,e);
  4233.         }

  4235.     }
  4236.     
  4237.     public boolean isRegistrazioneInCorso() {
  4238.         if(this.state!=null) {
  4239.             StateMessage stateMSG = (StateMessage)this.state;
  4240.             if(stateMSG.getPreparedStatement()!=null && stateMSG.getPreparedStatement().size()>0) {
  4241.                 List<String> keys = stateMSG.getPreparedStatement().keys();
  4242.                 if(keys!=null && !keys.isEmpty()) {
  4243.                     for (String key : keys) {
  4244.                         if(key!=null && key.startsWith("INSERT")) {
  4245.                             return true;
  4246.                         }
  4247.                         else if(key!=null && key.startsWith("UPDATE")) {
  4248.                             return true;
  4249.                         }
  4250.                     }
  4251.                 }
  4252.             }
  4253.         }
  4254.         return false;
  4255.     }
  4256. }

Created with JaCoCo 0.8.8.202204050719