DriverConfigurazioneDB_genericPropertiesDriver.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.HashMap;
  28. import java.util.List;
  29. import java.util.Map;

  31. import org.apache.commons.lang.StringUtils;
  32. import org.openspcoop2.core.byok.IDriverBYOK;
  33. import org.openspcoop2.core.commons.Filtri;
  34. import org.openspcoop2.core.commons.ISearch;
  35. import org.openspcoop2.core.commons.SearchUtils;
  36. import org.openspcoop2.core.config.GenericProperties;
  37. import org.openspcoop2.core.config.Property;
  38. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  39. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  40. import org.openspcoop2.core.constants.CostantiDB;
  41. import org.openspcoop2.core.constants.CostantiProprieta;
  42. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  43. import org.openspcoop2.utils.sql.ISQLQueryObject;
  44. import org.openspcoop2.utils.sql.SQLObjectFactory;

  46. /**
  47.  * DriverConfigurazioneDB_genericPropertiesDriver
  48.  * 
  49.  * 
  50.  * @author Sandra Giangrandi (sandra@link.it)
  51.  * @author Stefano Corallo (corallo@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */
  55. public class DriverConfigurazioneDB_genericPropertiesDriver {

  57.     private static Map<String, List<String>> propertiesConfidentials = new HashMap<>();
  58.     static {
  59.         propertiesConfidentials.put(CostantiProprieta.TOKEN_VALIDATION_ID, CostantiProprieta.getTokenValidationProperties());
  60.         propertiesConfidentials.put(CostantiProprieta.TOKEN_NEGOZIAZIONE_ID, CostantiProprieta.getTokenRetrieveProperties());
  61.         propertiesConfidentials.put(CostantiProprieta.ATTRIBUTE_AUTHORITY_ID, CostantiProprieta.getAttributeAuthorityProperties());
  62.         List<String> messageSecurityIds = CostantiProprieta.getMessageSecurityIds();
  63.         if(messageSecurityIds!=null && !messageSecurityIds.isEmpty()) {
  64.             for (String id : messageSecurityIds) {
  65.                 propertiesConfidentials.put(id, CostantiProprieta.getMessageSecurityProperties(id));
  66.             }
  67.         }
  68.     }
  69.     public static void addConfidentialProperty(String tipo, String nome){
  70.         List<String> l = propertiesConfidentials.computeIfAbsent(tipo, k -> new ArrayList<>());

  72.         if(!l.contains(nome)) {
  73.             l.add(nome);
  74.         }
  75.     }
  76.     public static boolean isConfidentialProperty(String tipo, String nome) {
  77.         if(tipo==null || nome==null) {
  78.             return false;
  79.         }
  80.         List<String> l = propertiesConfidentials.get(tipo);
  81.         if(l!=null) {
  82.             return  isConfidentialProperty(l, nome);
  83.         }
  84.         return false;
  85.     }
  86.     private static boolean isConfidentialProperty(List<String> l, String nome) {
  87.         if(l.isEmpty()) {
  88.             return false;
  89.         }
  90.         if(l.contains(nome)) {
  91.             return true;
  92.         }
  93.         
  94.         if(nome.contains(CostantiProprieta.KEY_PROPERTIES_CUSTOM_SEPARATOR)) {
  95.             return isConfidentialPropertyCustomSeparator(l, nome);
  96.         }
  97.         else if(nome.contains(CostantiProprieta.KEY_PROPERTIES_DEFAULT_SEPARATOR)) {
  98.             return isConfidentialPropertyDefaultSeparator(l, nome);
  99.         }
  100.         
  101.         return false;
  102.     }
  103.     private static boolean isConfidentialPropertyCustomSeparator(List<String> l, String nome) {
  104.         String [] tmp = nome.split(CostantiProprieta.KEY_PROPERTIES_CUSTOM_SEPARATOR);
  105.         if(tmp!=null && tmp.length>1 && tmp[1]!=null){
  106.             for (String s : l) {
  107.                 if(tmp[1].equals(s)) {
  108.                     return true;
  109.                 }
  110.             }
  111.         }
  112.         return false;
  113.     }
  114.     private static boolean isConfidentialPropertyDefaultSeparator(List<String> l, String nome) {
  115.         String [] tmp = nome.split(CostantiProprieta.KEY_PROPERTIES_DEFAULT_SEPARATOR);
  116.         if(tmp!=null && tmp.length>1 && tmp[1]!=null){
  117.             for (String s : l) {
  118.                 if(tmp[1].equals(s)) {
  119.                     return true;
  120.                 }
  121.             }
  122.         }
  123.         return false;
  124.     }
  125.     
  126.     
  127.     private DriverConfigurazioneDB driver = null;
  128.     private DriverConfigurazioneDBUtils utilsDriver = null;
  129.     
  130.     protected DriverConfigurazioneDB_genericPropertiesDriver(DriverConfigurazioneDB driver) {
  131.         this.driver = driver;
  132.         this.utilsDriver = new DriverConfigurazioneDBUtils(driver);
  133.     }
  134.     
  135.     /**
  136.      * Restituisce le proprieta' generiche di una tipologia utilizzate dalla PdD
  137.      *
  138.      * @return proprieta' generiche
  139.      * 
  140.      */
  141.     protected List<GenericProperties> getGenericProperties() throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  142.         return getGenericProperties(null);
  143.     }
  144.     
  145.     /**
  146.      * Restituisce le proprieta' generiche utilizzate dalla PdD
  147.      *
  148.      * @return proprieta' generiche
  149.      * 
  150.      */
  151.     protected List<GenericProperties> getGenericProperties(String tipologia) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  152.         List<String> listTipologia = new ArrayList<>();
  153.         if(tipologia!=null) {
  154.             listTipologia.add(tipologia);
  155.         }
  156.         return getGenericProperties(listTipologia, null, null,true, null);
  157.     }
  158.     
  159.     protected GenericProperties getGenericProperties(String tipologia, String name) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  160.         List<String> listTipologia = new ArrayList<>();
  161.         if(tipologia!=null) {
  162.             listTipologia.add(tipologia);
  163.         }
  164.         List<GenericProperties> l = getGenericProperties(listTipologia, null, null,true, name);
  165.         if(l==null || l.isEmpty()) {
  166.             throw new DriverConfigurazioneNotFound("[getGenericProperties] Configurazione Generic Properties non presenti con tipologia '"+tipologia+"' e nome '"+name+"'");
  167.         }
  168.         else if(l.size()>1) {
  169.             throw new DriverConfigurazioneException("[getGenericProperties] Trovata più di una collezione di proprietà con tipologia '"+tipologia+"' e nome '"+name+"'");
  170.         }
  171.         return l.get(0);
  172.     }
  173.     
  174.     /**
  175.      * Restituisce le proprieta' generiche utilizzate dalla PdD
  176.      *
  177.      * @return proprieta' generiche
  178.      * 
  179.      */
  180.     protected List<GenericProperties> getGenericProperties(List<String> tipologia, Integer idLista, ISearch ricerca, boolean throwNotFoundException) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  181.         return getGenericProperties(tipologia, idLista, ricerca, throwNotFoundException, null);
  182.     }
  183.     private List<GenericProperties> getGenericProperties(List<String> tipologia, Integer idLista, ISearch ricerca, boolean throwNotFoundException, String nomeEsatto) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{

  185.         Connection con = null;
  186.         PreparedStatement stm = null;
  187.         ResultSet rs = null;
  188.         
  189.         Integer offset = null;
  190.         Integer limit =null;
  191.         String search = "";
  192.         String filterTipoTokenPolicy = null;
  193.         if(idLista != null && ricerca != null) {
  194.             limit = ricerca.getPageSize(idLista);
  195.             offset = ricerca.getIndexIniziale(idLista);
  196.             search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  197.             
  198.             filterTipoTokenPolicy = SearchUtils.getFilter(ricerca, idLista,  Filtri.FILTRO_TIPO_TOKEN_POLICY);
  199.             
  200.             this.driver.logDebug("search : " + search);
  201.             this.driver.logDebug("filterTipoTokenPolicy : " + filterTipoTokenPolicy);
  202.         }
  203.         
  204.         
  205.         String sqlQuery = "";

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

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

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

  219.         List<Long> listIdLong = new ArrayList<>();
  220.         
  221.         try {
  222.             
  223.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  224.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTIES);
  225.             sqlQueryObject.addSelectCountField("*", "cont");
  226.             if(tipologia!=null && !tipologia.isEmpty()) {
  227.                 sqlQueryObject.addWhereINCondition("tipologia", true, tipologia.toArray(new String[1]));
  228.             }
  229.             if(filterTipoTokenPolicy!=null && !"".equals(filterTipoTokenPolicy)) {
  230.                 sqlQueryObject.addWhereCondition("tipo=?");
  231.             }
  232.             if(nomeEsatto!=null) {
  233.                 sqlQueryObject.addWhereCondition("nome=?");
  234.             }
  235.             if (!search.equals("")) {
  236.                 //query con search
  237.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  238.             } 
  239.             sqlQueryObject.setANDLogicOperator(true);
  240.             sqlQuery = sqlQueryObject.createSQLQuery();
  241.              
  242.             stm = con.prepareStatement(sqlQuery);
  243.             int index = 1;
  244.             if(filterTipoTokenPolicy!=null && !"".equals(filterTipoTokenPolicy)) {
  245.                 stm.setString(index++, filterTipoTokenPolicy);
  246.             }
  247.             if(nomeEsatto!=null) {
  248.                 stm.setString(index++, nomeEsatto);
  249.             }
  250.             rs = stm.executeQuery();
  251.             if (rs.next() && ricerca != null)
  252.                 ricerca.setNumEntries(idLista,rs.getInt(1));
  253.             rs.close();
  254.             stm.close();

  256.             // ricavo le entries
  257.             if (limit!= null && limit == 0) // con limit
  258.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  260.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  261.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTIES);
  262.             sqlQueryObject.addSelectField("id");
  263.             sqlQueryObject.addSelectField("nome");
  264.             if(tipologia!=null && !tipologia.isEmpty()) {
  265.                 sqlQueryObject.addWhereINCondition("tipologia", true, tipologia.toArray(new String[1]));
  266.             }
  267.             if(filterTipoTokenPolicy!=null && !"".equals(filterTipoTokenPolicy)) {
  268.                 sqlQueryObject.addWhereCondition("tipo=?");
  269.             }
  270.             if(nomeEsatto!=null) {
  271.                 sqlQueryObject.addWhereCondition("nome=?");
  272.             }
  273.             if (!search.equals("")) {
  274.                 //query con search
  275.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  276.             } 
  277.             sqlQueryObject.setANDLogicOperator(true);
  278.             sqlQueryObject.addOrderBy("nome");
  279.             sqlQueryObject.setSortType(true);
  280.             if(limit!= null)
  281.                 sqlQueryObject.setLimit(limit);
  282.             if(offset != null)
  283.                 sqlQueryObject.setOffset(offset);
  284.             
  285.             sqlQuery = sqlQueryObject.createSQLQuery();
  286.             stm = con.prepareStatement(sqlQuery);
  287.             index = 1;
  288.             if(filterTipoTokenPolicy!=null && !"".equals(filterTipoTokenPolicy)) {
  289.                 stm.setString(index++, filterTipoTokenPolicy);
  290.             }
  291.             if(nomeEsatto!=null) {
  292.                 stm.setString(index++, nomeEsatto);
  293.             }
  294.             rs = stm.executeQuery();
  295.             
  296.             while(rs.next()){
  297.                 
  298.                 long idP = rs.getLong("id");
  299.                 listIdLong.add(idP);
  300.                 
  301.             }
  302.             rs.close();
  303.             stm.close();
  304.             
  305.         } catch (SQLException se) {
  306.             throw new DriverConfigurazioneException("[getGenericProperties]  SqlException: " + se.getMessage(),se);
  307.         }catch (Exception se) {
  308.             throw new DriverConfigurazioneException("[getGenericProperties]  Exception: " + se.getMessage(),se);
  309.         } finally {
  310.             JDBCUtilities.closeResources(rs, stm);
  311.             this.driver.closeConnection(con);
  312.         }

  314.         
  315.         List<GenericProperties> genericPropertiesList = new ArrayList<>();
  316.         
  317.         if(!listIdLong.isEmpty()) {
  318.             for (Long id : listIdLong) {
  319.                 genericPropertiesList.add(this.getGenericProperties(id));
  320.             }
  321.         }

  323.         if((genericPropertiesList==null || genericPropertiesList.isEmpty()) && throwNotFoundException)
  324.             throw new DriverConfigurazioneNotFound("Generic Properties non presenti");
  325.         
  326.         return genericPropertiesList;
  327.     }
  328.     
  329.     protected void createGenericProperties(GenericProperties genericProperties) throws DriverConfigurazioneException{
  330.         Connection con = null;
  331.         boolean error = false;

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

  340.             }

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

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

  347.         try {
  348.             this.driver.logDebug("CRUDGenericPropertiesPdD type = 1");
  349.             DriverConfigurazioneDB_configLIB.CRUDGenericProperties(1, genericProperties, con, this.driver.getDriverWrapBYOK());

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

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

  360.     /**
  361.      * Aggiorna le informazioni sulle proprieta' generiche della PdD
  362.      * 
  363.      * @param genericProperties
  364.      * @throws DriverConfigurazioneException
  365.      */
  366.     protected void updateGenericProperties(GenericProperties genericProperties) throws DriverConfigurazioneException{
  367.         Connection con = null;
  368.         boolean error = false;

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

  377.             }

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

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

  384.         try {
  385.             this.driver.logDebug("updateGenericProperties type = 2");
  386.             DriverConfigurazioneDB_configLIB.CRUDGenericProperties(2, genericProperties, con, this.driver.getDriverWrapBYOK());

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

  393.             this.driver.closeConnection(error,con);
  394.         }
  395.     }


  398.     /**
  399.      * Elimina le informazioni sulle proprieta' generiche della PdD
  400.      * 
  401.      * @param genericProperties
  402.      * @throws DriverConfigurazioneException
  403.      */
  404.     protected void deleteGenericProperties(GenericProperties genericProperties) throws DriverConfigurazioneException{
  405.         Connection con = null;
  406.         boolean error = false;

  408.         if (this.driver.atomica) {
  409.             try {
  410.                 con = this.driver.getConnectionFromDatasource("deleteGenericProperties");
  411.                 con.setAutoCommit(false);
  412.             } catch (Exception e) {
  413.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteGenericProperties] Exception accedendo al datasource :" + e.getMessage(),e);

  415.             }

  417.         } else
  418.             con = this.driver.globalConnection;

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

  422.         try {
  423.             this.driver.logDebug("deleteGenericProperties type = 3");
  424.             DriverConfigurazioneDB_configLIB.CRUDGenericProperties(3, genericProperties, con, this.driver.getDriverWrapBYOK());

  426.         } catch (Exception qe) {
  427.             error = true;
  428.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteGenericProperties] Errore durante la deleteSystemPropertiesPdD : " + qe.getMessage(),qe);
  429.         } finally {

  431.             this.driver.closeConnection(error,con);
  432.         }
  433.     }
  434.     
  435.     protected GenericProperties getGenericProperties(long idGenericProperties) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  436.         Connection con = null;
  437.         PreparedStatement stm = null;
  438.         ResultSet rs = null;
  439.         PreparedStatement stm2 = null;
  440.         ResultSet rs2 = null;
  441.         
  442.         String sqlQuery = "";

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

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

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

  456.         try {
  457.             GenericProperties genericProperties = null;
  458.             
  459.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  460.             sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTIES);
  461.             sqlQueryObject.addSelectField("*");
  462.             sqlQueryObject.addWhereCondition("id=?");
  463.             
  464.             sqlQuery = sqlQueryObject.createSQLQuery();
  465.             stm = con.prepareStatement(sqlQuery);
  466.             stm.setLong(1, idGenericProperties);
  467.             rs = stm.executeQuery();

  469.             if(rs.next()){
  470.                 
  471.                 genericProperties = new GenericProperties();
  472.                 genericProperties.setNome(rs.getString("nome"));
  473.                 genericProperties.setDescrizione(rs.getString("descrizione"));
  474.                 genericProperties.setTipologia(rs.getString("tipologia"));
  475.                 genericProperties.setTipo(rs.getString("tipo"));
  476.                 
  477.                 // Proprieta Oggetto
  478.                 genericProperties.setProprietaOggetto(this.utilsDriver.readProprietaOggetto(rs,false));
  479.                 
  480.                 long idP = rs.getLong("id");
  481.                 genericProperties.setId(idP);
  482.                 
  483.                 //prendo le proprieta
  484.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  485.                 sqlQueryObject.addFromTable(CostantiDB.CONFIG_GENERIC_PROPERTY);
  486.                 sqlQueryObject.addSelectField("*");
  487.                 sqlQueryObject.addWhereCondition("id_props = ?");
  488.                 sqlQuery = sqlQueryObject.createSQLQuery();
  489.                 stm2 = con.prepareStatement(sqlQuery);
  490.                 stm2.setLong(1, idP);
  491.                 rs2 = stm2.executeQuery();
  492.                 Property genericProperty = null;
  493.                 while(rs2.next())
  494.                 {
  495.                     genericProperty = new Property();
  496.                     //proprieta
  497.                     genericProperty.setId(rs2.getLong("id"));
  498.                     genericProperty.setNome(rs2.getString("nome"));
  499.                     
  500.                     String plainValue = rs2.getString("valore");
  501.                     String encValue = rs2.getString("enc_value");
  502.                     if(encValue!=null && StringUtils.isNotEmpty(encValue)) {
  503.                         IDriverBYOK driverBYOK = this.driver.getDriverUnwrapBYOK();
  504.                         if(driverBYOK!=null) {
  505.                             genericProperty.setValore(driverBYOK.unwrapAsString(encValue));
  506.                         }
  507.                         else {
  508.                             genericProperty.setValore(encValue);
  509.                         }
  510.                     }
  511.                     else {
  512.                         genericProperty.setValore(plainValue);
  513.                     }

  515.                     genericProperties.addProperty(genericProperty);
  516.                 }
  517.                 rs2.close();
  518.                 stm2.close();
  519.                 
  520.             }
  521.             rs.close();
  522.             stm.close();

  524.             if(genericProperties==null )
  525.                 throw new DriverConfigurazioneNotFound("Generic Properties non presenti");
  526.             
  527.             return genericProperties;

  529.         } catch (SQLException se) {
  530.             throw new DriverConfigurazioneException("[getGenericProperties]  SqlException: " + se.getMessage(),se);
  531.         }catch (DriverConfigurazioneNotFound e) {
  532.             throw new DriverConfigurazioneNotFound(e);
  533.         }catch (Exception se) {
  534.             throw new DriverConfigurazioneException("[getGenericProperties]  Exception: " + se.getMessage(),se);
  535.         } finally {
  536.             //Chiudo statement and resultset
  537.             JDBCUtilities.closeResources(rs2, stm2);
  538.             JDBCUtilities.closeResources(rs, stm);
  539.             this.driver.closeConnection(con);
  540.         }
  541.     }
  542. }
Created with JaCoCo 0.8.8.202204050719