DriverConfigurazioneDB_porteDriver.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;
  26. import java.util.ArrayList;
  27. import java.util.List;

  29. import org.openspcoop2.core.commons.DBUtils;
  30. import org.openspcoop2.core.commons.ISearch;
  31. import org.openspcoop2.core.commons.Liste;
  32. import org.openspcoop2.core.config.CorsConfigurazione;
  33. import org.openspcoop2.core.config.CorsConfigurazioneHeaders;
  34. import org.openspcoop2.core.config.CorsConfigurazioneMethods;
  35. import org.openspcoop2.core.config.CorsConfigurazioneOrigin;
  36. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  37. import org.openspcoop2.core.config.ResponseCachingConfigurazioneControl;
  38. import org.openspcoop2.core.config.ResponseCachingConfigurazioneHashGenerator;
  39. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  40. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  41. import org.openspcoop2.core.config.constants.StatoFunzionalitaCacheDigestQueryParameter;
  42. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.constants.CostantiDB;
  45. import org.openspcoop2.utils.date.DateManager;
  46. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  47. import org.openspcoop2.utils.sql.ISQLQueryObject;
  48. import org.openspcoop2.utils.sql.SQLObjectFactory;

  50. /**
  51.  * DriverConfigurazioneDB_porteDriver
  52.  * 
  53.  * 
  54.  * @author Sandra Giangrandi (sandra@link.it)
  55.  * @author Stefano Corallo (corallo@link.it)
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  */
  59. public class DriverConfigurazioneDB_porteDriver {

  61.     private DriverConfigurazioneDB driver = null;
  62.     
  63.     protected DriverConfigurazioneDB_porteDriver(DriverConfigurazioneDB driver) {
  64.         this.driver = driver;
  65.     }
  66.     
  67.     protected List<ResponseCachingConfigurazioneRegola> portaApplicativaResponseCachingConfigurazioneRegolaList(long idPA, ISearch ricerca) throws DriverConfigurazioneException {
  68.         int idLista = Liste.PORTE_APPLICATIVE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA;
  69.         String nomeMetodo = "portaApplicativaResponseCachingConfigurazioneRegolaList";
  70.         boolean delegata = false;
  71.         return getEngineResponseCachingConfigurazioneRegolaList(idPA, ricerca, idLista, nomeMetodo, delegata);
  72.     }
  73.     
  74.     protected List<ResponseCachingConfigurazioneRegola> portaDelegataResponseCachingConfigurazioneRegolaList(long idPD, ISearch ricerca) throws DriverConfigurazioneException {
  75.         String nomeMetodo = "portaDelegataResponseCachingConfigurazioneRegolaList";
  76.         int idLista = Liste.PORTE_DELEGATE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA;
  77.         boolean delegata = true;
  78.         return getEngineResponseCachingConfigurazioneRegolaList(idPD, ricerca, idLista, nomeMetodo, delegata);
  79.     }
  80.     
  81.     private List<ResponseCachingConfigurazioneRegola> getEngineResponseCachingConfigurazioneRegolaList(long idPA, ISearch ricerca, int idLista, String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  82.         int offset; 
  83.         int limit;
  84.         String queryString;

  86.         limit = ricerca.getPageSize(idLista);
  87.         offset = ricerca.getIndexIniziale(idLista);
  88.         
  89.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_CACHE_REGOLE : CostantiDB.PORTE_APPLICATIVE_CACHE_REGOLE;

  91.         Connection con = null;
  92.         PreparedStatement stmt = null;
  93.         ResultSet risultato = null;

  95.         if (this.driver.atomica) {
  96.             try {
  97.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  98.             } catch (Exception e) {
  99.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  101.             }

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

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

  108.         List<ResponseCachingConfigurazioneRegola> lista = new ArrayList<>();
  109.         try {
  110.             
  111.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  112.             sqlQueryObject.addFromTable(nomeTabella);
  113.             sqlQueryObject.addSelectCountField(nomeTabella+".id", "cont");
  114.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  115.             sqlQueryObject.setSelectDistinct(true);
  116.             sqlQueryObject.setANDLogicOperator(true);
  117.             queryString = sqlQueryObject.createSQLQuery();
  118.             stmt = con.prepareStatement(queryString);
  119.             stmt.setLong(1, idPA);

  121.             risultato = stmt.executeQuery();
  122.             if (risultato.next())
  123.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  124.             risultato.close();
  125.             stmt.close();

  127.             // ricavo le entries
  128.             if (limit == 0) // con limit
  129.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  130.             
  131.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  132.             sqlQueryObject.addFromTable(nomeTabella);
  133.             sqlQueryObject.addSelectField("id");
  134.             sqlQueryObject.addWhereCondition(nomeTabella+".id_porta=?");
  135.             sqlQueryObject.setSelectDistinct(true);
  136.             sqlQueryObject.setANDLogicOperator(true);
  137.             sqlQueryObject.addOrderBy(nomeTabella+".id");
  138.             sqlQueryObject.setSortType(true);
  139.             sqlQueryObject.setLimit(limit);
  140.             sqlQueryObject.setOffset(offset);
  141.             queryString = sqlQueryObject.createSQLQuery();
  142.             stmt = con.prepareStatement(queryString);
  143.             stmt.setLong(1, idPA);

  145.             risultato = stmt.executeQuery();

  147.             List<Long> idLong = new ArrayList<>();
  148.             while (risultato.next()) { 
  149.                 idLong.add(risultato.getLong("id"));
  150.             }
  151.             risultato.close();
  152.             stmt.close();
  153.             
  154.             if(!idLong.isEmpty()) {
  155.                 
  156.                 for (Long idLongRegola : idLong) {
  157.                     
  158.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  159.                     sqlQueryObject.addFromTable(nomeTabella);
  160.                     sqlQueryObject.addSelectField("*");
  161.                     sqlQueryObject.addWhereCondition(nomeTabella+".id=?");
  162.                     sqlQueryObject.setANDLogicOperator(true);
  163.                     queryString = sqlQueryObject.createSQLQuery();
  164.                     stmt = con.prepareStatement(queryString);
  165.                     stmt.setLong(1, idLongRegola);

  167.                     risultato = stmt.executeQuery();
  168.                     
  169.                     if(risultato.next()) {
  170.                     
  171.                         ResponseCachingConfigurazioneRegola regola = new ResponseCachingConfigurazioneRegola();
  172.                         
  173.                         regola.setId(risultato.getLong("id"));
  174.                         int statusMin = risultato.getInt("status_min");
  175.                         int statusMax = risultato.getInt("status_max");
  176.                         if(statusMin>0) {
  177.                             regola.setReturnCodeMin(statusMin);
  178.                         }
  179.                         if(statusMax>0) {
  180.                             regola.setReturnCodeMax(statusMax);
  181.                         }

  183.                         int fault = risultato.getInt("fault");
  184.                         if(CostantiDB.TRUE == fault) {
  185.                             regola.setFault(true);
  186.                         }
  187.                         else if(CostantiDB.FALSE == fault) {
  188.                             regola.setFault(false);
  189.                         }
  190.                         
  191.                         int cacheSeconds = risultato.getInt("cache_seconds");
  192.                         if(cacheSeconds>0) {
  193.                             regola.setCacheTimeoutSeconds(cacheSeconds);
  194.                         }

  196.                         lista.add(regola);
  197.                         
  198.                     }
  199.                     
  200.                     risultato.close();
  201.                     stmt.close();
  202.                 }
  203.                 
  204.             }

  206.         } catch (Exception qe) {
  207.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  208.         } finally {

  210.             //Chiudo statement and resultset
  211.             JDBCUtilities.closeResources(risultato, stmt);

  213.             this.driver.closeConnection(con);
  214.         }
  215.         
  216.         return lista;
  217.     }
  218.     
  219.     protected boolean existsPortaApplicativaResponseCachingConfigurazioneRegola(long idPA, Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException {
  220.         String nomeMetodo = "existsPortaApplicativaResponseCachingConfigurazioneRegola";
  221.         boolean delegata = false;
  222.         return existsResponseCachingConfigurazioneRegolaEngine(idPA, statusMin, statusMax, fault, nomeMetodo, delegata);
  223.     }
  224.     
  225.     protected boolean existsPortaDelegataResponseCachingConfigurazioneRegola(long idPA, Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException {
  226.         String nomeMetodo = "existsPortaDelegataResponseCachingConfigurazioneRegola";
  227.         boolean delegata = true;
  228.         return existsResponseCachingConfigurazioneRegolaEngine(idPA, statusMin, statusMax, fault, nomeMetodo, delegata);
  229.     }
  230.     
  231.     private boolean existsResponseCachingConfigurazioneRegolaEngine(long idPA, Integer statusMin, Integer statusMax, boolean fault,String nomeMetodo, boolean portaDelegata) throws DriverConfigurazioneException {
  232.         Connection con = null;
  233.         PreparedStatement stmt=null;
  234.         ResultSet risultato=null;
  235.         String queryString;
  236.         String nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_CACHE_REGOLE : CostantiDB.PORTE_APPLICATIVE_CACHE_REGOLE;

  238.         if (this.driver.atomica) {
  239.             try {
  240.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  241.             } catch (Exception e) {
  242.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  244.             }

  246.         } else
  247.             con = this.driver.globalConnection;

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

  251.         try {

  253.             int count = 0;
  254.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  255.             sqlQueryObject.addFromTable(nomeTabella);
  256.             sqlQueryObject.addSelectCountField(nomeTabella+".id", "cont");
  257.             sqlQueryObject.setANDLogicOperator(true);
  258.             
  259.             sqlQueryObject.addWhereCondition("id_porta = ?");
  260.             if(statusMin != null) {
  261.                 sqlQueryObject.addWhereCondition("status_min = ?");
  262.             } else {
  263.                 sqlQueryObject.addWhereIsNullCondition("status_min");
  264.             }
  265.             
  266.             if(statusMax != null) {
  267.                 sqlQueryObject.addWhereCondition("status_max = ?");
  268.             } else {
  269.                 sqlQueryObject.addWhereIsNullCondition("status_max");
  270.             }
  271.             
  272.             sqlQueryObject.addWhereCondition("fault = ?");
  273.             
  274.             queryString = sqlQueryObject.createSQLQuery();
  275.             stmt = con.prepareStatement(queryString);
  276.             int parameterIndex = 1;
  277.             stmt.setLong(parameterIndex ++, idPA);
  278.             if(statusMin != null)
  279.                 stmt.setInt(parameterIndex ++, statusMin);
  280.             if(statusMax != null)
  281.                 stmt.setInt(parameterIndex ++, statusMax);
  282.             if(fault) {
  283.                 stmt.setInt(parameterIndex ++, CostantiDB.TRUE);
  284.             } else {
  285.                 stmt.setInt(parameterIndex ++, CostantiDB.FALSE);
  286.             }
  287.             
  288.             risultato = stmt.executeQuery();
  289.             if (risultato.next())
  290.                 count = risultato.getInt(1);
  291.             risultato.close();
  292.             stmt.close();

  294.             return count > 0;

  296.         } catch (Exception qe) {
  297.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  298.         } finally {

  300.             //Chiudo statement and resultset
  301.             JDBCUtilities.closeResources(risultato, stmt);

  303.             this.driver.closeConnection(con);
  304.         }
  305.     }
  306.     
  307.     protected void readConfigurazioneCors(CorsConfigurazione configurazione, ResultSet rs) throws SQLException {
  308.         
  309.         String corsStato = rs.getString("cors_stato");
  310.         if(corsStato!=null && !"".equals(corsStato)) {
  311.             configurazione.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(corsStato));
  312.         }
  313.         
  314.         if(StatoFunzionalita.ABILITATO.equals(configurazione.getStato())) {
  315.             
  316.             String corsTipo = rs.getString("cors_tipo");
  317.             if(corsTipo!=null && !"".equals(corsTipo)) {
  318.                 configurazione.setTipo(DriverConfigurazioneDBLib.getEnumTipoGestioneCORS(corsTipo));
  319.             }
  320.             
  321.             if(TipoGestioneCORS.GATEWAY.equals(configurazione.getTipo())) {
  322.                 
  323.                 String corsAllAllowOrigins = rs.getString("cors_all_allow_origins");
  324.                 if(corsAllAllowOrigins!=null && !"".equals(corsAllAllowOrigins)) {
  325.                     configurazione.setAccessControlAllAllowOrigins(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(corsAllAllowOrigins));
  326.                 }
  327.                 if(StatoFunzionalita.DISABILITATO.equals(configurazione.getAccessControlAllAllowOrigins())) {
  328.                     List<String> l = DBUtils.convertToList(rs.getString("cors_allow_origins"));
  329.                     if(!l.isEmpty()) {
  330.                         configurazione.setAccessControlAllowOrigins(new CorsConfigurazioneOrigin());
  331.                     }
  332.                     for (String v : l) {
  333.                         configurazione.getAccessControlAllowOrigins().addOrigin(v);
  334.                     }
  335.                 }
  336.             
  337.                 String corsAllowCredentials = rs.getString("cors_allow_credentials");
  338.                 if(corsAllowCredentials!=null && !"".equals(corsAllowCredentials)) {
  339.                     configurazione.setAccessControlAllowCredentials(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(corsAllowCredentials));
  340.                 }
  341.                 
  342.                 int corsAllowMaxAge = rs.getInt("cors_allow_max_age");
  343.                 if(CostantiDB.TRUE == corsAllowMaxAge) {
  344.                     int corsAllowMaxAgeSeconds = rs.getInt("cors_allow_max_age_seconds");
  345.                     configurazione.setAccessControlMaxAge(corsAllowMaxAgeSeconds);
  346.                 }
  347.                 
  348.                 String corsAllAllowHeader = rs.getString("cors_all_allow_headers");
  349.                 if(corsAllAllowHeader!=null && !"".equals(corsAllAllowHeader)) {
  350.                     configurazione.setAccessControlAllAllowHeaders(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(corsAllAllowHeader));
  351.                 }
  352.                 if(StatoFunzionalita.DISABILITATO.equals(configurazione.getAccessControlAllAllowHeaders())) {
  353.                     List<String> l = DBUtils.convertToList(rs.getString("cors_allow_headers"));
  354.                     if(!l.isEmpty()) {
  355.                         configurazione.setAccessControlAllowHeaders(new CorsConfigurazioneHeaders());
  356.                     }
  357.                     for (String v : l) {
  358.                         configurazione.getAccessControlAllowHeaders().addHeader(v);
  359.                     }
  360.                 }
  361.                 
  362.                 String corsAllAllowMethods = rs.getString("cors_all_allow_methods");
  363.                 if(corsAllAllowMethods!=null && !"".equals(corsAllAllowMethods)) {
  364.                     configurazione.setAccessControlAllAllowMethods(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(corsAllAllowMethods));
  365.                 }
  366.                 if(StatoFunzionalita.DISABILITATO.equals(configurazione.getAccessControlAllAllowMethods())) {
  367.                     List<String> l = DBUtils.convertToList(rs.getString("cors_allow_methods"));
  368.                     if(!l.isEmpty()) {
  369.                         configurazione.setAccessControlAllowMethods(new CorsConfigurazioneMethods());
  370.                     }
  371.                     for (String v : l) {
  372.                         configurazione.getAccessControlAllowMethods().addMethod(v);
  373.                     }
  374.                 }
  375.                 
  376.                 List<String> l = DBUtils.convertToList(rs.getString("cors_allow_expose_headers"));
  377.                 if(!l.isEmpty()) {
  378.                     configurazione.setAccessControlExposeHeaders(new CorsConfigurazioneHeaders());
  379.                 }
  380.                 for (String v : l) {
  381.                     configurazione.getAccessControlExposeHeaders().addHeader(v);
  382.                 }
  383.             }
  384.             
  385.         }
  386.         
  387.     }
  388.     
  389.     protected void readResponseCaching(Long idPorta, boolean config, boolean portaDelegata, ResponseCachingConfigurazione configurazione, ResultSet rs, Connection con) throws Exception {
  390.         
  391.         String responseCacheStato = rs.getString("response_cache_stato");
  392.         if(responseCacheStato!=null && !"".equals(responseCacheStato)) {
  393.             configurazione.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(responseCacheStato));
  394.         }
  395.         
  396.         if(StatoFunzionalita.ABILITATO.equals(configurazione.getStato())) {
  397.     
  398.             int responseCacheSeconds = rs.getInt("response_cache_seconds");
  399.             if(responseCacheSeconds>0) {
  400.                 configurazione.setCacheTimeoutSeconds(responseCacheSeconds);
  401.             }
  402.             
  403.             long responseCacheMaxMsgBytes = rs.getLong("response_cache_max_msg_size");
  404.             if(responseCacheMaxMsgBytes>0) {
  405.                 configurazione.setMaxMessageSize(responseCacheMaxMsgBytes);
  406.             }
  407.             
  408.             configurazione.setHashGenerator(new ResponseCachingConfigurazioneHashGenerator());
  409.             
  410.             String responseCacheHashUrl = rs.getString("response_cache_hash_url");
  411.             if(responseCacheHashUrl!=null && !"".equals(responseCacheHashUrl)) {
  412.                 configurazione.getHashGenerator().setRequestUri(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(responseCacheHashUrl));
  413.             }
  414.             
  415.             String responseCacheHashQuery = rs.getString("response_cache_hash_query");
  416.             if(responseCacheHashQuery!=null && !"".equals(responseCacheHashQuery)) {
  417.                 configurazione.getHashGenerator().setQueryParameters(DriverConfigurazioneDBLib.getEnumStatoFunzionalitaCacheDigestQueryParameter(responseCacheHashQuery));
  418.             }
  419.             
  420.             if(StatoFunzionalitaCacheDigestQueryParameter.SELEZIONE_PUNTUALE.equals(configurazione.getHashGenerator().getQueryParameters())) {
  421.                 List<String> l = DBUtils.convertToList(rs.getString("response_cache_hash_query_list"));
  422.                 for (String v : l) {
  423.                     configurazione.getHashGenerator().addQueryParameter(v);
  424.                 }
  425.             }
  426.             
  427.             String responseCacheHashHeaders = rs.getString("response_cache_hash_headers");
  428.             if(responseCacheHashHeaders!=null && !"".equals(responseCacheHashHeaders)) {
  429.                 configurazione.getHashGenerator().setHeaders(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(responseCacheHashHeaders));
  430.             }
  431.             
  432.             if(StatoFunzionalita.ABILITATO.equals(configurazione.getHashGenerator().getHeaders())) {
  433.                 List<String> l = DBUtils.convertToList(rs.getString("response_cache_hash_hdr_list"));
  434.                 for (String v : l) {
  435.                     configurazione.getHashGenerator().addHeader(v);
  436.                 }
  437.             }
  438.             
  439.             String responseCacheHashPayload = rs.getString("response_cache_hash_payload");
  440.             if(responseCacheHashPayload!=null && !"".equals(responseCacheHashPayload)) {
  441.                 configurazione.getHashGenerator().setPayload(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(responseCacheHashPayload));
  442.             }
  443.             
  444.             configurazione.setControl(new ResponseCachingConfigurazioneControl());
  445.             
  446.             int responseCacheControlNoCache = rs.getInt("response_cache_control_nocache");
  447.             if(CostantiDB.TRUE == responseCacheControlNoCache) {
  448.                 configurazione.getControl().setNoCache(true);
  449.             }
  450.             else if(CostantiDB.FALSE == responseCacheControlNoCache) {
  451.                 configurazione.getControl().setNoCache(false);
  452.             }
  453.             
  454.             int responseCacheControlMaxAge = rs.getInt("response_cache_control_maxage");
  455.             if(CostantiDB.TRUE == responseCacheControlMaxAge) {
  456.                 configurazione.getControl().setMaxAge(true);
  457.             }
  458.             else if(CostantiDB.FALSE == responseCacheControlMaxAge) {
  459.                 configurazione.getControl().setMaxAge(false);
  460.             }
  461.             
  462.             int responseCacheControlNoStore = rs.getInt("response_cache_control_nostore");
  463.             if(CostantiDB.TRUE == responseCacheControlNoStore) {
  464.                 configurazione.getControl().setNoStore(true);
  465.             }
  466.             else if(CostantiDB.FALSE == responseCacheControlNoStore) {
  467.                 configurazione.getControl().setNoStore(false);
  468.             }
  469.             
  470.             PreparedStatement stmRegole = null;
  471.             ResultSet rsRegole = null;
  472.             try {
  473.                 String nomeTabella = null;
  474.                 if(config) {
  475.                     nomeTabella = CostantiDB.CONFIGURAZIONE_CACHE_REGOLE;
  476.                 }
  477.                 else {
  478.                     nomeTabella = portaDelegata ? CostantiDB.PORTE_DELEGATE_CACHE_REGOLE : CostantiDB.PORTE_APPLICATIVE_CACHE_REGOLE;
  479.                 }
  480.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  481.                 sqlQueryObject.addFromTable(nomeTabella);
  482.                 sqlQueryObject.addSelectField("*");
  483.                 if(!config) {
  484.                     sqlQueryObject.addWhereCondition("id_porta=?");
  485.                 }
  486.                 String sqlQuery = sqlQueryObject.createSQLQuery();
  487.                 stmRegole = con.prepareStatement(sqlQuery);
  488.                 if(!config) {
  489.                     stmRegole.setLong(1, idPorta);
  490.                 }
  491.         
  492.                 this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, idPorta));
  493.                 rsRegole = stmRegole.executeQuery();
  494.         
  495.                 while (rsRegole.next()) {
  496.                 
  497.                     ResponseCachingConfigurazioneRegola regola = new ResponseCachingConfigurazioneRegola();
  498.                     
  499.                     regola.setId(rsRegole.getLong("id"));
  500.                     int statusMin = rsRegole.getInt("status_min");
  501.                     int statusMax = rsRegole.getInt("status_max");
  502.                     if(statusMin>0) {
  503.                         regola.setReturnCodeMin(statusMin);
  504.                     }
  505.                     if(statusMax>0) {
  506.                         regola.setReturnCodeMax(statusMax);
  507.                     }

  509.                     int fault = rsRegole.getInt("fault");
  510.                     if(CostantiDB.TRUE == fault) {
  511.                         regola.setFault(true);
  512.                     }
  513.                     else if(CostantiDB.FALSE == fault) {
  514.                         regola.setFault(false);
  515.                     }
  516.                     
  517.                     int cacheSeconds = rsRegole.getInt("cache_seconds");
  518.                     if(cacheSeconds>0) {
  519.                         regola.setCacheTimeoutSeconds(cacheSeconds);
  520.                     }
  521.                     
  522.                     configurazione.addRegola(regola);
  523.                     
  524.                 }
  525.                 
  526.                 
  527.             }finally {
  528.                 JDBCUtilities.closeResources(rsRegole, stmRegole);
  529.             }
  530.         }

  532.     }
  533.     
  534.     
  535.     protected void updateProprietaOggetto(String nome, String user, String tabella) throws DriverConfigurazioneException {
  536.         
  537.         String nomeMetodo = "updateProprietaOggetto_"+tabella;
  538.         
  539.         Connection con = null;
  540.         if (this.driver.atomica) {
  541.             try {
  542.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  543.             } catch (Exception e) {
  544.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  546.             }

  548.         } else
  549.             con = this.driver.globalConnection;

  551.         this.driver.logDebug("operazione this.driver.atomica = " + this.driver.atomica);
  552.         
  553.         PreparedStatement stm = null;
  554.         try {

  556.             ISQLQueryObject sqlQueryObjectUpdate = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  557.             sqlQueryObjectUpdate.addUpdateTable(tabella);
  558.             sqlQueryObjectUpdate.addUpdateField("utente_ultima_modifica", "?");
  559.             sqlQueryObjectUpdate.addUpdateField("data_ultima_modifica", "?");
  560.             sqlQueryObjectUpdate.addWhereCondition("nome_porta=?");
  561.             String updateString = sqlQueryObjectUpdate.createSQLUpdate();
  562.             stm = con.prepareStatement(updateString);
  563.             int index = 1;
  564.             stm.setString(index++, user);
  565.             stm.setTimestamp(index++, DateManager.getTimestamp());
  566.             stm.setString(index, nome);
  567.             int n=stm.executeUpdate();
  568.             stm.close();
  569.             this.driver.logDebug("Aggiornata "+n+" entry per l'operazione di ultima modifica della tabella '"+tabella+"' con nome: "+nome);
  570.         } catch (SQLException e) {
  571.             this.driver.logError("Errore SQL", e);
  572.             throw new DriverConfigurazioneException(e);
  573.         }catch (Exception e) {
  574.             this.driver.logError("Errore", e);
  575.             throw new DriverConfigurazioneException(e);
  576.         } finally {
  577.             JDBCUtilities.closeResources(stm);

  579.             this.driver.closeConnection(con);
  580.         }
  581.     }
  582. }
Created with JaCoCo 0.8.8.202204050719