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

  28. import org.apache.commons.lang.StringUtils;
  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.AccessoRegistroRegistro;
  33. import org.openspcoop2.core.config.CanaleConfigurazione;
  34. import org.openspcoop2.core.config.CanaleConfigurazioneNodo;
  35. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  36. import org.openspcoop2.core.config.IdSoggetto;
  37. import org.openspcoop2.core.config.Property;
  38. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  39. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  40. import org.openspcoop2.core.config.constants.RegistroTipo;
  41. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  42. import org.openspcoop2.core.config.constants.StatoFunzionalitaConPersonalizzazione;
  43. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  44. import org.openspcoop2.core.constants.CostantiDB;
  45. import org.openspcoop2.core.id.IDSoggetto;
  46. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  47. import org.openspcoop2.utils.sql.ISQLQueryObject;
  48. import org.openspcoop2.utils.sql.SQLObjectFactory;

  50. /**
  51.  * DriverConfigurazioneDB_configSearchDriver
  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_configSearchDriver {

  61.     private DriverConfigurazioneDB driver = null;
  62.     
  63.     protected DriverConfigurazioneDB_configSearchDriver(DriverConfigurazioneDB driver) {
  64.         this.driver = driver;
  65.     }
  66.     
  67.     protected List<Property> systemPropertyList(ISearch ricerca) throws DriverConfigurazioneException {
  68.         String nomeMetodo = "systemPropertyList";
  69.         int idLista = Liste.SYSTEM_PROPERTIES;

  71.         int offset;
  72.         int limit;
  73.         String search;
  74.         String queryString;
  75.         limit = ricerca.getPageSize(idLista);
  76.         offset = ricerca.getIndexIniziale(idLista);
  77.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));


  80.         Connection con = null;
  81.         PreparedStatement stmt=null;
  82.         ResultSet risultato=null;
  83.         ArrayList<Property> lista = new ArrayList<>();

  85.         if (this.driver.atomica) {
  86.             try {
  87.                 con = this.driver.getConnectionFromDatasource("systemPropertyList");
  88.             } catch (Exception e) {
  89.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  91.             }

  93.         } else
  94.             con = this.driver.globalConnection;

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

  98.         try {

  100.             if (!search.equals("")) {
  101.                 //query con search
  102.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  103.                 sqlQueryObject.addFromTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  104.                 sqlQueryObject.addSelectCountField("*", "cont");
  105.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  106.                 sqlQueryObject.setANDLogicOperator(true);
  107.                 queryString = sqlQueryObject.createSQLQuery();
  108.             } else {
  109.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  110.                 sqlQueryObject.addFromTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  111.                 sqlQueryObject.addSelectCountField("*", "cont");
  112.                 queryString = sqlQueryObject.createSQLQuery();
  113.             }
  114.             stmt = con.prepareStatement(queryString);
  115.             risultato = stmt.executeQuery();
  116.             if (risultato.next())
  117.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  118.             risultato.close();
  119.             stmt.close();

  121.             // ricavo le entries
  122.             if (limit == 0) // con limit
  123.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  124.             if (!search.equals("")) { // con search
  125.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  126.                 sqlQueryObject.addFromTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  127.                 sqlQueryObject.addSelectField("id");
  128.                 sqlQueryObject.addSelectField("nome");
  129.                 sqlQueryObject.addSelectField("valore");
  130.                 sqlQueryObject.addSelectField("enc_value");
  131.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  132.                 sqlQueryObject.setANDLogicOperator(true);
  133.                 sqlQueryObject.addOrderBy("nome");
  134.                 sqlQueryObject.setSortType(true);
  135.                 sqlQueryObject.setLimit(limit);
  136.                 sqlQueryObject.setOffset(offset);
  137.                 queryString = sqlQueryObject.createSQLQuery();
  138.             } else {
  139.                 // senza search
  140.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  141.                 sqlQueryObject.addFromTable(CostantiDB.SYSTEM_PROPERTIES_PDD);
  142.                 sqlQueryObject.addSelectField("id");
  143.                 sqlQueryObject.addSelectField("nome");
  144.                 sqlQueryObject.addSelectField("valore");
  145.                 sqlQueryObject.addSelectField("enc_value");
  146.                 sqlQueryObject.addOrderBy("nome");
  147.                 sqlQueryObject.setSortType(true);
  148.                 sqlQueryObject.setLimit(limit);
  149.                 sqlQueryObject.setOffset(offset);
  150.                 queryString = sqlQueryObject.createSQLQuery();
  151.             }
  152.             stmt = con.prepareStatement(queryString);
  153.             risultato = stmt.executeQuery();

  155.             Property sp;
  156.             while (risultato.next()) {

  158.                 sp = new Property();

  160.                 sp.setId(risultato.getLong("id"));
  161.                 sp.setNome(risultato.getString("nome"));
  162.                 
  163.                 String plainValue = risultato.getString("valore");
  164.                 String encValue = risultato.getString("enc_value");
  165.                 if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  166.                     sp.setValore(encValue);
  167.                 }
  168.                 else {
  169.                     sp.setValore(plainValue);
  170.                 }

  172.                 lista.add(sp);
  173.             }

  175.             return lista;

  177.         } catch (Exception qe) {
  178.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  179.         } finally {

  181.             //Chiudo statement and resultset
  182.             JDBCUtilities.closeResources(risultato, stmt);

  184.             this.driver.closeConnection(con);
  185.         }
  186.     }
  187.     
  188.     protected List<AccessoRegistroRegistro> registriList(ISearch ricerca) throws DriverConfigurazioneException {
  189.         String nomeMetodo = "registriList";
  190.         int idLista = Liste.REGISTRI;
  191.         int offset;
  192.         int limit;
  193.         String search;
  194.         String queryString;

  196.         limit = ricerca.getPageSize(idLista);
  197.         offset = ricerca.getIndexIniziale(idLista);
  198.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));


  201.         Connection con = null;
  202.         PreparedStatement stmt=null;
  203.         ResultSet risultato=null;
  204.         ArrayList<AccessoRegistroRegistro> lista = new ArrayList<>();

  206.         if (this.driver.atomica) {
  207.             try {
  208.                 con = this.driver.getConnectionFromDatasource("registriList");
  209.             } catch (Exception e) {
  210.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  212.             }

  214.         } else
  215.             con = this.driver.globalConnection;

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

  219.         try {

  221.             if (!search.equals("")) {
  222.                 //query con search
  223.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  224.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  225.                 sqlQueryObject.addSelectCountField("*", "cont");
  226.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  227.                 queryString = sqlQueryObject.createSQLQuery();
  228.             } else {
  229.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  230.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  231.                 sqlQueryObject.addSelectCountField("*", "cont");
  232.                 queryString = sqlQueryObject.createSQLQuery();
  233.             }
  234.             stmt = con.prepareStatement(queryString);
  235.             risultato = stmt.executeQuery();
  236.             if (risultato.next())
  237.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  238.             risultato.close();
  239.             stmt.close();

  241.             // ricavo le entries
  242.             if (limit == 0) // con limit
  243.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  245.             if (!search.equals("")) { // con search
  246.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  247.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  248.                 sqlQueryObject.addSelectField("id");
  249.                 sqlQueryObject.addSelectField("nome");
  250.                 sqlQueryObject.addSelectField("tipo");
  251.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  252.                 sqlQueryObject.addOrderBy("nome");
  253.                 sqlQueryObject.setSortType(true);
  254.                 sqlQueryObject.setLimit(limit);
  255.                 sqlQueryObject.setOffset(offset);
  256.                 queryString = sqlQueryObject.createSQLQuery();
  257.             } else {
  258.                 // senza search
  259.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  260.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  261.                 sqlQueryObject.addSelectField("id");
  262.                 sqlQueryObject.addSelectField("nome");
  263.                 sqlQueryObject.addSelectField("tipo");
  264.                 sqlQueryObject.addOrderBy("nome");
  265.                 sqlQueryObject.setSortType(true);
  266.                 sqlQueryObject.setLimit(limit);
  267.                 sqlQueryObject.setOffset(offset);
  268.                 queryString = sqlQueryObject.createSQLQuery();
  269.             }
  270.             stmt = con.prepareStatement(queryString);
  271.             risultato = stmt.executeQuery();

  273.             AccessoRegistroRegistro arr;
  274.             while (risultato.next()) {

  276.                 arr = new AccessoRegistroRegistro();

  278.                 arr.setId(risultato.getLong("id"));
  279.                 arr.setNome(risultato.getString("nome"));
  280.                 arr.setTipo(RegistroTipo.toEnumConstant(risultato.getString("tipo")));

  282.                 lista.add(arr);
  283.             }

  285.             return lista;

  287.         } catch (Exception qe) {
  288.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  289.         } finally {

  291.             //Chiudo statement and resultset
  292.             JDBCUtilities.closeResources(risultato, stmt);

  294.             this.driver.closeConnection(con);
  295.         }
  296.     }
  297.     
  298.     protected List<ResponseCachingConfigurazioneRegola> responseCachingConfigurazioneRegolaList(ISearch ricerca) throws DriverConfigurazioneException {
  299.         String nomeMetodo = "responseCachingConfigurazioneRegolaList";
  300.         int idLista = Liste.CONFIGURAZIONE_RESPONSE_CACHING_CONFIGURAZIONE_REGOLA;
  301.         int offset;
  302.         int limit;
  303.         String queryString;

  305.         limit = ricerca.getPageSize(idLista);
  306.         offset = ricerca.getIndexIniziale(idLista);

  308.         Connection con = null;
  309.         PreparedStatement stmt=null;
  310.         ResultSet risultato=null;
  311.         ArrayList<ResponseCachingConfigurazioneRegola> lista = new ArrayList<>();

  313.         if (this.driver.atomica) {
  314.             try {
  315.                 con = this.driver.getConnectionFromDatasource("responseCachingConfigurazioneRegolaList");
  316.             } catch (Exception e) {
  317.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  319.             }

  321.         } else
  322.             con = this.driver.globalConnection;

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

  326.         try {

  328.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  329.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  330.             sqlQueryObject.addSelectCountField("id", "cont");
  331.             queryString = sqlQueryObject.createSQLQuery();
  332.             stmt = con.prepareStatement(queryString);
  333.             risultato = stmt.executeQuery();
  334.             if (risultato.next())
  335.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  336.             risultato.close();
  337.             stmt.close();

  339.             // ricavo le entries
  340.             if (limit == 0) // con limit
  341.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  343.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  344.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  345.             sqlQueryObject.addSelectField("id");
  346.             sqlQueryObject.addOrderBy("id");
  347.             sqlQueryObject.setSortType(true);
  348.             sqlQueryObject.setLimit(limit);
  349.             sqlQueryObject.setOffset(offset);
  350.             queryString = sqlQueryObject.createSQLQuery();
  351.             stmt = con.prepareStatement(queryString);
  352.             risultato = stmt.executeQuery();

  354.             List<Long> idLong = new ArrayList<>();
  355.             while (risultato.next()) { 
  356.                 idLong.add(risultato.getLong("id"));
  357.             }
  358.             risultato.close();
  359.             stmt.close();
  360.             
  361.             if(!idLong.isEmpty()) {
  362.                 
  363.                 for (Long idLongRegola : idLong) {
  364.                     
  365.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  366.                     sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CACHE_REGOLE);
  367.                     sqlQueryObject.addSelectField("id");
  368.                     sqlQueryObject.addSelectField("status_min");
  369.                     sqlQueryObject.addSelectField("status_max");
  370.                     sqlQueryObject.addSelectField("fault");
  371.                     sqlQueryObject.addSelectField("cache_seconds");
  372.                     sqlQueryObject.addWhereCondition("id=?");
  373.                     queryString = sqlQueryObject.createSQLQuery();
  374.                     stmt = con.prepareStatement(queryString);
  375.                     stmt.setLong(1, idLongRegola);
  376.                     risultato = stmt.executeQuery();
  377.                     
  378.                     if(risultato.next()) {
  379.                         ResponseCachingConfigurazioneRegola regola = new ResponseCachingConfigurazioneRegola();
  380.                         
  381.                         regola.setId(risultato.getLong("id"));
  382.                         int status_min = risultato.getInt("status_min");
  383.                         int status_max = risultato.getInt("status_max");
  384.                         if(status_min>0) {
  385.                             regola.setReturnCodeMin(status_min);
  386.                         }
  387.                         if(status_max>0) {
  388.                             regola.setReturnCodeMax(status_max);
  389.                         }

  391.                         int fault = risultato.getInt("fault");
  392.                         if(CostantiDB.TRUE == fault) {
  393.                             regola.setFault(true);
  394.                         }
  395.                         else if(CostantiDB.FALSE == fault) {
  396.                             regola.setFault(false);
  397.                         }
  398.                         
  399.                         int cacheSeconds = risultato.getInt("cache_seconds");
  400.                         if(cacheSeconds>0) {
  401.                             regola.setCacheTimeoutSeconds(cacheSeconds);
  402.                         }

  404.                         lista.add(regola);
  405.                     }
  406.                     
  407.                     risultato.close();
  408.                     stmt.close();
  409.                 }
  410.                 
  411.             }
  412.             
  413.             return lista;

  415.         } catch (Exception qe) {
  416.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  417.         } finally {

  419.             //Chiudo statement and resultset
  420.             JDBCUtilities.closeResources(risultato, stmt);

  422.             this.driver.closeConnection(con);
  423.         }
  424.     }
  425.     
  426.     protected List<ConfigurazioneUrlInvocazioneRegola> proxyPassConfigurazioneRegolaList(ISearch ricerca) throws DriverConfigurazioneException {
  427.         String nomeMetodo = "proxyPassConfigurazioneRegolaList";
  428.         int idLista = Liste.CONFIGURAZIONE_PROXY_PASS_REGOLA;
  429.         int offset;
  430.         int limit;
  431.         String queryString;
  432.         String search;

  434.         limit = ricerca.getPageSize(idLista);
  435.         offset = ricerca.getIndexIniziale(idLista);
  436.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  438.         Connection con = null;
  439.         PreparedStatement stmt=null;
  440.         ResultSet risultato=null;
  441.         ArrayList<ConfigurazioneUrlInvocazioneRegola> lista = new ArrayList<>();

  443.         if (this.driver.atomica) {
  444.             try {
  445.                 con = this.driver.getConnectionFromDatasource("responseCachingConfigurazioneRegolaList");
  446.             } catch (Exception e) {
  447.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  449.             }

  451.         } else
  452.             con = this.driver.globalConnection;

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

  456.         try {

  458.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  459.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  460.             sqlQueryObject.addSelectCountField("id", "cont");
  461.             
  462.             if (!search.equals("")) {
  463.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  464.             }
  465.             
  466.             queryString = sqlQueryObject.createSQLQuery();
  467.             stmt = con.prepareStatement(queryString);
  468.             risultato = stmt.executeQuery();
  469.             if (risultato.next())
  470.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  471.             risultato.close();
  472.             stmt.close();

  474.             // ricavo le entries
  475.             if (limit == 0) // con limit
  476.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  478.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  479.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_URL_REGOLE);
  480.             sqlQueryObject.addSelectField("id");
  481.             sqlQueryObject.addSelectField("nome");            
  482.             sqlQueryObject.addSelectField("posizione");       
  483.             sqlQueryObject.addSelectField("stato");           
  484.             sqlQueryObject.addSelectField("descrizione");     
  485.             sqlQueryObject.addSelectField("regexpr");         
  486.             sqlQueryObject.addSelectField("regola");          
  487.             sqlQueryObject.addSelectField("contesto_esterno");
  488.             sqlQueryObject.addSelectField("base_url");        
  489.             sqlQueryObject.addSelectField("protocollo");      
  490.             sqlQueryObject.addSelectField("ruolo");           
  491.             sqlQueryObject.addSelectField("service_binding"); 
  492.             sqlQueryObject.addSelectField("tipo_soggetto");   
  493.             sqlQueryObject.addSelectField("nome_soggetto");
  494.             
  495.             if (!search.equals("")) {
  496.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  497.             }
  498.             sqlQueryObject.addOrderBy("posizione");
  499.             sqlQueryObject.addOrderBy("nome");
  500.             sqlQueryObject.setSortType(true);
  501.             sqlQueryObject.setLimit(limit);
  502.             sqlQueryObject.setOffset(offset);
  503.             queryString = sqlQueryObject.createSQLQuery();
  504.             stmt = con.prepareStatement(queryString);
  505.             risultato = stmt.executeQuery();

  507.             
  508.             while (risultato.next()) { 
  509.                 ConfigurazioneUrlInvocazioneRegola regola = new ConfigurazioneUrlInvocazioneRegola();
  510.                 regola.setId(risultato.getLong("id"));
  511.                 regola.setNome(risultato.getString("nome"));
  512.                 regola.setPosizione(risultato.getInt("posizione"));
  513.                 regola.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(risultato.getString("stato")));
  514.                 regola.setDescrizione(risultato.getString("descrizione"));
  515.                 if(risultato.getInt("regexpr") == CostantiDB.TRUE) {
  516.                     regola.setRegexpr(true);
  517.                 }else {
  518.                     regola.setRegexpr(false);
  519.                 }
  520.                 regola.setRegola(risultato.getString("regola"));
  521.                 // Fix stringa vuota in Oracle, impostato dalla console e non accettato da Oracle che lo traduce in null e fa schiantare per via del NOT NULL sul db
  522.                 String s = risultato.getString("contesto_esterno");
  523.                 if(CostantiConfigurazione.REGOLA_PROXY_PASS_CONTESTO_VUOTO.equals(s)) {
  524.                     s = "";
  525.                 }
  526.                 regola.setContestoEsterno(s);
  527.                 regola.setBaseUrl(risultato.getString("base_url"));
  528.                 regola.setProtocollo(risultato.getString("protocollo"));
  529.                 regola.setRuolo(DriverConfigurazioneDBLib.getEnumRuoloContesto(risultato.getString("ruolo")));
  530.                 regola.setServiceBinding(DriverConfigurazioneDBLib.getEnumServiceBinding(risultato.getString("service_binding")));
  531.                 String tipoSoggetto = risultato.getString("tipo_soggetto");
  532.                 String nomeSoggetto = risultato.getString("nome_soggetto");
  533.                 if(tipoSoggetto!=null && !"".equals(tipoSoggetto) && nomeSoggetto!=null && !"".equals(nomeSoggetto)) {
  534.                     regola.setSoggetto(new IdSoggetto(new IDSoggetto(tipoSoggetto, nomeSoggetto)));
  535.                 }
  536.                 
  537.                 lista.add(regola);
  538.             
  539.             }
  540.             risultato.close();
  541.             stmt.close();
  542.             
  543.             return lista;

  545.         } catch (Exception qe) {
  546.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  547.         } finally {

  549.             //Chiudo statement and resultset
  550.             JDBCUtilities.closeResources(risultato, stmt);

  552.             this.driver.closeConnection(con);
  553.         }
  554.     }
  555.     
  556.     protected List<CanaleConfigurazione> canaleConfigurazioneList(ISearch ricerca) throws DriverConfigurazioneException {
  557.         String nomeMetodo = "canaleConfigurazioneList";
  558.         int idLista = Liste.CONFIGURAZIONE_CANALI;
  559.         int offset;
  560.         int limit;
  561.         String queryString;
  562.         String search;

  564.         limit = ricerca.getPageSize(idLista);
  565.         offset = ricerca.getIndexIniziale(idLista);
  566.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  568.         Connection con = null;
  569.         PreparedStatement stmt=null;
  570.         ResultSet risultato=null;
  571.         ArrayList<CanaleConfigurazione> lista = new ArrayList<>();

  573.         if (this.driver.atomica) {
  574.             try {
  575.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  576.             } catch (Exception e) {
  577.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  579.             }

  581.         } else
  582.             con = this.driver.globalConnection;

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

  586.         try {

  588.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  589.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI);
  590.             sqlQueryObject.addSelectCountField("id", "cont");
  591.             
  592.             if (!search.equals("")) {
  593.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  594.             }
  595.             
  596.             queryString = sqlQueryObject.createSQLQuery();
  597.             stmt = con.prepareStatement(queryString);
  598.             risultato = stmt.executeQuery();
  599.             if (risultato.next())
  600.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  601.             risultato.close();
  602.             stmt.close();

  604.             // ricavo le entries
  605.             if (limit == 0) // con limit
  606.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  608.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  609.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI);
  610.             sqlQueryObject.addSelectField("id");
  611.             sqlQueryObject.addSelectField("nome");            
  612.             sqlQueryObject.addSelectField("descrizione");     
  613.             sqlQueryObject.addSelectField("canale_default");         
  614.             
  615.             if (!search.equals("")) {
  616.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  617.             }
  618.             sqlQueryObject.addOrderBy("nome");
  619.             sqlQueryObject.setSortType(true);
  620.             sqlQueryObject.setLimit(limit);
  621.             sqlQueryObject.setOffset(offset);
  622.             queryString = sqlQueryObject.createSQLQuery();
  623.             stmt = con.prepareStatement(queryString);
  624.             risultato = stmt.executeQuery();

  626.             
  627.             while (risultato.next()) { 
  628.                 CanaleConfigurazione canale = new CanaleConfigurazione();
  629.                 canale.setId(risultato.getLong("id"));
  630.                 canale.setNome(risultato.getString("nome"));
  631.                 canale.setDescrizione(risultato.getString("descrizione"));
  632.                 int v = risultato.getInt("canale_default");
  633.                 if(v == CostantiDB.TRUE) {
  634.                     canale.setCanaleDefault(true);
  635.                 }
  636.                 else {
  637.                     canale.setCanaleDefault(false);
  638.                 }
  639.                 
  640.                 lista.add(canale);
  641.             
  642.             }
  643.             risultato.close();
  644.             stmt.close();
  645.             
  646.             return lista;

  648.         } catch (Exception qe) {
  649.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  650.         } finally {

  652.             //Chiudo statement and resultset
  653.             JDBCUtilities.closeResources(risultato, stmt);

  655.             this.driver.closeConnection(con);
  656.         }
  657.     }
  658.     
  659.     protected List<CanaleConfigurazioneNodo> canaleNodoConfigurazioneList(ISearch ricerca) throws DriverConfigurazioneException { 
  660.         String nomeMetodo = "canaleNodoConfigurazioneList";
  661.         int idLista = Liste.CONFIGURAZIONE_CANALI_NODI;
  662.         int offset;
  663.         int limit;
  664.         String queryString;
  665.         String search;

  667.         limit = ricerca.getPageSize(idLista);
  668.         offset = ricerca.getIndexIniziale(idLista);
  669.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  671.         Connection con = null;
  672.         PreparedStatement stmt=null;
  673.         ResultSet risultato=null;
  674.         ArrayList<CanaleConfigurazioneNodo> lista = new ArrayList<>();

  676.         if (this.driver.atomica) {
  677.             try {
  678.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  679.             } catch (Exception e) {
  680.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  682.             }

  684.         } else
  685.             con = this.driver.globalConnection;

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

  689.         try {

  691.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  692.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI_NODI);
  693.             sqlQueryObject.addSelectCountField("id", "cont");
  694.             
  695.             if (!search.equals("")) {
  696.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  697.             }
  698.             
  699.             queryString = sqlQueryObject.createSQLQuery();
  700.             stmt = con.prepareStatement(queryString);
  701.             risultato = stmt.executeQuery();
  702.             if (risultato.next())
  703.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  704.             risultato.close();
  705.             stmt.close();

  707.             // ricavo le entries
  708.             if (limit == 0) // con limit
  709.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  711.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  712.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE_CANALI_NODI);
  713.             sqlQueryObject.addSelectField("id");
  714.             sqlQueryObject.addSelectField("nome");            
  715.             sqlQueryObject.addSelectField("descrizione");     
  716.             sqlQueryObject.addSelectField("canali");         
  717.             
  718.             if (!search.equals("")) {
  719.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  720.             }
  721.             sqlQueryObject.addOrderBy("nome");
  722.             sqlQueryObject.setSortType(true);
  723.             sqlQueryObject.setLimit(limit);
  724.             sqlQueryObject.setOffset(offset);
  725.             queryString = sqlQueryObject.createSQLQuery();
  726.             stmt = con.prepareStatement(queryString);
  727.             risultato = stmt.executeQuery();

  729.             
  730.             while (risultato.next()) { 
  731.                 CanaleConfigurazioneNodo canaleNodo = new CanaleConfigurazioneNodo();
  732.                 canaleNodo.setId(risultato.getLong("id"));
  733.                 canaleNodo.setNome(risultato.getString("nome"));
  734.                 canaleNodo.setDescrizione(risultato.getString("descrizione"));
  735.                 List<String> l = DBUtils.convertToList(risultato.getString("canali"));
  736.                 canaleNodo.setCanaleList(l);
  737.                 
  738.                 lista.add(canaleNodo);
  739.             
  740.             }
  741.             risultato.close();
  742.             stmt.close();
  743.             
  744.             return lista;

  746.         } catch (Exception qe) {
  747.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  748.         } finally {

  750.             //Chiudo statement and resultset
  751.             JDBCUtilities.closeResources(risultato, stmt);

  753.             this.driver.closeConnection(con);
  754.         }
  755.     }
  756.     
  757.     
  758.     
  759.     protected boolean existsFaseTracciamentoDBRequestIn(boolean erogazioni, boolean fruizioni) throws DriverConfigurazioneException { 
  760.         return existsFaseTracciamentoDB("existsFaseTracciamentoDBRequestIn", erogazioni, fruizioni,
  761.                 true, false, false);
  762.     }
  763.     protected boolean existsFaseTracciamentoDBRequestOut(boolean erogazioni, boolean fruizioni) throws DriverConfigurazioneException { 
  764.         return existsFaseTracciamentoDB("existsFaseTracciamentoDBRequestOut", erogazioni, fruizioni,
  765.                 false, true, false);
  766.     }
  767.     protected boolean existsFaseTracciamentoDBResponseOut(boolean erogazioni, boolean fruizioni) throws DriverConfigurazioneException { 
  768.         return existsFaseTracciamentoDB("existsFaseTracciamentoDBResponseOut", erogazioni, fruizioni,
  769.                 false, false, true);
  770.     }
  771.     private boolean existsFaseTracciamentoDB(String nomeMetodo, boolean erogazioni, boolean fruizioni,
  772.             boolean inRequest, boolean outRequest, boolean outResponse) throws DriverConfigurazioneException { 
  773.         
  774.         Connection con = null;
  775.         PreparedStatement stmt=null;
  776.         ResultSet risultato=null;

  778.         if (this.driver.atomica) {
  779.             try {
  780.                 con = this.driver.getConnectionFromDatasource(nomeMetodo);
  781.             } catch (Exception e) {
  782.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  784.             }

  786.         } else
  787.             con = this.driver.globalConnection;

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

  791.         try {

  793.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  794.             sqlQueryObject.addFromTable(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE);
  795.             sqlQueryObject.addSelectCountField("id", "cont");
  796.             sqlQueryObject.addWhereLikeCondition("stato", StatoFunzionalitaConPersonalizzazione.PERSONALIZZATO.getValue(), false, false);
  797.             sqlQueryObject.addWhereLikeCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_TIPO, CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_TIPO_DB, false, false);
  798.             List<String> valori = new ArrayList<>();
  799.             if(erogazioni) {
  800.                 valori.add(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PA);
  801.                 valori.add(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PA);
  802.             }
  803.             if(fruizioni) {
  804.                 valori.add(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_CONFIG_PD);
  805.                 valori.add(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_PROPRIETARIO_PD);
  806.             }
  807.             sqlQueryObject.addWhereINCondition(CostantiDB.TRACCIAMENTO_CONFIGURAZIONE_COLUMN_PROPRIETARIO, true, valori.toArray(new String[1]));
  808.             if(inRequest) {
  809.                 sqlQueryObject.addWhereLikeCondition("request_in", StatoFunzionalita.ABILITATO.getValue(), false, false);
  810.             }
  811.             if(outRequest) {
  812.                 sqlQueryObject.addWhereLikeCondition("request_out", StatoFunzionalita.ABILITATO.getValue(), false, false);
  813.             }
  814.             if(outResponse) {
  815.                 sqlQueryObject.addWhereLikeCondition("response_out", StatoFunzionalita.ABILITATO.getValue(), false, false);
  816.             }
  817.             sqlQueryObject.setANDLogicOperator(true);
  818.             
  819.             String queryString = sqlQueryObject.createSQLQuery();
  820.             stmt = con.prepareStatement(queryString);
  821.             risultato = stmt.executeQuery();
  822.             boolean result = false;
  823.             if (risultato.next()) {
  824.                 int c = risultato.getInt(1);
  825.                 result = c>0;
  826.             }
  827.             risultato.close();
  828.             stmt.close();

  830.             return result; 

  832.         } catch (Exception qe) {
  833.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  834.         } finally {

  836.             //Chiudo statement and resultset
  837.             JDBCUtilities.closeResources(risultato, stmt);

  839.             this.driver.closeConnection(con);
  840.         }
  841.     }
  842. }
Created with JaCoCo 0.8.8.202204050719