DriverConfigurazioneDB_gestioneErroreDriver.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.  */
  20. package org.openspcoop2.core.config.driver.db;

  22. import java.sql.Connection;
  23. import java.sql.PreparedStatement;
  24. import java.sql.ResultSet;
  25. import java.sql.SQLException;

  27. import org.openspcoop2.core.commons.DBUtils;
  28. import org.openspcoop2.core.config.GestioneErrore;
  29. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  30. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  31. import org.openspcoop2.core.constants.CostantiDB;
  32. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  33. import org.openspcoop2.utils.sql.ISQLQueryObject;
  34. import org.openspcoop2.utils.sql.SQLObjectFactory;

  36. /**
  37.  * DriverConfigurazioneDB_gestioneErroreDriver
  38.  * 
  39.  * 
  40.  * @author Sandra Giangrandi (sandra@link.it)
  41.  * @author Stefano Corallo (corallo@link.it)
  42.  * @author $Author$
  43.  * @version $Rev$, $Date$
  44.  */
  45. public class DriverConfigurazioneDB_gestioneErroreDriver {

  47.     private DriverConfigurazioneDB driver = null;
  48.     
  49.     protected DriverConfigurazioneDB_gestioneErroreDriver(DriverConfigurazioneDB driver) {
  50.         this.driver = driver;
  51.     }
  52.     


  55.     /**
  56.      * Restituisce la gestione dell'errore di default definita nella Porta di Dominio per il componente di cooperazione
  57.      *
  58.      * @return La gestione dell'errore
  59.      * 
  60.      */
  61.     protected GestioneErrore getGestioneErroreComponenteCooperazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  62.         return getGestioneErrore(true);
  63.     }

  65.     /**
  66.      * Restituisce la gestione dell'errore di default definita nella Porta di Dominio per il componente di integrazione
  67.      *
  68.      * @return La gestione dell'errore
  69.      * 
  70.      */
  71.     protected GestioneErrore getGestioneErroreComponenteIntegrazione() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  72.         return getGestioneErrore(false);
  73.     }


  76.     /**
  77.      * Restituisce la gestione dell'errore di default definita nella Porta di
  78.      * Dominio
  79.      * 
  80.      * @return La gestione dell'errore
  81.      * 
  82.      */
  83.     private GestioneErrore getGestioneErrore(boolean cooperazione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {

  85.         Connection con = null;
  86.         PreparedStatement stm = null;
  87.         ResultSet rs = null;

  89.         String sqlQuery = "";

  91.         String tipoOperazione = "GestioneErrore per componente di Cooperazione";
  92.         if(cooperazione==false)
  93.             tipoOperazione = "GestioneErrore per componente di Integrazione";

  95.         if (this.driver.atomica) {
  96.             try {
  97.                 con = this.driver.getConnectionFromDatasource("getGestioneErrore("+cooperazione+")");

  99.             } catch (Exception e) {
  100.                 throw new DriverConfigurazioneException("["+tipoOperazione+"] Exception accedendo al datasource :" + e.getMessage(),e);

  102.             }

  104.         } else
  105.             con = this.driver.globalConnection;

  107.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  109.         try {
  110.             GestioneErrore gestioneErrore = null;
  111.             String nomeColonna = "id_ge_cooperazione";
  112.             if(cooperazione==false)
  113.                 nomeColonna = "id_ge_integrazione";
  114.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  115.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  116.             sqlQueryObject.addSelectField(nomeColonna);
  117.             sqlQuery = sqlQueryObject.createSQLQuery();

  119.             this.driver.logDebug("eseguo query: " + DBUtils.formatSQLString(sqlQuery));
  120.             stm = con.prepareStatement(sqlQuery);
  121.             rs = stm.executeQuery();

  123.             if (rs.next()) {

  125.                 Long idGestioneErrore = rs.getLong(nomeColonna);
  126.                 if(idGestioneErrore>0){
  127.                     gestioneErrore = DriverConfigurazioneDB_gestioneErroreLIB.getGestioneErrore(idGestioneErrore, con);
  128.                 }

  130.             } 

  132.             rs.close();
  133.             stm.close();

  135.             if(gestioneErrore==null){
  136.                 throw new DriverConfigurazioneNotFound(tipoOperazione +" non presente.");
  137.             }
  138.             return gestioneErrore;

  140.         } catch (SQLException se) {
  141.             throw new DriverConfigurazioneException(tipoOperazione +" SqlException: " + se.getMessage(),se);
  142.         }catch (DriverConfigurazioneNotFound e) {
  143.             throw new DriverConfigurazioneNotFound(e);
  144.         }catch (Exception se) {
  145.             throw new DriverConfigurazioneException(tipoOperazione +" Exception: " + se.getMessage(),se);
  146.         } finally {
  147.             //Chiudo statement and resultset
  148.             JDBCUtilities.closeResources(rs, stm);
  149.             this.driver.closeConnection(con);
  150.         }

  152.     }
  153.     
  154.     protected void createGestioneErroreComponenteCooperazione(GestioneErrore gestione) throws DriverConfigurazioneException{
  155.         Connection con = null;
  156.         boolean error = false;

  158.         if (this.driver.atomica) {
  159.             try {
  160.                 con = this.driver.getConnectionFromDatasource("createGestioneErroreComponenteCooperazione");
  161.                 con.setAutoCommit(false);
  162.             } catch (Exception e) {
  163.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createGestioneErroreComponenteCooperazione] Exception accedendo al datasource :" + e.getMessage(),e);

  165.             }

  167.         } else
  168.             con = this.driver.globalConnection;

  170.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  172.         PreparedStatement pstmt = null;
  173.         try {
  174.             this.driver.logDebug("CRUDGestioneErrore type = 1");
  175.             DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreComponenteCooperazione(CostantiDB.CREATE, gestione, con);

  177.             // Aggiorno configurazione
  178.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  179.             sqlQueryObject.addUpdateTable(CostantiDB.CONFIGURAZIONE);
  180.             sqlQueryObject.addUpdateField("id_ge_cooperazione", "?");
  181.             String updateQuery = sqlQueryObject.createSQLUpdate();
  182.             pstmt = con.prepareStatement(updateQuery);
  183.             pstmt.setLong(1, gestione.getId());
  184.             pstmt.execute();
  185.             pstmt.close();

  187.         } catch (Exception qe) {
  188.             error = true;
  189.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createGestioneErroreComponenteCooperazione] Errore: " + qe.getMessage(),qe);
  190.         } finally {

  192.             JDBCUtilities.closeResources(pstmt);

  194.             this.driver.closeConnection(error,con);
  195.         }
  196.     }

  198.     /**
  199.      * Aggiorna le informazioni per la gestione dell'errore per il ComponenteCooperazione
  200.      * 
  201.      * @param gestione
  202.      * @throws DriverConfigurazioneException
  203.      */
  204.     protected void updateGestioneErroreComponenteCooperazione(GestioneErrore gestione) throws DriverConfigurazioneException{
  205.         Connection con = null;
  206.         boolean error = false;

  208.         if (this.driver.atomica) {
  209.             try {
  210.                 con = this.driver.getConnectionFromDatasource("updateGestioneErroreComponenteCooperazione");
  211.                 con.setAutoCommit(false);
  212.             } catch (Exception e) {
  213.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateGestioneErroreComponenteCooperazione] Exception accedendo al datasource :" + e.getMessage(),e);

  215.             }

  217.         } else
  218.             con = this.driver.globalConnection;

  220.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  222.         try {
  223.             this.driver.logDebug("CRUDGestioneErrore type = 2");
  224.             DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreComponenteCooperazione(CostantiDB.UPDATE, gestione, con);

  226.         } catch (Exception qe) {
  227.             error = true;
  228.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateGestioneErroreComponenteCooperazione] Errore: " + qe.getMessage(),qe);
  229.         } finally {

  231.             this.driver.closeConnection(error,con);
  232.         }
  233.     }

  235.     /**
  236.      * Elimina le informazioni per la gestione dell'errore per il ComponenteCooperazione
  237.      * 
  238.      * @param gestione
  239.      * @throws DriverConfigurazioneException
  240.      */
  241.     protected void deleteGestioneErroreComponenteCooperazione(GestioneErrore gestione) throws DriverConfigurazioneException{
  242.         Connection con = null;
  243.         boolean error = false;

  245.         if (this.driver.atomica) {
  246.             try {
  247.                 con = this.driver.getConnectionFromDatasource("deleteGestioneErroreComponenteCooperazione");
  248.                 con.setAutoCommit(false);
  249.             } catch (Exception e) {
  250.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteGestioneErroreComponenteCooperazione] Exception accedendo al datasource :" + e.getMessage(),e);

  252.             }

  254.         } else
  255.             con = this.driver.globalConnection;

  257.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  259.         try {
  260.             this.driver.logDebug("CRUDGestioneErrore type = 3");
  261.             DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreComponenteCooperazione(CostantiDB.DELETE, gestione, con);

  263.         } catch (Exception qe) {
  264.             error = true;
  265.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteGestioneErroreComponenteCooperazione] Errore: " + qe.getMessage(),qe);
  266.         } finally {

  268.             this.driver.closeConnection(error,con);
  269.         }
  270.     }

  272.     /**
  273.      * Crea le informazioni per la gestione dell'errore per il ComponenteIntegrazione
  274.      * 
  275.      * @param gestione
  276.      * @throws DriverConfigurazioneException
  277.      */
  278.     protected void createGestioneErroreComponenteIntegrazione(GestioneErrore gestione) throws DriverConfigurazioneException{
  279.         Connection con = null;
  280.         boolean error = false;

  282.         if (this.driver.atomica) {
  283.             try {
  284.                 con = this.driver.getConnectionFromDatasource("createGestioneErroreComponenteIntegrazione");
  285.                 con.setAutoCommit(false);
  286.             } catch (Exception e) {
  287.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createGestioneErroreComponenteIntegrazione] Exception accedendo al datasource :" + e.getMessage(),e);

  289.             }

  291.         } else
  292.             con = this.driver.globalConnection;

  294.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  296.         PreparedStatement pstmt = null;
  297.         try {
  298.             this.driver.logDebug("CRUDGestioneErrore type = 1");
  299.             DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreComponenteIntegrazione(CostantiDB.CREATE, gestione, con);

  301.             // Aggiorno configurazione
  302.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  303.             sqlQueryObject.addUpdateTable(CostantiDB.CONFIGURAZIONE);
  304.             sqlQueryObject.addUpdateField("id_ge_integrazione", "?");
  305.             String updateQuery = sqlQueryObject.createSQLUpdate();
  306.             pstmt = con.prepareStatement(updateQuery);
  307.             pstmt.setLong(1, gestione.getId());
  308.             pstmt.execute();
  309.             pstmt.close();

  311.         } catch (Exception qe) {
  312.             error = true;
  313.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createGestioneErroreComponenteIntegrazione] Errore: " + qe.getMessage(),qe);
  314.         } finally {

  316.             JDBCUtilities.closeResources(pstmt);

  318.             this.driver.closeConnection(error,con);
  319.         }
  320.     }

  322.     /**
  323.      * Aggiorna le informazioni per la gestione dell'errore per il ComponenteIntegrazione
  324.      * 
  325.      * @param gestione
  326.      * @throws DriverConfigurazioneException
  327.      */
  328.     protected void updateGestioneErroreComponenteIntegrazione(GestioneErrore gestione) throws DriverConfigurazioneException{
  329.         Connection con = null;
  330.         boolean error = false;

  332.         if (this.driver.atomica) {
  333.             try {
  334.                 con = this.driver.getConnectionFromDatasource("updateGestioneErroreComponenteIntegrazione");
  335.                 con.setAutoCommit(false);
  336.             } catch (Exception e) {
  337.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateGestioneErroreComponenteIntegrazione] Exception accedendo al datasource :" + e.getMessage(),e);

  339.             }

  341.         } else
  342.             con = this.driver.globalConnection;

  344.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  346.         try {
  347.             this.driver.logDebug("CRUDGestioneErrore type = 2");
  348.             DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreComponenteIntegrazione(CostantiDB.UPDATE, gestione, con);

  350.         } catch (Exception qe) {
  351.             error = true;
  352.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateGestioneErroreComponenteIntegrazione] Errore: " + qe.getMessage(),qe);
  353.         } finally {

  355.             this.driver.closeConnection(error,con);
  356.         }
  357.     }

  359.     /**
  360.      * Elimina le informazioni per la gestione dell'errore per il ComponenteIntegrazione
  361.      * 
  362.      * @param gestione
  363.      * @throws DriverConfigurazioneException
  364.      */
  365.     protected void deleteGestioneErroreComponenteIntegrazione(GestioneErrore gestione) throws DriverConfigurazioneException{
  366.         Connection con = null;
  367.         boolean error = false;

  369.         if (this.driver.atomica) {
  370.             try {
  371.                 con = this.driver.getConnectionFromDatasource("deleteGestioneErroreComponenteIntegrazione");
  372.                 con.setAutoCommit(false);
  373.             } catch (Exception e) {
  374.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteGestioneErroreComponenteIntegrazione] Exception accedendo al datasource :" + e.getMessage(),e);

  376.             }

  378.         } else
  379.             con = this.driver.globalConnection;

  381.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);

  383.         try {
  384.             this.driver.logDebug("CRUDGestioneErrore type = 3");
  385.             DriverConfigurazioneDB_gestioneErroreLIB.CRUDGestioneErroreComponenteIntegrazione(CostantiDB.DELETE, gestione, con);

  387.         } catch (Exception qe) {
  388.             error = true;
  389.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteGestioneErroreComponenteIntegrazione] Errore: " + qe.getMessage(),qe);
  390.         } finally {

  392.             this.driver.closeConnection(error,con);
  393.         }
  394.     }
  395. }
Created with JaCoCo 0.8.8.202204050719