History.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.engine.driver.repository.IGestoreRepository;
  34. import org.openspcoop2.protocol.sdk.ProtocolException;
  35. import org.openspcoop2.protocol.sdk.state.IState;
  36. import org.openspcoop2.protocol.sdk.state.StateMessage;
  37. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  38. import org.openspcoop2.utils.LoggerWrapperFactory;


  41. /**
  42.  * Sono inclusi i metodi per la gestione dell'History delle buste inviate/ricevuta.
  43.  *
  44.  *
  45.  * @author Poli Andrea (apoli@link.it)
  46.  * @author Tronci Fabio (tronci@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */

  51. public class History  {

  53.     /** Logger utilizzato per debug. */
  54.     private Logger log = null;

  56.     /** Se IState e' un'istanza di StatefulMessage possiede una Connessione SQL in autoCommit mode su cui effettuare query 
  57.      *  Altrimenti, e' un'istanza di StatelessMessage e nn necessita di connessioni 
  58.      * */
  59.     private IState state;


  62.     /** GestoreRepository */
  63.     private IGestoreRepository gestoreRepositoryBuste;


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

  68.     /**
  69.      * Costruttore. 
  70.      *
  71.      * @param state Oggetto che rappresenta lo stato di una busta
  72.      * 
  73.      */
  74.     public History(IState state){
  75.         this(state,Configurazione.getLibraryLog());
  76.     }
  77.     /**
  78.      * Costruttore. 
  79.      *
  80.      * @param state Oggetto che rappresenta lo stato di una busta
  81.      * 
  82.      */
  83.     public History(IState state, Logger alog){
  84.         this.state = state;
  85.         this.gestoreRepositoryBuste = Configurazione.getGestoreRepositoryBuste();
  86.         if(alog!=null){
  87.             this.log = alog;
  88.         }else{
  89.             this.log = LoggerWrapperFactory.getLogger(History.class.getName());
  90.         }
  91.     }

  93.     public void updateState(IState state){
  94.         this.state = state;
  95.     }




  100.     /* ********  B U S T E     I N V I A T E  ******** */
  101.     /**
  102.      * Metodo che si occupa di salvare una busta, precedentemente registrata, 
  103.      * nell'history delle buste inviate. 
  104.      * 
  105.      * @param id identificativo della busta da salvare.
  106.      * 
  107.      */
  108.     public void registraBustaInviata(String id) throws ProtocolException{
  109.         registraBusta(id,Costanti.OUTBOX);
  110.     }
  111.     /**
  112.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  113.      * nell'history delle buste inviate. 
  114.      * 
  115.      * @param id identificativo della busta da eliminare.
  116.      * 
  117.      */
  118.     public void eliminaBustaInviata(String id) throws ProtocolException{
  119.         eliminaBusta(id,Costanti.OUTBOX);
  120.     }
  121.     public void eliminaBustaInviataPerRiscontri(String id) throws ProtocolException{
  122.         eliminaBustaPerRiscontri(id,Costanti.OUTBOX);
  123.     }

















  141.     /* ********  B U S T E     R I C E V U T E  ******** */
  142.     /**
  143.      * Metodo che si occupa di salvare una busta, precedentemente registrata, 
  144.      * nell'history delle buste ricevute. 
  145.      * 
  146.      * @param id identificativo della busta da salvare.
  147.      * 
  148.      */
  149.     public void registraBustaRicevuta(String id) throws ProtocolException{
  150.         registraBusta(id,Costanti.INBOX);
  151.     }
  152.     /**
  153.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  154.      * nell'history delle buste ricevute. 
  155.      * 
  156.      * @param id identificativo della busta da eliminare.
  157.      * 
  158.      */
  159.     public void eliminaBustaRicevuta(String id) throws ProtocolException{
  160.         eliminaBusta(id,Costanti.INBOX);
  161.     }
  162.     public void eliminaBustaRicevutaPerRiscontri(String id) throws ProtocolException{
  163.         eliminaBustaPerRiscontri(id,Costanti.INBOX);
  164.     }

  166.     /**
  167.      * Ritorna true, se una busta con il medesimo identificativo e' gia' stata precedentemente registrata.
  168.      *
  169.      * @param id identificativo della busta.
  170.      * @return true se una busta con il medesimo identificativo e' gia' stata precedentemente registrata. false altrimenti
  171.      * 
  172.      */
  173.     public boolean bustaRicevutaPrecedentemente(String id) throws ProtocolException{
  174.         StateMessage stateMSG = (StateMessage)this.state;
  175.         Connection connectionDB = stateMSG.getConnectionDB();

  177.         PreparedStatement pstmt = null;
  178.         ResultSet rs = null;
  179.         try{    

  181.             StringBuilder query = new StringBuilder();
  182.             query.append("select ID_MESSAGGIO from ");
  183.             query.append(Costanti.REPOSITORY);
  184.             query.append(" WHERE ID_MESSAGGIO = ? AND TIPO=? AND ");
  185.             
  186.             // controllo anche accesso_history=1 perche' puo' darsi che sia in 
  187.             // corso di gestione...questa non la devo considerare gia ricevuta! 
  188.             // per attuare questo controllo guardo che la busta non possiede accesso_history=1 (se e' gia' stata ricevuta possiede accesso_history=1)
  189.             query.append(this.gestoreRepositoryBuste.createSQLCondition_History(true));
  190.             
  191.             pstmt = connectionDB.prepareStatement(query.toString());
  192.             pstmt.setString(1,id);
  193.             pstmt.setString(2,Costanti.INBOX);

  195.             rs = pstmt.executeQuery();
  196.             if(rs != null){ 
  197.                 if(rs.next() == true) {
  198.                     rs.close();
  199.                     pstmt.close();
  200.                     return true;
  201.                 }
  202.                 else {
  203.                     rs.close();
  204.                     pstmt.close();
  205.                     return false;
  206.                 }
  207.             }

  209.             pstmt.close();

  211.             return false;

  213.         } catch(Exception e) {
  214.             String errorMsg = "HISTORY_BUSTE, Errore durante il check bustaRicevutaPrecedentemente "+id+": "+e.getMessage();        
  215.             this.log.error(errorMsg,e);
  216.             try{
  217.                 if(rs!=null)
  218.                     rs.close();
  219.             } catch(Exception er) {
  220.                 // Eccezione SQL.
  221.             }
  222.             try{
  223.                 if(pstmt!=null)
  224.                     pstmt.close();
  225.             } catch(Exception er) {
  226.                 // Eccezione SQL.
  227.             }
  228.             throw new ProtocolException(errorMsg,e);
  229.         }
  230.     }   


  233.     // ************ GESTIONE HISTORY ************

  235.     /**
  236.      * Metodo che si occupa di salvare una busta, precedentemente registrata, 
  237.      * nell'history delle buste. 
  238.      * 
  239.      * @param id identificativo della busta da salvare.
  240.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  241.      * 
  242.      */
  243.     public void registraBusta(String id,String tipoBusta) throws ProtocolException{

  245.         StateMessage stateMSG = (StateMessage)this.state;
  246.         Connection connectionDB = stateMSG.getConnectionDB();

  248.         PreparedStatement pstmtUpdate = null;
  249.         try{    

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

  261.             // Add PreparedStatement
  262.             stateMSG.getPreparedStatement().put("UPDATE saveBustaForHistory"+tipoBusta+"_"+id,pstmtUpdate);

  264.         } catch(Exception e) {
  265.             String errorMsg = "HISTORY_BUSTE, Errore di registrazione "+tipoBusta+"/"+id+": "+e.getMessage();       
  266.             this.log.error(errorMsg,e);
  267.             try{
  268.                 if( pstmtUpdate != null )
  269.                     pstmtUpdate.close();
  270.             } catch(Exception er) {
  271.                 // Eccezione SQL.
  272.             }
  273.             throw new ProtocolException(errorMsg,e);
  274.         }
  275.     }
  276.     
  277.     /**
  278.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  279.      * nell'history delle buste. 
  280.      * 
  281.      * @param id identificativo della busta da salvare.
  282.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  283.      * 
  284.      */
  285.     public void eliminaBusta(String id,String tipoBusta) throws ProtocolException{
  286.         eliminaBusta(id,tipoBusta,false);
  287.     }
  288.     public void eliminaBusta(String id,String tipoBusta,boolean forzaEliminazioneDb) throws ProtocolException{

  290.         if(this.state instanceof StatefulMessage || forzaEliminazioneDb) {
  291.             StateMessage state = (StateMessage)this.state;
  292.             Connection connectionDB = state.getConnectionDB();

  294.             PreparedStatement pstmtUpdate = null;
  295.             try{    

  297.                 StringBuilder queryUpdate = new StringBuilder();
  298.                 queryUpdate.append("UPDATE ");
  299.                 queryUpdate.append(Costanti.REPOSITORY);
  300.                 queryUpdate.append(" SET ");
  301.                 queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_History(false));
  302.                 queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  303.                 pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  304.                 pstmtUpdate.setString(1,id);
  305.                 pstmtUpdate.setString(2,tipoBusta);

  307.                 // Add PreparedStatement
  308.                 state.getPreparedStatement().put("UPDATE eliminaBustaForHistory"+tipoBusta+"_"+id,pstmtUpdate);

  310.             } catch(Exception e) {
  311.                 String errorMsg = "HISTORY_BUSTE, Errore di cancellazione "+tipoBusta+"/"+id+": "+e.getMessage();       
  312.                 this.log.error(errorMsg,e);
  313.                 try{
  314.                     if( pstmtUpdate != null )
  315.                         pstmtUpdate.close();
  316.                 } catch(Exception er) {
  317.                     // Eccezione SQL.
  318.                 }
  319.                 throw new ProtocolException(errorMsg,e);
  320.             }
  321.         }
  322.         else {
  323.             throw new ProtocolException ("Metodo non invocabile in modalita' stateless");
  324.         }
  325.     }
  326.     
  327.     /**
  328.      * Metodo che si occupa di eliminare una busta, precedentemente registrata, 
  329.      * nell'history delle buste. 
  330.      * 
  331.      * @param id identificativo della busta da salvare.
  332.      * @param tipoBusta Indicazione sul tipo di busta inviata/ricevuta
  333.      * 
  334.      */
  335.     public void eliminaBustaPerRiscontri(String id,String tipoBusta) throws ProtocolException{

  337.         StateMessage stateMSG = (StateMessage)this.state;
  338.         Connection connectionDB = stateMSG.getConnectionDB();

  340.         PreparedStatement pstmtUpdate = null;
  341.         try{    

  343.             StringBuilder queryUpdate = new StringBuilder();
  344.             queryUpdate.append("UPDATE ");
  345.             queryUpdate.append(Costanti.REPOSITORY);
  346.             queryUpdate.append(" SET ");
  347.             queryUpdate.append(this.gestoreRepositoryBuste.createSQLSet_History(false));
  348.             queryUpdate.append(" WHERE  ID_MESSAGGIO = ? AND TIPO=?");
  349.             pstmtUpdate = connectionDB.prepareStatement(queryUpdate.toString());
  350.             pstmtUpdate.setString(1,id);
  351.             pstmtUpdate.setString(2,tipoBusta);

  353.             // Add PreparedStatement
  354.             stateMSG.getPreparedStatement().put("UPDATE eliminaBustaForHistory"+tipoBusta+"_"+id,pstmtUpdate);

  356.         } catch(Exception e) {
  357.             String errorMsg = "HISTORY_BUSTE, Errore di cancellazione "+tipoBusta+"/"+id+": "+e.getMessage();       
  358.             this.log.error(errorMsg,e);
  359.             try{
  360.                 if( pstmtUpdate != null )
  361.                     pstmtUpdate.close();
  362.             } catch(Exception er) {
  363.                 // Eccezione SQL.
  364.             }
  365.             throw new ProtocolException(errorMsg,e);
  366.         }
  367.     }
  368. }
Created with JaCoCo 0.8.8.202204050719