DriverRegistroServiziDB_accordiExistsDriver.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.registry.driver.db;

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

  26. import org.openspcoop2.core.commons.DBUtils;
  27. import org.openspcoop2.core.constants.CostantiDB;
  28. import org.openspcoop2.core.id.IDAccordo;
  29. import org.openspcoop2.core.id.IDPortType;
  30. import org.openspcoop2.core.registry.constants.ParameterType;
  31. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  32. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  33. import org.openspcoop2.utils.sql.ISQLQueryObject;
  34. import org.openspcoop2.utils.sql.SQLObjectFactory;

  36. /**
  37.  * DriverRegistroServiziDB_accordiExistsDriver
  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 DriverRegistroServiziDB_accordiExistsDriver {

  47.     private DriverRegistroServiziDB driver = null;
  48.     
  49.     protected DriverRegistroServiziDB_accordiExistsDriver(DriverRegistroServiziDB driver) {
  50.         this.driver = driver;
  51.     }
  52.     
  53.     protected boolean existsAccordoServizioParteComune(IDAccordo idAccordo) throws DriverRegistroServiziException {

  55.         Connection connection;
  56.         if (this.driver.atomica) {
  57.             try {
  58.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComune(idAccordo)");
  59.             } catch (Exception e) {
  60.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComune] Exception accedendo al datasource :" + e.getMessage(),e);

  62.             }

  64.         } else
  65.             connection = this.driver.globalConnection;

  67.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  68.         try {

  70.             // Check soggetto referente se esiste.
  71.             if(idAccordo.getSoggettoReferente()!=null){
  72.                 if(this.driver.existsSoggetto(connection, idAccordo.getSoggettoReferente())==false){
  73.                     return false;
  74.                 }
  75.             }

  77.             long idAccordoLong = DBUtils.getIdAccordoServizioParteComune(idAccordo, connection, this.driver.tipoDB);
  78.             if (idAccordoLong <= 0)
  79.                 return false;
  80.             else
  81.                 return true;
  82.         } catch (Exception e) {
  83.             throw new DriverRegistroServiziException(e.getMessage(),e);
  84.         } finally {
  85.             this.driver.closeConnection(connection);
  86.         }
  87.     }

  89.     /**
  90.      * Verifica l'esistenza di un accordo registrato.
  91.      * 
  92.      * @param idAccordo
  93.      *                dell'accordo da verificare
  94.      * @return true se l'accordo esiste, false altrimenti
  95.      */
  96.     protected boolean existsAccordoServizioParteComune(long idAccordo) throws DriverRegistroServiziException {

  98.         Connection connection = null;
  99.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  100.         PreparedStatement stm=null;
  101.         ResultSet rs=null;
  102.         try {
  103.             if (this.driver.atomica) {
  104.                 try {
  105.                     connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComune(longId)");
  106.                 } catch (Exception e) {
  107.                     throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComune] Exception accedendo al datasource :" + e.getMessage(),e);

  109.                 }

  111.             } else
  112.                 connection = this.driver.globalConnection;
  113.             
  114.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  115.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI);
  116.             sqlQueryObject.addSelectField("*");
  117.             sqlQueryObject.addWhereCondition("id = ?");
  118.             String sqlQuery = sqlQueryObject.createSQLQuery();
  119.             stm=connection.prepareStatement(sqlQuery);
  120.             stm.setLong(1, idAccordo);
  121.             rs=stm.executeQuery();
  122.             if (rs.next())
  123.                 return true;
  124.             else
  125.                 return false;
  126.         } catch (Exception e) {
  127.             throw new DriverRegistroServiziException(e.getMessage(),e);
  128.         } finally {
  129.             JDBCUtilities.closeResources(rs, stm);
  130.             this.driver.closeConnection(connection);
  131.         }
  132.     }

  134.     /**
  135.      * Verifica l'esistenza di un'azione in un accordo
  136.      * 
  137.      * @param nome
  138.      *                dell'azione da verificare
  139.      * @param idAccordo Identificativo dell'accordi di servizio
  140.      *               
  141.      * @return true se l'azione esiste, false altrimenti
  142.      */
  143.     protected boolean existsAccordoServizioParteComuneAzione(String nome, IDAccordo idAccordo) throws DriverRegistroServiziException {

  145.         Connection connection;
  146.         if (this.driver.atomica) {
  147.             try {
  148.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComuneAzione(nome,idAccordo)");
  149.             } catch (Exception e) {
  150.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComuneAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  152.             }

  154.         } else
  155.             connection = this.driver.globalConnection;

  157.         try {
  158.             return existsAccordoServizioParteComuneAzione(nome, DBUtils.getIdAccordoServizioParteComune(idAccordo, connection, this.driver.tipoDB));
  159.         }catch (Exception e) {
  160.             throw new DriverRegistroServiziException(e.getMessage(),e);
  161.         } finally {
  162.             this.driver.closeConnection(connection);
  163.         }

  165.     }

  167.     /**
  168.      * Verifica l'esistenza di un'azione in un accordo
  169.      * 
  170.      * @param nome
  171.      *                dell'azione da verificare
  172.      * @param idAccordo
  173.      *                dell'accordo
  174.      * @return true se l'azione esiste, false altrimenti
  175.      */
  176.     protected boolean existsAccordoServizioParteComuneAzione(String nome, long idAccordo) throws DriverRegistroServiziException {

  178.         boolean exist = false;
  179.         Connection connection;
  180.         PreparedStatement stm = null;
  181.         ResultSet rs = null;
  182.         if (this.driver.atomica) {
  183.             try {
  184.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComuneAzione(nome,longId)");
  185.             } catch (Exception e) {
  186.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComuneAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  188.             }

  190.         } else
  191.             connection = this.driver.globalConnection;

  193.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  194.         try {
  195.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  196.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_AZIONI);
  197.             sqlQueryObject.addSelectField("*");
  198.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  199.             sqlQueryObject.addWhereCondition("nome = ?");
  200.             sqlQueryObject.setANDLogicOperator(true);
  201.             String sqlQuery = sqlQueryObject.createSQLQuery();
  202.             stm = connection.prepareStatement(sqlQuery);
  203.             stm.setLong(1, idAccordo);
  204.             stm.setString(2, nome);
  205.             rs = stm.executeQuery();
  206.             if (rs.next())
  207.                 exist = true;
  208.             rs.close();
  209.             stm.close();
  210.         } catch (Exception e) {
  211.             exist = false;
  212.             throw new DriverRegistroServiziException(e.getMessage(),e);
  213.         } finally {

  215.             //Chiudo statement and resultset
  216.             JDBCUtilities.closeResources(rs, stm);

  218.             this.driver.closeConnection(connection);
  219.         }

  221.         return exist;
  222.     }

  224.     /**
  225.      * Verifica l'esistenza di un'azione in un accordo
  226.      * 
  227.      * @param idAzione dell'azione
  228.      * @return true se l'azione esiste, false altrimenti
  229.      */
  230.     protected boolean existsAccordoServizioParteComuneAzione(long idAzione) throws DriverRegistroServiziException {

  232.         boolean exist = false;
  233.         Connection connection;
  234.         PreparedStatement stm = null;
  235.         ResultSet rs = null;
  236.         if (this.driver.atomica) {
  237.             try {
  238.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComuneAzione(longId)");
  239.             } catch (Exception e) {
  240.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComuneAzione] Exception accedendo al datasource :" + e.getMessage(),e);

  242.             }

  244.         } else
  245.             connection = this.driver.globalConnection;

  247.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  248.         try {
  249.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  250.             sqlQueryObject.addFromTable(CostantiDB.ACCORDI_AZIONI);
  251.             sqlQueryObject.addSelectField("*");
  252.             sqlQueryObject.addWhereCondition("id = ?");
  253.             String sqlQuery = sqlQueryObject.createSQLQuery();
  254.             stm = connection.prepareStatement(sqlQuery);
  255.             stm.setLong(1, idAzione);
  256.             rs = stm.executeQuery();
  257.             if (rs.next())
  258.                 exist = true;
  259.             rs.close();
  260.             stm.close();
  261.         } catch (Exception e) {
  262.             exist = false;
  263.             throw new DriverRegistroServiziException(e.getMessage(),e);
  264.         } finally {

  266.             //Chiudo statement and resultset
  267.             JDBCUtilities.closeResources(rs, stm);

  269.             this.driver.closeConnection(connection);
  270.         }

  272.         return exist;
  273.     }

  275.     protected boolean existsAccordoServizioParteComunePorttype(String nome, IDAccordo idAccordo) throws DriverRegistroServiziException {
  276.         Connection connection;
  277.         if (this.driver.atomica) {
  278.             try {
  279.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComunePorttype(nome,idAccordo)");
  280.             } catch (Exception e) {
  281.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComunePorttype] Exception accedendo al datasource :" + e.getMessage(),e);

  283.             }

  285.         } else
  286.             connection = this.driver.globalConnection;

  288.         try {
  289.             return existsAccordoServizioParteComunePorttype(nome, DBUtils.getIdAccordoServizioParteComune(idAccordo, connection, this.driver.tipoDB));
  290.         }catch (Exception e) {
  291.             throw new DriverRegistroServiziException(e.getMessage(),e);
  292.         } finally {
  293.             this.driver.closeConnection(connection);
  294.         }
  295.     }



  299.     /**
  300.      * Verifica l'esistenza di un'operation in un accordo
  301.      * 
  302.      * @param idAzione dell'azione
  303.      * @return true se l'azione esiste, false altrimenti
  304.      */
  305.     protected boolean existsAccordoServizioParteComuneOperation(long idAzione) throws DriverRegistroServiziException {

  307.         boolean exist = false;
  308.         Connection connection;
  309.         PreparedStatement stm = null;
  310.         ResultSet rs = null;
  311.         if (this.driver.atomica) {
  312.             try {
  313.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComuneOperation(longId)");
  314.             } catch (Exception e) {
  315.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComuneOperation] Exception accedendo al datasource :" + e.getMessage(),e);

  317.             }

  319.         } else
  320.             connection = this.driver.globalConnection;

  322.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  323.         try {
  324.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  325.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  326.             sqlQueryObject.addSelectField("*");
  327.             sqlQueryObject.addWhereCondition("id = ?");
  328.             String sqlQuery = sqlQueryObject.createSQLQuery();
  329.             stm = connection.prepareStatement(sqlQuery);
  330.             stm.setLong(1, idAzione);
  331.             rs = stm.executeQuery();
  332.             if (rs.next())
  333.                 exist = true;
  334.             rs.close();
  335.             stm.close();
  336.         } catch (Exception e) {
  337.             exist = false;
  338.             throw new DriverRegistroServiziException(e.getMessage(),e);
  339.         } finally {

  341.             //Chiudo statement and resultset
  342.             JDBCUtilities.closeResources(rs, stm);

  344.             this.driver.closeConnection(connection);
  345.         }

  347.         return exist;
  348.     }

  350.     /**
  351.      * Verifica l'esistenza di un port-type in un accordo
  352.      * 
  353.      * @param nome
  354.      *                del port-type da verificare
  355.      * @param idAccordo
  356.      *                dell'accordo
  357.      * @return true se il port-type esiste, false altrimenti
  358.      */
  359.     protected boolean existsAccordoServizioParteComunePorttype(String nome, long idAccordo) throws DriverRegistroServiziException {

  361.         boolean exist = false;
  362.         Connection connection;
  363.         PreparedStatement stm = null;
  364.         ResultSet rs = null;
  365.         if (this.driver.atomica) {
  366.             try {
  367.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComunePorttype(nome,longId)");
  368.             } catch (Exception e) {
  369.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComunePorttype] Exception accedendo al datasource :" + e.getMessage(),e);

  371.             }

  373.         } else
  374.             connection = this.driver.globalConnection;

  376.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  377.         try {
  378.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  379.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE);
  380.             sqlQueryObject.addSelectField("*");
  381.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  382.             sqlQueryObject.addWhereCondition("nome = ?");
  383.             sqlQueryObject.setANDLogicOperator(true);
  384.             String sqlQuery = sqlQueryObject.createSQLQuery();
  385.             stm = connection.prepareStatement(sqlQuery);
  386.             stm.setLong(1, idAccordo);
  387.             stm.setString(2, nome);
  388.             rs = stm.executeQuery();
  389.             if (rs.next())
  390.                 exist = true;
  391.             rs.close();
  392.             stm.close();
  393.         } catch (Exception e) {
  394.             exist = false;
  395.             throw new DriverRegistroServiziException(e.getMessage(),e);
  396.         } finally {

  398.             //Chiudo statement and resultset
  399.             JDBCUtilities.closeResources(rs, stm);

  401.             this.driver.closeConnection(connection);
  402.         }

  404.         return exist;
  405.     }

  407.     /**
  408.      * 
  409.      * @param nome Nome dell'operation
  410.      * @param idPortType L'identificativo del PortType
  411.      * @return true se esiste, false altrimenti.
  412.      * @throws DriverRegistroServiziException
  413.      */
  414.     protected boolean existsAccordoServizioParteComunePorttypeOperation(String nome, IDPortType idPortType) throws DriverRegistroServiziException {
  415.         Connection connection;
  416.         if (this.driver.atomica) {
  417.             try {
  418.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComunePorttypeOperation(nome,idPortType)");
  419.             } catch (Exception e) {
  420.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComunePorttypeOperation] Exception accedendo al datasource :" + e.getMessage(),e);

  422.             }

  424.         } else
  425.             connection = this.driver.globalConnection;

  427.         try {
  428.             long idAccordo = DBUtils.getIdAccordoServizioParteComune(idPortType.getIdAccordo(), connection, this.driver.tipoDB);
  429.             return existsAccordoServizioParteComunePorttypeOperation(nome, DBUtils.getIdPortType(idAccordo,idPortType.getNome(), connection));
  430.         }catch (Exception e) {
  431.             throw new DriverRegistroServiziException(e.getMessage(),e);
  432.         } finally {
  433.             this.driver.closeConnection(connection);
  434.         }
  435.     }

  437.     /**
  438.      * Verifica l'esistenza di un operation in un port-type
  439.      * 
  440.      * @param nome
  441.      *                dell'operation da verificare
  442.      * @param idPortType
  443.      *                del port-type
  444.      * @return true se l'operation esiste, false altrimenti
  445.      */
  446.     protected boolean existsAccordoServizioParteComunePorttypeOperation(String nome, long idPortType) throws DriverRegistroServiziException {

  448.         boolean exist = false;
  449.         Connection connection;
  450.         PreparedStatement stm = null;
  451.         ResultSet rs = null;
  452.         if (this.driver.atomica) {
  453.             try {
  454.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComunePorttypeOperation(nome,longId)");
  455.             } catch (Exception e) {
  456.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComunePorttypeOperation] Exception accedendo al datasource :" + e.getMessage(),e);

  458.             }

  460.         } else
  461.             connection = this.driver.globalConnection;

  463.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  464.         try {
  465.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  466.             sqlQueryObject.addFromTable(CostantiDB.PORT_TYPE_AZIONI);
  467.             sqlQueryObject.addSelectField("*");
  468.             sqlQueryObject.addWhereCondition("id_port_type = ?");
  469.             sqlQueryObject.addWhereCondition("nome = ?");
  470.             sqlQueryObject.setANDLogicOperator(true);
  471.             String sqlQuery = sqlQueryObject.createSQLQuery();
  472.             stm = connection.prepareStatement(sqlQuery);
  473.             stm.setLong(1, idPortType);
  474.             stm.setString(2, nome);
  475.             rs = stm.executeQuery();
  476.             if (rs.next())
  477.                 exist = true;
  478.             rs.close();
  479.             stm.close();
  480.         } catch (Exception e) {
  481.             exist = false;
  482.             throw new DriverRegistroServiziException(e.getMessage(),e);
  483.         } finally {

  485.             //Chiudo statement and resultset
  486.             JDBCUtilities.closeResources(rs, stm);

  488.             this.driver.closeConnection(connection);
  489.         }

  491.         return exist;
  492.     }
  493.     
  494.     
  495.     /**
  496.      * Verifica l'esistenza di un risorsa con determinato nome in un accordo
  497.      * 
  498.      * @param nome
  499.      *                del port-type da verificare
  500.      * @param idAccordo
  501.      *                dell'accordo
  502.      * @return true se il port-type esiste, false altrimenti
  503.      */
  504.     protected boolean existsAccordoServizioParteComuneResource(String nome, long idAccordo) throws DriverRegistroServiziException {

  506.         boolean exist = false;
  507.         Connection connection;
  508.         PreparedStatement stm = null;
  509.         ResultSet rs = null;
  510.         if (this.driver.atomica) {
  511.             try {
  512.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComuneResource(nome,idAccordo)");
  513.             } catch (Exception e) {
  514.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComuneResource] Exception accedendo al datasource :" + e.getMessage(),e);

  516.             }

  518.         } else
  519.             connection = this.driver.globalConnection;

  521.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  522.         try {
  523.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  524.             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  525.             sqlQueryObject.addSelectField("*");
  526.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  527.             sqlQueryObject.addWhereCondition("nome = ?");
  528.             sqlQueryObject.setANDLogicOperator(true);
  529.             String sqlQuery = sqlQueryObject.createSQLQuery();
  530.             stm = connection.prepareStatement(sqlQuery);
  531.             stm.setLong(1, idAccordo);
  532.             stm.setString(2, nome);
  533.             rs = stm.executeQuery();
  534.             if (rs.next())
  535.                 exist = true;
  536.             rs.close();
  537.             stm.close();
  538.         } catch (Exception e) {
  539.             exist = false;
  540.             throw new DriverRegistroServiziException(e.getMessage(),e);
  541.         } finally {

  543.             //Chiudo statement and resultset
  544.             JDBCUtilities.closeResources(rs, stm);

  546.             this.driver.closeConnection(connection);
  547.         }

  549.         return exist;
  550.     }
  551.     
  552.     protected boolean existsAccordoServizioParteComuneResource(String httpMethod, String path, long idAccordo, String excludeResourceWithName) throws DriverRegistroServiziException {

  554.         boolean exist = false;
  555.         Connection connection;
  556.         PreparedStatement stm = null;
  557.         ResultSet rs = null;
  558.         if (this.driver.atomica) {
  559.             try {
  560.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioParteComuneResource(httpMethod,path,idAccordo)");
  561.             } catch (Exception e) {
  562.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioParteComuneResource] Exception accedendo al datasource :" + e.getMessage(),e);

  564.             }

  566.         } else
  567.             connection = this.driver.globalConnection;

  569.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  570.         try {
  571.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  572.             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES);
  573.             sqlQueryObject.addSelectField("*");
  574.             sqlQueryObject.addWhereCondition("id_accordo = ?");
  575.             sqlQueryObject.addWhereCondition("http_method = ?");
  576.             sqlQueryObject.addWhereCondition("path = ?");
  577.             if(excludeResourceWithName!=null && !"".equals(excludeResourceWithName)) {
  578.                 sqlQueryObject.addWhereCondition("nome <> ?");
  579.             }
  580.             sqlQueryObject.setANDLogicOperator(true);
  581.             String sqlQuery = sqlQueryObject.createSQLQuery();
  582.             stm = connection.prepareStatement(sqlQuery);
  583.             stm.setLong(1, idAccordo);
  584.             if(httpMethod==null || "".equals(httpMethod)) {
  585.                 stm.setString(2, CostantiDB.API_RESOURCE_HTTP_METHOD_ALL_VALUE);
  586.             }
  587.             else {
  588.                 stm.setString(2, httpMethod);
  589.             }
  590.             if(path==null || "".equals(path)) {
  591.                 stm.setString(3, CostantiDB.API_RESOURCE_PATH_ALL_VALUE);
  592.             }
  593.             else {
  594.                 stm.setString(3, path);
  595.             }
  596.             if(excludeResourceWithName!=null && !"".equals(excludeResourceWithName)) {
  597.                 stm.setString(4, excludeResourceWithName);
  598.             }
  599.             rs = stm.executeQuery();
  600.             if (rs.next())
  601.                 exist = true;
  602.             rs.close();
  603.             stm.close();
  604.         } catch (Exception e) {
  605.             exist = false;
  606.             throw new DriverRegistroServiziException(e.getMessage(),e);
  607.         } finally {

  609.             //Chiudo statement and resultset
  610.             JDBCUtilities.closeResources(rs, stm);

  612.             this.driver.closeConnection(connection);
  613.         }

  615.         return exist;
  616.     }
  617.     
  618.     /**
  619.      * Verifica l'esistenza di un response con Status in una Resource
  620.      * 
  621.      * @param httpStatus
  622.      *                 della response da verificare
  623.      * @param idRisorsa
  624.      *                della resource
  625.      * @return true se la risposta esiste, false altrimenti
  626.      */
  627.     protected boolean existsAccordoServizioResourceResponse(long idRisorsa, int httpStatus) throws DriverRegistroServiziException {

  629.         boolean exist = false;
  630.         Connection connection;
  631.         PreparedStatement stm = null;
  632.         ResultSet rs = null;
  633.         if (this.driver.atomica) {
  634.             try {
  635.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioResourceResponse(idRisorsa,httpStatus)");
  636.             } catch (Exception e) {
  637.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioResourceResponse] Exception accedendo al datasource :" + e.getMessage(),e);

  639.             }

  641.         } else
  642.             connection = this.driver.globalConnection;

  644.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  645.         try {
  646.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  647.             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES_RESPONSE);
  648.             sqlQueryObject.addSelectField("*");
  649.             sqlQueryObject.addWhereCondition("id_resource = ?");
  650.             sqlQueryObject.addWhereCondition("status = ?");
  651.             sqlQueryObject.setANDLogicOperator(true);
  652.             String sqlQuery = sqlQueryObject.createSQLQuery();
  653.             stm = connection.prepareStatement(sqlQuery);
  654.             stm.setLong(1, idRisorsa);
  655.             stm.setInt(2, httpStatus);
  656.             rs = stm.executeQuery();
  657.             if (rs.next())
  658.                 exist = true;
  659.             rs.close();
  660.             stm.close();
  661.         } catch (Exception e) {
  662.             exist = false;
  663.             throw new DriverRegistroServiziException(e.getMessage(),e);
  664.         } finally {

  666.             //Chiudo statement and resultset
  667.             JDBCUtilities.closeResources(rs, stm);

  669.             this.driver.closeConnection(connection);
  670.         }

  672.         return exist;
  673.     }
  674.     

  676.     protected boolean existsAccordoServizioResourceRepresentation(Long idRisorsa, boolean isRequest, Long idResponse, String mediaType) throws DriverRegistroServiziException {

  678.         boolean exist = false;
  679.         Connection connection;
  680.         PreparedStatement stm = null;
  681.         ResultSet rs = null;
  682.         if (this.driver.atomica) {
  683.             try {
  684.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioResourceRepresentation(idRisorsa,isRequest,idResponse,mediaType)");
  685.             } catch (Exception e) {
  686.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioResourceRepresentation] Exception accedendo al datasource :" + e.getMessage(),e);

  688.             }

  690.         } else
  691.             connection = this.driver.globalConnection;

  693.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  694.         try {
  695.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  696.             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES_MEDIA);
  697.             sqlQueryObject.addSelectField("*");
  698.             if(isRequest)
  699.                 sqlQueryObject.addWhereCondition("id_resource_media = ?");
  700.             else 
  701.                 sqlQueryObject.addWhereCondition("id_resource_response_media = ?");
  702.             sqlQueryObject.addWhereCondition("media_type = ?");
  703.             sqlQueryObject.setANDLogicOperator(true);
  704.             String sqlQuery = sqlQueryObject.createSQLQuery();
  705.             stm = connection.prepareStatement(sqlQuery);
  706.             if(isRequest)
  707.                 stm.setLong(1, idRisorsa);
  708.             else 
  709.                 stm.setLong(1, idResponse);
  710.             stm.setString(2, mediaType);
  711.             rs = stm.executeQuery();
  712.             if (rs.next())
  713.                 exist = true;
  714.             rs.close();
  715.             stm.close();
  716.         } catch (Exception e) {
  717.             exist = false;
  718.             throw new DriverRegistroServiziException(e.getMessage(),e);
  719.         } finally {

  721.             //Chiudo statement and resultset
  722.             JDBCUtilities.closeResources(rs, stm);

  724.             this.driver.closeConnection(connection);
  725.         }

  727.         return exist;
  728.     }
  729.     
  730.     protected boolean existsAccordoServizioResourceParameter(Long idRisorsa, boolean isRequest, Long idResponse, ParameterType tipo, String nome) throws DriverRegistroServiziException {

  732.         boolean exist = false;
  733.         Connection connection;
  734.         PreparedStatement stm = null;
  735.         ResultSet rs = null;
  736.         if (this.driver.atomica) {
  737.             try {
  738.                 connection = this.driver.getConnectionFromDatasource("existsAccordoServizioResourceRepresentation(idRisorsa,isRequest,idResponse,tipo,nome)");
  739.             } catch (Exception e) {
  740.                 throw new DriverRegistroServiziException("DriverRegistroServiziDB::existsAccordoServizioResourceRepresentation] Exception accedendo al datasource :" + e.getMessage(),e);

  742.             }

  744.         } else
  745.             connection = this.driver.globalConnection;

  747.         this.driver.logDebug("operazione atomica = " + this.driver.atomica);
  748.         try {
  749.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  750.             sqlQueryObject.addFromTable(CostantiDB.API_RESOURCES_PARAMETER);
  751.             sqlQueryObject.addSelectField("*");
  752.             if(isRequest)
  753.                 sqlQueryObject.addWhereCondition("id_resource_parameter = ?");
  754.             else 
  755.                 sqlQueryObject.addWhereCondition("id_resource_response_par = ?");
  756.             sqlQueryObject.addWhereCondition("tipo_parametro = ?");
  757.             sqlQueryObject.addWhereCondition("nome = ?");
  758.             sqlQueryObject.setANDLogicOperator(true);
  759.             String sqlQuery = sqlQueryObject.createSQLQuery();
  760.             stm = connection.prepareStatement(sqlQuery);
  761.             if(isRequest)
  762.                 stm.setLong(1, idRisorsa);
  763.             else 
  764.                 stm.setLong(1, idResponse);
  765.             stm.setString(2, tipo.toString());
  766.             stm.setString(3, nome);
  767.             rs = stm.executeQuery();
  768.             if (rs.next())
  769.                 exist = true;
  770.             rs.close();
  771.             stm.close();
  772.         } catch (Exception e) {
  773.             exist = false;
  774.             throw new DriverRegistroServiziException(e.getMessage(),e);
  775.         } finally {

  777.             //Chiudo statement and resultset
  778.             JDBCUtilities.closeResources(rs, stm);

  780.             this.driver.closeConnection(connection);
  781.         }

  783.         return exist;
  784.     }
  785. }
Created with JaCoCo 0.8.8.202204050719