ConsegnaInOrdine.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;

  30. import org.slf4j.Logger;
  31. import org.openspcoop2.protocol.engine.Configurazione;
  32. import org.openspcoop2.protocol.engine.constants.Costanti;
  33. import org.openspcoop2.protocol.sdk.Busta;
  34. import org.openspcoop2.protocol.sdk.Eccezione;
  35. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  36. import org.openspcoop2.protocol.sdk.ProtocolException;
  37. import org.openspcoop2.protocol.sdk.constants.ErroriCooperazione;
  38. import org.openspcoop2.protocol.sdk.state.IState;
  39. import org.openspcoop2.protocol.sdk.state.StateMessage;
  40. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  41. import org.openspcoop2.utils.LoggerWrapperFactory;
  42. import org.openspcoop2.utils.Utilities;
  43. import org.openspcoop2.utils.date.DateManager;
  44. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  45. import org.openspcoop2.utils.sql.ISQLQueryObject;
  46. import org.openspcoop2.utils.sql.SQLObjectFactory;

  48. /**
  49.  * Sono inclusi i metodi per la gestione della consegna in ordine (sequenza).
  50.  *
  51.  *
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author Tronci Fabio (tronci@link.it)
  54.  * @author $Author$
  55.  * @version $Rev$, $Date$
  56.  */

  58. public class ConsegnaInOrdine  {



  62.     /** Logger utilizzato per debug. */
  63.     private Logger log = null;

  65.     /** Se IState e' un'istanza di StatefulMessage possiede una Connessione SQL in autoCommit mode su cui effettuare query 
  66.      *  Altrimenti, e' un'istanza di StatelessMessage e nn necessita di connessioni */
  67.     private IState state;
  68.     
  69.     private IProtocolFactory<?> protocolFactory;

  71.     

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

  75.     /**
  76.      * Costruttore. 
  77.      *
  78.      * @param state Oggetto che rappresenta lo stato di una busta
  79.      * 
  80.      */
  81.     public ConsegnaInOrdine(IState state,IProtocolFactory<?> protocolFactory){
  82.         this(state,Configurazione.getLibraryLog(),protocolFactory);
  83.     }
  84.     /**
  85.      * Costruttore. 
  86.      *
  87.      * @param state Oggetto che rappresenta lo stato di una busta
  88.      * 
  89.      */
  90.     public ConsegnaInOrdine(IState state, Logger alog,IProtocolFactory<?> protocolFactory){
  91.         this.state = state;
  92.         if(alog!=null){
  93.             this.log = alog;
  94.         }else{
  95.             this.log = LoggerWrapperFactory.getLogger(ConsegnaInOrdine.class.getName());
  96.         }
  97.         this.protocolFactory = protocolFactory;
  98.     }
  99.     
  100.     /**
  101.      * Aggiorna lo stato della Busta
  102.      * Utilizzato per reimpostare la connessione ??
  103.      * 
  104.      */
  105.     public void updateState(IState state){
  106.         this.state = state;
  107.     }

  109.     private static final String NOT_USED = ""; // azione null


  112.     /**
  113.      * Ritorna l'identificativo di una collaborazione identificata da mittente/destinatario/servizio/azione.
  114.      * In caso la collaborazione non esiste, viene creata.
  115.      *  
  116.      * @param busta Busta su cui impostare la sequenza
  117.      * 
  118.      */
  119.     public void setNextSequenza_daInviare(Busta busta)throws ProtocolException{

  121.         if(this.state instanceof StateMessage) {
  122.             
  123.             StateMessage stateful = (StateMessage)this.state;
  124.             Connection connectionDB = stateful.getConnectionDB();

  126.             PreparedStatement pstmt = null;
  127.             ResultSet rs = null;
  128.             PreparedStatement pstmtInsert = null;
  129.             String idCollaborazione = null;
  130.             long sequenza = -1;
  131.             try{    

  133.                 StringBuilder query = new StringBuilder();
  134.                 query.append("SELECT ID_COLLABORAZIONE,PROSSIMA_SEQUENZA FROM ");
  135.                 query.append(Costanti.SEQUENZA_DA_INVIARE);
  136.                 query.append(" WHERE MITTENTE=? AND TIPO_MITTENTE=? AND DESTINATARIO=? AND TIPO_DESTINATARIO=? AND SERVIZIO=? AND TIPO_SERVIZIO=? AND AZIONE=?");
  137.                 pstmt = connectionDB.prepareStatement(query.toString());
  138.                 pstmt.setString(1,busta.getMittente());
  139.                 pstmt.setString(2,busta.getTipoMittente());
  140.                 pstmt.setString(3,busta.getDestinatario());
  141.                 pstmt.setString(4,busta.getTipoDestinatario());
  142.                 pstmt.setString(5,busta.getServizio());
  143.                 pstmt.setString(6,busta.getTipoServizio());
  144.                 if(busta.getAzione()!=null)
  145.                     pstmt.setString(7,busta.getAzione());
  146.                 else
  147.                     pstmt.setString(7,NOT_USED);

  149.                 // Esecuzione comando SQL
  150.                 rs = pstmt.executeQuery();      
  151.                 if(rs == null) {
  152.                     pstmt.close();
  153.                     throw new ProtocolException("RS NULL?");
  154.                 }       
  155.                 if(rs.next()){
  156.                     // Collaborazione preesistente
  157.                     idCollaborazione = rs.getString("ID_COLLABORAZIONE");
  158.                     sequenza=rs.getLong("PROSSIMA_SEQUENZA");

  160.                     // devo aggiornare il next sequence

  162.                     long next_sequenza = sequenza + 1;
  163.                     if(next_sequenza > Costanti.MAX_VALUE_SEQUENZA_COUNTER){
  164.                         next_sequenza = 1;
  165.                     } 

  167.                     rs.close();
  168.                     pstmt.close();

  170.                     // aggiornamento sequenza
  171.                     StringBuilder queryInsert = new StringBuilder();
  172.                     queryInsert.append("UPDATE ");
  173.                     queryInsert.append(Costanti.SEQUENZA_DA_INVIARE);
  174.                     queryInsert.append(" SET PROSSIMA_SEQUENZA = ? WHERE MITTENTE=? AND TIPO_MITTENTE=? AND DESTINATARIO=? AND TIPO_DESTINATARIO=? AND SERVIZIO=? AND TIPO_SERVIZIO=? AND AZIONE=?");
  175.                     pstmtInsert = connectionDB.prepareStatement(queryInsert.toString());
  176.                     int index = 1;
  177.                     pstmtInsert.setLong(index++,next_sequenza);
  178.                     pstmtInsert.setString(index++,busta.getMittente());
  179.                     pstmtInsert.setString(index++,busta.getTipoMittente());
  180.                     pstmtInsert.setString(index++,busta.getDestinatario());
  181.                     pstmtInsert.setString(index++,busta.getTipoDestinatario());
  182.                     pstmtInsert.setString(index++,busta.getServizio());
  183.                     pstmtInsert.setString(index++,busta.getTipoServizio());
  184.                     if(busta.getAzione()!=null){
  185.                         pstmtInsert.setString(index++,busta.getAzione());
  186.                     }else{
  187.                         pstmtInsert.setString(index++,NOT_USED);
  188.                     }

  190.                     stateful.getPreparedStatement().put("UPDATE setNextSequenza_daInviare"+busta.getCollaborazione(), pstmtInsert);


  193.                 }else{

  195.                     // Nuova collaborazione
  196.                     idCollaborazione = busta.getID();
  197.                     sequenza=1;

  199.                     rs.close();
  200.                     pstmt.close();              

  202.                     StringBuilder queryInsert = new StringBuilder();
  203.                     queryInsert.append("INSERT INTO  ");
  204.                     queryInsert.append(Costanti.SEQUENZA_DA_INVIARE);
  205.                     queryInsert.append(" VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )");
  206.                     pstmtInsert = connectionDB.prepareStatement(queryInsert.toString());
  207.                     int index = 1;
  208.                     pstmtInsert.setString(index++,busta.getMittente());
  209.                     pstmtInsert.setString(index++,busta.getTipoMittente());
  210.                     pstmtInsert.setString(index++,busta.getDestinatario());
  211.                     pstmtInsert.setString(index++,busta.getTipoDestinatario());
  212.                     pstmtInsert.setString(index++,busta.getServizio());
  213.                     pstmtInsert.setString(index++,busta.getTipoServizio());
  214.                     if(busta.getAzione()!=null){
  215.                         pstmtInsert.setString(index++,busta.getAzione());
  216.                     }else{
  217.                         pstmtInsert.setString(index++,NOT_USED);
  218.                     }
  219.                     pstmtInsert.setLong(index++,2); // next sequence is 2
  220.                     pstmtInsert.setString(index++,busta.getID()); // idCollaborazione is idRequest
  221.                     pstmtInsert.setTimestamp(index++, DateManager.getTimestamp());

  223.                     stateful.getPreparedStatement().put("INSERT setNextSequenza_daInviare"+busta.getCollaborazione(), pstmtInsert);


  226.                 }

  228.                 // impostazione busta
  229.                 busta.setSequenza(sequenza);
  230.                 busta.setCollaborazione(idCollaborazione);


  233.             } catch(Exception e) {
  234.                 String errorMsg = "ConsegnaInOrdine, Errore durante la setNextSequenza_daInviare: "+e.getMessage();     
  235.                 try{
  236.                     if( rs != null )
  237.                         rs.close();
  238.                 } catch(Exception er) {
  239.                     // close
  240.                 }
  241.                 try{
  242.                     if( pstmt != null )
  243.                         pstmt.close();
  244.                 } catch(Exception er) {
  245.                     // close
  246.                 }
  247.                 try{
  248.                     if( pstmtInsert != null )
  249.                         pstmtInsert.close();
  250.                 } catch(Exception er) {
  251.                     // close
  252.                 }
  253.                 this.log.error(errorMsg,e);
  254.                 throw new ProtocolException(errorMsg,e);
  255.             }

  257.         }else{
  258.             throw new ProtocolException("Metodo invocato con IState non valido");
  259.         }
  260.     }










  271.     /**
  272.      * Ritorna true se la busta contiene una sequenza/collaborazione valida
  273.      *  
  274.      * @param busta Busta su cui effettuare la validazione
  275.      * @return una eccezione se la busta contiene una sequenza/collaborazione non valida
  276.      * 
  277.      */
  278.     public Eccezione validazioneDatiConsegnaInOrdine(Busta busta, IProtocolFactory<?> protocolFactory)throws ProtocolException{
  279.         if(this.state instanceof StateMessage) {
  280.             
  281.             StateMessage stateful = (StateMessage)this.state;
  282.             Connection connectionDB = stateful.getConnectionDB();
  283.             
  284.             // Check stateless
  285.             boolean connessioneValida = false;
  286.             try{
  287.                 if(stateful instanceof StatefulMessage)
  288.                     connessioneValida = true;
  289.                 else
  290.                     connessioneValida = ( (connectionDB!=null) && (!connectionDB.isClosed()) );
  291.             }catch(Exception e){
  292.                 // ignore
  293.             }
  294.                     
  295.             if(connessioneValida && busta.getSequenza()!=-1 && busta.getCollaborazione()!=null){

  297.                 PreparedStatement pstmt = null;
  298.                 ResultSet rs = null;
  299.                 try{    

  301.                     if(busta.getID().equals(busta.getCollaborazione())){
  302.                         // busta Capostipite
  303.                         if(busta.getSequenza()!=1){
  304.                             this.log.debug("Riscontrato numero di sequenza diverso da 1, in una busta capostipite di una sequenza");
  305.                             return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_FUORI_SEQUENZA.getErroreCooperazione(), protocolFactory); 
  306.                         }
  307.                     }
  308.                     else{
  309.                         // busta non capostipite
  310.                         StringBuilder query = new StringBuilder();
  311.                         query.append("SELECT * FROM ");
  312.                         query.append(Costanti.SEQUENZA_DA_RICEVERE);
  313.                         query.append(" WHERE ID_COLLABORAZIONE=?");
  314.                         pstmt = connectionDB.prepareStatement(query.toString());
  315.                         pstmt.setString(1,busta.getCollaborazione());

  317.                         //  Esecuzione comando SQL
  318.                         rs = pstmt.executeQuery();      
  319.                         if(rs == null) {
  320.                             throw new ProtocolException("RS NULL?");
  321.                         }   
  322.                         if(rs.next()){
  323.                             String tipoMittente = rs.getString("TIPO_MITTENTE");
  324.                             String mittente = rs.getString("MITTENTE");
  325.                             String tipoDestinatario = rs.getString("TIPO_DESTINATARIO");
  326.                             String destinatario = rs.getString("DESTINATARIO");
  327.                             String tipoServizio = rs.getString("TIPO_SERVIZIO");
  328.                             String servizio = rs.getString("SERVIZIO");
  329.                             String azione = rs.getString("AZIONE");

  331.                             //  Check di coerenza
  332.                             if( tipoMittente.equals(busta.getTipoMittente())==false){
  333.                                 this.log.debug("Il tipo di mittente non rispetta quello atteso nella gestione della collaborazione con consegna in ordine.");
  334.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_TIPO_MITTENTE_NON_VALIDO.getErroreCooperazione(), protocolFactory);
  335.                             }
  336.                             if( mittente.equals(busta.getMittente())==false){
  337.                                 this.log.debug("Il mittente non rispetta quello atteso nella gestione della collaborazione con consegna in ordine.");
  338.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_MITTENTE_NON_VALIDO.getErroreCooperazione(), protocolFactory);
  339.                             }
  340.                             if( tipoDestinatario.equals(busta.getTipoDestinatario())==false){
  341.                                 this.log.debug("Il tipo di destinatario non rispetta quello atteso nella gestione della collaborazione con consegna in ordine.");
  342.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_TIPO_DESTINATARIO_NON_VALIDO.getErroreCooperazione(), protocolFactory);
  343.                             }
  344.                             if( destinatario.equals(busta.getDestinatario())==false){
  345.                                 this.log.debug("Il destinatario non rispetta quello atteso nella gestione della collaborazione con consegna in ordine.");
  346.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_DESTINATARIO_NON_VALIDO.getErroreCooperazione(),protocolFactory);
  347.                             }
  348.                             if( tipoServizio.equals(busta.getTipoServizio())==false){
  349.                                 this.log.debug("Il tipo di servizio non rispetta quello atteso nella gestione della collaborazione con consegna in ordine.");
  350.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_TIPO_SERVIZIO_NON_VALIDO.getErroreCooperazione(), protocolFactory);
  351.                             }
  352.                             if( servizio.equals(busta.getServizio())==false){
  353.                                 this.log.debug("Il servizio non rispetta quello atteso nella gestione della collaborazione con consegna in ordine.");
  354.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_SERVIZIO_NON_VALIDO.getErroreCooperazione(), protocolFactory);
  355.                             }
  356.                             if( (azione==null && busta.getAzione()!=null) ||
  357.                                     (azione!=null && azione.equals(busta.getAzione())==false) ){
  358.                                 this.log.debug("L'azione non rispetta quello attesa nella gestione della collaborazione con consegna in ordine.");
  359.                                 return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_AZIONE_NON_VALIDA.getErroreCooperazione(), protocolFactory);
  360.                             }
  361.                         }else{
  362.                             this.log.debug("Busta non capostipite che richiede funzionalità di consegna in ordine presenta una collaborazione non registrata per le funzioni di consegna in ordine");
  363.                             return Eccezione.getEccezioneValidazione(ErroriCooperazione.CONSEGNA_IN_ORDINE_COLLABORAZIONE_IN_BUSTA_NON_CAPOSTIPITE_SCONOSCIUTA.getErroreCooperazione(), protocolFactory);
  364.                         }

  366.                     }

  368.                 } catch(Exception e) {
  369.                     this.log.error("ERROR validazioneDatiConsegnaInOrdine ["+e.getMessage()+"]",e);
  370.                     throw new ProtocolException("ERROR validazioneDatiConsegnaInOrdine ["+e.getMessage()+"]",e);
  371.                 }
  372.                 finally {
  373.                     try{
  374.                         if( rs != null )
  375.                             rs.close();
  376.                     } catch(Exception er) {
  377.                         // close
  378.                     }
  379.                     try{
  380.                         if( pstmt != null )
  381.                             pstmt.close();
  382.                     } catch(Exception er) {
  383.                         // close
  384.                     }
  385.                 }

  387.             }

  389.             return null;
  390.         }else{
  391.             throw new ProtocolException("Metodo invocato con IState non valido");
  392.         }
  393.     }
  394.     
  395.     
  396.     
  397.     
  398.     /**
  399.      * Ritorna true se la consegna deve essere effettuata, false altrimenti
  400.      *  
  401.      * @param busta Busta su cui gestire la sequenza
  402.      * @return true se la consegna deve essere effettuata, false altrimenti
  403.      * 
  404.      */
  405.     public boolean isConsegnaInOrdine(Busta busta)throws ProtocolException{
  406.         return isConsegnaInOrdine(busta, 60l, 100);
  407.     }
  408.     /**
  409.      * Ritorna true se la consegna deve essere effettuata, false altrimenti
  410.      *  
  411.      * @param busta Busta su cui gestire la sequenza
  412.      * @param attesaAttiva AttesaAttiva per la gestione del livello di serializable
  413.      * @param checkInterval Intervallo di check per la gestione  del livello di serializable
  414.      * @return true se la consegna deve essere effettuata, false altrimenti
  415.      * 
  416.      */
  417.     private long sequenzaAttesa = -1;
  418.     public long getSequenzaAttesa() {
  419.         return this.sequenzaAttesa;
  420.     }
  421.     public boolean isConsegnaInOrdine(Busta busta, long attesaAttiva, int checkInterval) throws ProtocolException{

  423.         if(this.state instanceof StateMessage) {
  424.             
  425.             StateMessage stateMsg = (StateMessage)this.state;
  426.             Connection connectionDB = stateMsg.getConnectionDB();

  428.             //controllo che non abbia gia' gestito un numero di sequenza per la busta
  429.             RepositoryBuste repository = new RepositoryBuste(stateMsg, this.log, true, this.protocolFactory);
  430.             long sequenzaGestita = repository.getSequenzaFromInBox(busta.getID());
  431.             if(sequenzaGestita == -2){
  432.                 return true; // posso consegnare, sicuramente l'ho gia' consegnata prima.
  433.             }


  436.             /*
  437.         Viene realizzato con livello di isolamento SERIALIZABLE, per essere sicuri
  438.         di creare sequenza crescenti.
  439.              */
  440.             // setAutoCommit e livello Isolamento
  441.             int oldTransactionIsolation = -1;
  442.             try{
  443.                 oldTransactionIsolation = connectionDB.getTransactionIsolation();
  444.                 connectionDB.setAutoCommit(false);
  445.                 JDBCUtilities.setTransactionIsolationSerializable(Configurazione.getSqlQueryObjectType(), connectionDB);
  446.             } catch(Exception er) {
  447.                 String errorMsg = "ConsegnaInOrdine, errore durante isConsegnaInOrdine(setIsolation): "+er.getMessage();        
  448.                 this.log.error(errorMsg,er);
  449.                 throw new ProtocolException(errorMsg,er);
  450.             }


  453.             boolean nextSequenceOK = false;
  454.             boolean bustaInOrdine = false;

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

  458.             while(nextSequenceOK==false && DateManager.getTimeMillis() < scadenzaWhile){

  460.                 PreparedStatement pstmt = null;
  461.                 ResultSet rs = null;
  462.                 try{    

  464.                     if(busta.getID().equals(busta.getCollaborazione())){
  465.                         // busta Capostipite

  467.                         bustaInOrdine = true;

  469.                     }else{
  470.                         // busta da controllare

  472.                         StringBuilder query = new StringBuilder();
  473.                         if(Configurazione.getSqlQueryObjectType()!=null){
  474.                             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(Configurazione.getSqlQueryObjectType());
  475.                             sqlQueryObject.addSelectField("SEQUENZA_ATTESA");
  476.                             sqlQueryObject.addFromTable(Costanti.SEQUENZA_DA_RICEVERE);
  477.                             sqlQueryObject.addWhereCondition("ID_COLLABORAZIONE=?");
  478.                             sqlQueryObject.setANDLogicOperator(true);
  479.                             sqlQueryObject.setSelectForUpdate(true);
  480.                             query.append(sqlQueryObject.createSQLQuery());
  481.                         }
  482.                         else{
  483.                             query.append("SELECT SEQUENZA_ATTESA FROM ");
  484.                             query.append(Costanti.SEQUENZA_DA_RICEVERE);
  485.                             query.append(" WHERE ID_COLLABORAZIONE=? FOR UPDATE");
  486.                         }
  487.                         pstmt =  connectionDB.prepareStatement(query.toString());
  488.                         pstmt.setString(1,busta.getCollaborazione());

  490.                         //  Esecuzione comando SQL
  491.                         rs = pstmt.executeQuery();      
  492.                         if(rs == null) {
  493.                             pstmt.close();
  494.                             throw new ProtocolException("RS NULL?");
  495.                         }   
  496.                         if(rs.next()==false){
  497.                             throw new Exception("Informazioni su consegna in ordine non trovate, durante il check di una busta non capostipite");
  498.                         }

  500.                         this.sequenzaAttesa = rs.getLong("SEQUENZA_ATTESA");
  501.                         rs.close();
  502.                         pstmt.close();

  504.                         // se non e' la sequenza attesa, vado in congelamento
  505.                         if(this.sequenzaAttesa!=busta.getSequenza()){
  506.                             bustaInOrdine = false;
  507.                         }else{
  508.                             bustaInOrdine = true;
  509.                         }
  510.                     }

  512.                     // Chiusura Transazione
  513.                     connectionDB.commit();

  515.                     // ID Costruito
  516.                     nextSequenceOK = true;

  518.                 } catch(Exception e) {
  519.                     this.log.error("ERROR isConsegnaInOrdine ["+e.getMessage()+"]");
  520.                     try{
  521.                         if( rs != null )
  522.                             rs.close();
  523.                     } catch(Exception er) {
  524.                         // close
  525.                     }
  526.                     try{
  527.                         if( pstmt != null )
  528.                             pstmt.close();
  529.                     } catch(Exception er) {
  530.                         // close
  531.                     }
  532.                     try{
  533.                         connectionDB.rollback();
  534.                     } catch(Exception er) {
  535.                         // ignore
  536.                     }
  537.                 }

  539.                 if(nextSequenceOK == false){
  540.                     // Per aiutare ad evitare conflitti
  541.                     try{
  542.                         Utilities.sleep(ProtocolRandomUtilities.getRandom().nextInt(checkInterval)); // random da 0ms a checkIntervalms
  543.                     }catch(Exception eRandom){
  544.                         // ignore
  545.                     }
  546.                 }
  547.             }

  549.             // Ripristino Transazione
  550.             try{
  551.                 connectionDB.setTransactionIsolation(oldTransactionIsolation);
  552.                 connectionDB.setAutoCommit(true);
  553.             } catch(Exception er) {
  554.                 String errorMsg = "ConsegnaInOrdine, Errore durante la isConsegnaInOrdine(ripristinoIsolation): "+er.getMessage();      
  555.                 this.log.error(errorMsg,er);
  556.                 throw new ProtocolException(errorMsg,er);
  557.             }


  560.             if(nextSequenceOK==false){
  561.                 throw new ProtocolException("Controllo sequenza per gestione funzionalita' di consegna in ordine non riuscita");
  562.             }

  564.             return bustaInOrdine;
  565.         }else{
  566.             throw new ProtocolException("Metodo invocato con IState non valido");
  567.         }
  568.     }
  569.     
  570.     
  571.     
  572.     





  578.     /**
  579.      * Aggiorna la sequenza
  580.      * 
  581.      * @param busta Busta su cui gestire la sequenza
  582.      * 
  583.      */
  584.     public void setNextSequenza_daRicevere(Busta busta)throws ProtocolException{
  585.         if(this.state instanceof StateMessage) {
  586.             
  587.             StateMessage stateful = (StateMessage)this.state;
  588.             Connection connectionDB = stateful.getConnectionDB();
  589.             // controllo che non abbia gia' gestito il numero di sequenza per la busta
  590.             RepositoryBuste repository = new RepositoryBuste(stateful, this.log, true, this.protocolFactory);
  591.             long sequenzaGestita = repository.getSequenzaFromInBox(busta.getID());
  592.             if(sequenzaGestita == -2){
  593.                 return; // gia gestita
  594.             }

  596.             PreparedStatement pstmtInsert = null;
  597.             try{    

  599.                 if(busta.getID().equals(busta.getCollaborazione())){
  600.                     // busta Capostipite

  602.                     StringBuilder queryInsert = new StringBuilder();
  603.                     queryInsert.append("INSERT INTO  ");
  604.                     queryInsert.append(Costanti.SEQUENZA_DA_RICEVERE);
  605.                     queryInsert.append(" VALUES ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )");
  606.                     pstmtInsert =  connectionDB.prepareStatement(queryInsert.toString());
  607.                     int index = 1;
  608.                     pstmtInsert.setString(index++,busta.getCollaborazione());
  609.                     pstmtInsert.setLong(index++,(busta.getSequenza()+1)); //prossima sequenza attesa
  610.                     pstmtInsert.setString(index++,busta.getMittente());
  611.                     pstmtInsert.setString(index++,busta.getTipoMittente());
  612.                     pstmtInsert.setString(index++,busta.getDestinatario());
  613.                     pstmtInsert.setString(index++,busta.getTipoDestinatario());
  614.                     pstmtInsert.setString(index++,busta.getServizio());
  615.                     pstmtInsert.setString(index++,busta.getTipoServizio());
  616.                     pstmtInsert.setString(index++,busta.getAzione());
  617.                     pstmtInsert.setTimestamp(index++, DateManager.getTimestamp());

  619.                 }else{
  620.                     // aggiorno prossima sequenza attesa
  621.                     StringBuilder queryInsert = new StringBuilder();
  622.                     queryInsert.append("UPDATE ");
  623.                     queryInsert.append(Costanti.SEQUENZA_DA_RICEVERE);
  624.                     queryInsert.append(" SET SEQUENZA_ATTESA = ? WHERE ID_COLLABORAZIONE=? ");
  625.                     pstmtInsert =  connectionDB.prepareStatement(queryInsert.toString());

  627.                     long next_sequenza = busta.getSequenza() + 1;
  628.                     if(next_sequenza > Costanti.MAX_VALUE_SEQUENZA_COUNTER){
  629.                         next_sequenza = 1;
  630.                     } 
  631.                     pstmtInsert.setLong(1,next_sequenza);
  632.                     pstmtInsert.setString(2,busta.getCollaborazione());
  633.                 }
  634.                 stateful.getPreparedStatement().put("INSERT setNextSequenza_daRicevere"+busta.getCollaborazione(), pstmtInsert);

  636.                 // imposto gestione della sequenza per la busta effettuata
  637.                 repository.aggiornaSequenzaIntoInBox(busta.getID(),-2);

  639.             } catch(Exception e) {
  640.                 String errorMsg = "ConsegnaInOrdine, Errore durante la setNextSequenza_daRicevere: "+e.getMessage();        
  641.                 try{
  642.                     if( pstmtInsert != null )
  643.                         pstmtInsert.close();
  644.                 } catch(Exception er) {
  645.                     // close
  646.                 }
  647.                 this.log.error(errorMsg,e);
  648.                 throw new ProtocolException(errorMsg,e);
  649.             }


  652.         }else{
  653.             throw new ProtocolException("Metodo invocato con IState non valido");
  654.         }
  655.     }

  657. }




Created with JaCoCo 0.8.8.202204050719