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

  29. import org.slf4j.Logger;
  30. import org.openspcoop2.protocol.engine.Configurazione;
  31. import org.openspcoop2.protocol.engine.constants.Costanti;
  32. import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
  33. import org.openspcoop2.protocol.sdk.ProtocolException;
  34. import org.openspcoop2.protocol.sdk.state.IState;
  35. import org.openspcoop2.protocol.sdk.state.StateMessage;
  36. import org.openspcoop2.utils.LoggerWrapperFactory;


  39. /**
  40.  * Classe utilizzata per effettuare rollback applicativo
  41.  * di informazioni salvate precedentemente nei DB.
  42.  *
  43.  *
  44.  * @author Poli Andrea (apoli@link.it)
  45.  * @author Tronci Fabio (tronci@link.it)
  46.  * @author $Author$
  47.  * @version $Rev$, $Date$
  48.  */

  50. public class RollbackRepositoryBuste implements java.io.Serializable {

  52.     /**
  53.      * serialVersionUID
  54.      */
  55.     private static final long serialVersionUID = 1L;

  57.     /** Logger utilizzato per debug. */
  58.     private Logger log = null;

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

  64.     /** Identificativo */
  65.     private String idBusta;

  67.     /** GestoreRepository */
  68.     private IGestoreRepository gestoreRepositoryBuste;

  70.     /** Indicazione se stiamo gestendo il onewat in modalita 11 */
  71.     //private boolean oneWay11 = false;


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

  76.     /**
  77.      * Costruttore. 
  78.      *
  79.      * @param id ID su cui effettuare il rollback delle precedenti informazioni salvate.
  80.      * @param state Oggetto che rappresenta lo stato di una busta
  81.      * 
  82.      */
  83.     public RollbackRepositoryBuste(String id, IState state,boolean oneWay11){
  84.         this(id,state,Configurazione.getLibraryLog(),oneWay11);
  85.     }
  86.     /**
  87.      * Costruttore. 
  88.      *
  89.      * @param id ID su cui effettuare il rollback delle precedenti informazioni salvate.
  90.      * @param state Oggetto che rappresenta lo stato di una busta
  91.      * 
  92.      */
  93.     public RollbackRepositoryBuste(String id,IState state,Logger aLog,boolean oneWay11){
  94.         this.idBusta = id;
  95.         this.state = state;
  96.         this.gestoreRepositoryBuste = Configurazione.getGestoreRepositoryBuste();
  97.         if(aLog!=null)
  98.             this.log = aLog;
  99.         else
  100.             this.log = LoggerWrapperFactory.getLogger(RollbackRepositoryBuste.class.getName());
  101.         //this.oneWay11 = oneWay11;
  102.     }




  107.     /**
  108.      * Metodo che si occupa di eliminare tutti i dati creati durante una gestione di una richiesta
  109.      * in una fase di Porta di Dominio Delegata (Invocazione di una porta di dominio delegata).
  110.      *
  111.      * 
  112.      */
  113.     public void rollbackBustaIntoOutBox() throws ProtocolException{ 
  114.         this.rollback(Costanti.OUTBOX,true); 
  115.     }
  116.     /**
  117.      * Metodo che si occupa di eliminare tutti i dati creati durante una gestione di una richiesta
  118.      * in una fase di Porta di Dominio Delegata (Invocazione di una porta di dominio delegata).
  119.      *
  120.      * @param rollbackAccessoHistory rollback dell'accesso effettuato dall'History
  121.      * 
  122.      */
  123.     public void rollbackBustaIntoOutBox(boolean rollbackAccessoHistory) throws ProtocolException{   
  124.         this.rollback(Costanti.OUTBOX,rollbackAccessoHistory); 
  125.     }

  127.     /**
  128.      * Metodo che si occupa di eliminare tutti i dati creati durante una gestione di una richiesta
  129.      * in una fase di Porta di Dominio Applicativa (Invocazione di una porta di dominio applicativa).
  130.      *
  131.      * 
  132.      */
  133.     public void rollbackBustaIntoInBox() throws ProtocolException{
  134.         this.rollback(Costanti.INBOX,true);
  135.     }
  136.     /**
  137.      * Metodo che si occupa di eliminare tutti i dati creati durante una gestione di una richiesta
  138.      * in una fase di Porta di Dominio Applicativa (Invocazione di una porta di dominio applicativa).
  139.      *
  140.      * @param rollbackAccessoHistory rollback dell'accesso effettuato dall'History
  141.      * 
  142.      */
  143.     public void rollbackBustaIntoInBox(boolean rollbackAccessoHistory) throws ProtocolException{
  144.         this.rollback(Costanti.INBOX,rollbackAccessoHistory);
  145.     }









  155.     /* ********  UTILITY DI ROLLBACK APPLICATIVO  ******** */
  156.     /**
  157.      * Metodo che si occupa di eliminare i dati di una busta presente nel RepositoryBuste.
  158.      *
  159.      * @param tipoBusta tipo di busta INBOX/OUTBOX
  160.      * @param rollbackAccessoHistory rollback dell'accesso effettuato dall'History
  161.      * 
  162.      */
  163.     public void rollback(String tipoBusta,boolean rollbackAccessoHistory) throws ProtocolException{

  165.         StateMessage stateMSG = (StateMessage)this.state;
  166.         Connection connectionDB = stateMSG.getConnectionDB();

  168.         if(connectionDB!=null){
  169.             PreparedStatement pstmtUpdateHistory = null;
  170.             PreparedStatement pstmtUpdateProfilo = null;
  171.             PreparedStatement pstmtUpdatePdd = null;
  172.             try{    
  173.     
  174.                 // Le prepared Stamenent devono essere suddivise, per Oracle, ad es, non accetta SET di stessi field.
  175.     
  176.                 // rollback AccessoHistory
  177.                 if(rollbackAccessoHistory){
  178.                     StringBuilder queryUpdateHistory = new StringBuilder();
  179.                     queryUpdateHistory.append("UPDATE ");
  180.                     queryUpdateHistory.append(Costanti.REPOSITORY);
  181.                     queryUpdateHistory.append(" SET ");
  182.                     queryUpdateHistory.append(this.gestoreRepositoryBuste.createSQLSet_History(false));
  183.                     queryUpdateHistory.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  184.                     pstmtUpdateHistory =  connectionDB.prepareStatement(queryUpdateHistory.toString());
  185.                     pstmtUpdateHistory.setString(1,this.idBusta);
  186.                     pstmtUpdateHistory.setString(2,tipoBusta);
  187.                     // Add PreparedStatement
  188.                     stateMSG.getPreparedStatement().put("RollbackGeneraleHISTORY_"+tipoBusta+"_"+this.idBusta,pstmtUpdateHistory);
  189.                 }
  190.     
  191.                 // rollback profilo
  192.                 StringBuilder queryUpdateProfilo= new StringBuilder();
  193.                 queryUpdateProfilo.append("UPDATE ");
  194.                 queryUpdateProfilo.append(Costanti.REPOSITORY);
  195.                 queryUpdateProfilo.append(" SET ");
  196.                 queryUpdateProfilo.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(false));
  197.                 queryUpdateProfilo.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  198.                 pstmtUpdateProfilo =  connectionDB.prepareStatement(queryUpdateProfilo.toString());
  199.                 pstmtUpdateProfilo.setString(1,this.idBusta);
  200.                 pstmtUpdateProfilo.setString(2,tipoBusta);
  201.                 // Add PreparedStatement
  202.                 stateMSG.getPreparedStatement().put("RollbackGeneralePROFILO_"+tipoBusta+"_"+this.idBusta,pstmtUpdateProfilo);
  203.     
  204.                 // rollback pdd
  205.                 StringBuilder queryUpdatePdd = new StringBuilder();
  206.                 queryUpdatePdd.append("UPDATE ");
  207.                 queryUpdatePdd.append(Costanti.REPOSITORY);
  208.                 queryUpdatePdd.append(" SET ");
  209.                 queryUpdatePdd.append(this.gestoreRepositoryBuste.createSQLSet_PdD(false));
  210.                 queryUpdatePdd.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  211.                 pstmtUpdatePdd =  connectionDB.prepareStatement(queryUpdatePdd.toString());
  212.                 pstmtUpdatePdd.setString(1,this.idBusta);
  213.                 pstmtUpdatePdd.setString(2,tipoBusta);
  214.                 // Add PreparedStatement
  215.                 stateMSG.getPreparedStatement().put("RollbackGeneralePDD_"+tipoBusta+"_"+this.idBusta,pstmtUpdatePdd);
  216.     
  217.             } catch(Exception e) {
  218.                 String errorMsg = "ROLLBACK_BUSTE, Errore "+tipoBusta+"/"+this.idBusta+": "+e.getMessage();
  219.                 this.log.info(errorMsg,e);
  220.                 try{
  221.                     if( pstmtUpdateHistory != null )
  222.                         pstmtUpdateHistory.close();
  223.                 } catch(Exception er) {
  224.                     // close
  225.                 }
  226.                 try{
  227.                     if( pstmtUpdateProfilo != null )
  228.                         pstmtUpdateProfilo.close();
  229.                 } catch(Exception er) {
  230.                     // close
  231.                 }
  232.                 try{
  233.                     if( pstmtUpdatePdd != null )
  234.                         pstmtUpdatePdd.close();
  235.                 } catch(Exception er) {
  236.                     // close
  237.                 }
  238.                 throw new ProtocolException(errorMsg,e);
  239.             }
  240.         }else{
  241.             this.log.debug("Rollback("+tipoBusta+"/"+this.idBusta+") non effettuato, connessione is null");
  242.         }

  244.     }

  246.     /* ********  UTILITY DI SET ACCESSI  ******** */
  247.     /**
  248.      * Metodo che si occupa di eliminare i dati di una busta presente nel RepositoryBuste.
  249.      *
  250.      * @param history accesso effettuato dall'History
  251.      * @param profilo accesso effettuato dall'History
  252.      * @param pdd accesso effettuato dall'History
  253.      * 
  254.      */
  255.     public void clearAccessiIntoInBox(boolean history,boolean profilo,boolean pdd) throws ProtocolException{
  256.         clearAccessi(Costanti.INBOX,history,profilo,pdd);
  257.     }
  258.     /**
  259.      * Metodo che si occupa di eliminare i dati di una busta presente nel RepositoryBuste.
  260.      *
  261.      * @param history accesso effettuato dall'History
  262.      * @param profilo accesso effettuato dall'History
  263.      * @param pdd accesso effettuato dall'History
  264.      * 
  265.      */
  266.     public void clearAccessiIntoOutBox(boolean history,boolean profilo,boolean pdd) throws ProtocolException{
  267.         clearAccessi(Costanti.OUTBOX,history,profilo,pdd);
  268.     }
  269.     /**
  270.      * Metodo che si occupa di eliminare i dati di una busta presente nel RepositoryBuste.
  271.      *
  272.      * @param tipoBusta tipo di busta INBOX/OUTBOX
  273.      * @param history accesso effettuato dall'History
  274.      * @param profilo accesso effettuato dall'History
  275.      * @param pdd accesso effettuato dall'History
  276.      * 
  277.      */
  278.     private void clearAccessi(String tipoBusta,boolean history,boolean profilo,boolean pdd) throws ProtocolException{
  279.         StateMessage stateMSG = (StateMessage)this.state;
  280.         Connection connectionDB = stateMSG.getConnectionDB();

  282.         if(connectionDB!=null){
  283.             PreparedStatement pstmtUpdateHistory = null;
  284.             PreparedStatement pstmtUpdateProfilo = null;
  285.             PreparedStatement pstmtUpdatePdd = null;
  286.             try{    
  287.     
  288.                 if(history==false && profilo==false && pdd==false)
  289.                     return;
  290.     
  291.                 // rollback AccessoHistory
  292.                 if(history){
  293.                     StringBuilder queryUpdateHistory = new StringBuilder();
  294.                     queryUpdateHistory.append("UPDATE ");
  295.                     queryUpdateHistory.append(Costanti.REPOSITORY);
  296.                     queryUpdateHistory.append(" SET ");
  297.                     queryUpdateHistory.append(this.gestoreRepositoryBuste.createSQLSet_History(false));
  298.                     queryUpdateHistory.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  299.                     pstmtUpdateHistory =  connectionDB.prepareStatement(queryUpdateHistory.toString());
  300.                     pstmtUpdateHistory.setString(1,this.idBusta);
  301.                     pstmtUpdateHistory.setString(2,tipoBusta);
  302.                     // Add PreparedStatement
  303.                     stateMSG.getPreparedStatement().put("ClearAccessiHISTORY_"+tipoBusta+"_"+this.idBusta,pstmtUpdateHistory);
  304.                 }
  305.     
  306.                 // rollback profilo
  307.                 if(profilo){
  308.                     StringBuilder queryUpdateProfilo= new StringBuilder();
  309.                     queryUpdateProfilo.append("UPDATE ");
  310.                     queryUpdateProfilo.append(Costanti.REPOSITORY);
  311.                     queryUpdateProfilo.append(" SET ");
  312.                     queryUpdateProfilo.append(this.gestoreRepositoryBuste.createSQLSet_ProfiloCollaborazione(false));
  313.                     queryUpdateProfilo.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  314.                     pstmtUpdateProfilo =  connectionDB.prepareStatement(queryUpdateProfilo.toString());
  315.                     pstmtUpdateProfilo.setString(1,this.idBusta);
  316.                     pstmtUpdateProfilo.setString(2,tipoBusta);
  317.                     // Add PreparedStatement
  318.                     stateMSG.getPreparedStatement().put("ClearAccessiPROFILO_"+tipoBusta+"_"+this.idBusta,pstmtUpdateProfilo);
  319.                 }
  320.     
  321.                 // rollback pdd
  322.                 if(pdd){
  323.                     StringBuilder queryUpdatePdd = new StringBuilder();
  324.                     queryUpdatePdd.append("UPDATE ");
  325.                     queryUpdatePdd.append(Costanti.REPOSITORY);
  326.                     queryUpdatePdd.append(" SET ");
  327.                     queryUpdatePdd.append(this.gestoreRepositoryBuste.createSQLSet_PdD(false));
  328.                     queryUpdatePdd.append(" WHERE ID_MESSAGGIO = ? AND TIPO=?");
  329.                     pstmtUpdatePdd = connectionDB.prepareStatement(queryUpdatePdd.toString());
  330.                     pstmtUpdatePdd.setString(1,this.idBusta);
  331.                     pstmtUpdatePdd.setString(2,tipoBusta);
  332.                     // Add PreparedStatement
  333.                     stateMSG.getPreparedStatement().put("ClearAccessiPDD_"+tipoBusta+"_"+this.idBusta,pstmtUpdatePdd);
  334.                 }
  335.     
  336.     
  337.             } catch(Exception e) {
  338.                 String errorMsg = "ROLLBACK_BUSTE, setAccessi Errore "+tipoBusta+"/"+this.idBusta+": "+e.getMessage();
  339.                 this.log.info(errorMsg,e);
  340.                 try{
  341.                     if( pstmtUpdateHistory != null )
  342.                         pstmtUpdateHistory.close();
  343.                 } catch(Exception er) {
  344.                     // close
  345.                 }
  346.                 try{
  347.                     if( pstmtUpdateProfilo != null )
  348.                         pstmtUpdateProfilo.close();
  349.                 } catch(Exception er) {
  350.                     // close
  351.                 }
  352.                 try{
  353.                     if( pstmtUpdatePdd != null )
  354.                         pstmtUpdatePdd.close();
  355.                 } catch(Exception er) {
  356.                     // close
  357.                 }
  358.                 throw new ProtocolException(errorMsg,e);
  359.             }
  360.         }else{
  361.             this.log.debug("clearAccessi("+tipoBusta+"/"+this.idBusta+") non effettuato, connessione is null");
  362.         }
  363.     }
  364. }
Created with JaCoCo 0.8.8.202204050719