DriverConfigurazioneDB_pluginsDriver.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.sql.Timestamp;
  27. import java.util.ArrayList;
  28. import java.util.Arrays;
  29. import java.util.Date;
  30. import java.util.List;

  32. import org.openspcoop2.core.commons.DBUtils;
  33. import org.openspcoop2.core.commons.ISearch;
  34. import org.openspcoop2.core.commons.Liste;
  35. import org.openspcoop2.core.config.RegistroPlugin;
  36. import org.openspcoop2.core.config.RegistroPluginArchivio;
  37. import org.openspcoop2.core.config.RegistroPlugins;
  38. import org.openspcoop2.core.config.constants.PluginSorgenteArchivio;
  39. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  40. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  41. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  42. import org.openspcoop2.core.constants.CostantiDB;
  43. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  44. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  45. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  46. import org.openspcoop2.utils.sql.ISQLQueryObject;
  47. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  60.     private DriverConfigurazioneDB driver = null;
  61.     
  62.     protected DriverConfigurazioneDB_pluginsDriver(DriverConfigurazioneDB driver) {
  63.         this.driver = driver;
  64.     }
  65.     
  66.     protected RegistroPlugins getRegistroPlugins() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  67.         
  68.         Connection con = null;
  69.         PreparedStatement stm = null;
  70.         ResultSet rs = null;
  71.         
  72.         String sqlQuery = "";

  74.         if (this.driver.atomica) {
  75.             try {
  76.                 con = this.driver.getConnectionFromDatasource("getRegistroPlugins");
  77.             } catch (Exception e) {
  78.                 throw new DriverConfigurazioneException("[getRegistroPlugins] Exception accedendo al datasource :" + e.getMessage(),e);

  80.             }
  81.         } else
  82.             con = this.driver.globalConnection;

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

  86.         RegistroPlugins registro = null;
  87.         
  88.         try {
  89.             
  90.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  91.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  92.             sqlQueryObject.addSelectField("nome");
  93.             sqlQueryObject.setANDLogicOperator(true);
  94.             sqlQueryObject.addOrderBy("posizione", true);
  95.             sqlQuery = sqlQueryObject.createSQLQuery();
  96.              
  97.             stm = con.prepareStatement(sqlQuery);
  98.             rs = stm.executeQuery();
  99.             List<String> nomi = new ArrayList<>();
  100.             while(rs.next()) {
  101.                 nomi.add(rs.getString("nome"));
  102.             }
  103.             rs.close();
  104.             stm.close();
  105.             rs=null;
  106.             stm=null;
  107.             
  108.             if(!nomi.isEmpty()) {
  109.                 if(registro==null) {
  110.                     registro = new RegistroPlugins();
  111.                 }
  112.                 for (String nome : nomi) {
  113.                     registro.addPlugin(this.getRegistroPlugin(con, nome));
  114.                 }
  115.             }
  116.             
  117.         } catch (SQLException se) {
  118.             throw new DriverConfigurazioneException("[getRegistroPlugins]  SqlException: " + se.getMessage(),se);
  119.         }catch (Exception se) {
  120.             throw new DriverConfigurazioneException("[getRegistroPlugins]  Exception: " + se.getMessage(),se);
  121.         } finally {
  122.             JDBCUtilities.closeResources(rs, stm);
  123.             this.driver.closeConnection(con);
  124.         }

  126.         if(registro==null || registro.sizePluginList()<=0) {
  127.             throw new DriverConfigurazioneNotFound("Nessun plugin registrato");
  128.         }
  129.         return registro;
  130.         
  131.     }
  132.     
  133.     
  134.     
  135.     protected RegistroPlugin getRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  136.         return getRegistroPlugin(nome, false);
  137.     }
  138.     protected RegistroPlugin getDatiRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  139.         return getRegistroPlugin(nome, true);
  140.     }
  141.     private RegistroPlugin getRegistroPlugin(String nome, boolean soloDati) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  142.         Connection con = null;
  143.         
  144.         if (this.driver.atomica) {
  145.             try {
  146.                 con = this.driver.getConnectionFromDatasource("getRegistroPlugin");
  147.             } catch (Exception e) {
  148.                 throw new DriverConfigurazioneException("[getRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  150.             }
  151.         } else
  152.             con = this.driver.globalConnection;

  154.             try {
  155.             
  156.             return getRegistroPlugin(con, nome, soloDati);
  157.             
  158.         } finally {
  159.             this.driver.closeConnection(con);
  160.         }

  162.     }

  164.     protected RegistroPlugin getRegistroPlugin(Connection conParam, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  165.         return getRegistroPlugin(conParam, nome, false);
  166.     }
  167.     protected RegistroPlugin getDatiRegistroPlugin(Connection conParam, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  168.         return getRegistroPlugin(conParam, nome, true);
  169.     }
  170.     private RegistroPlugin getRegistroPlugin(Connection conParam, String nome, boolean soloDati) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  171.         PreparedStatement stm = null;
  172.         ResultSet rs = null;
  173.         
  174.         String sqlQuery = "";

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

  178.         RegistroPlugin plugin = null;
  179.         
  180.         try {
  181.             
  182.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  183.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  184.             sqlQueryObject.addWhereCondition("nome=?");
  185.             sqlQueryObject.setANDLogicOperator(true);
  186.             sqlQuery = sqlQueryObject.createSQLQuery();
  187.              
  188.             stm = conParam.prepareStatement(sqlQuery);
  189.             stm.setString(1, nome);
  190.             rs = stm.executeQuery();
  191.             if(rs.next()) {
  192.                 
  193.                 plugin = new RegistroPlugin();
  194.                 
  195.                 plugin.setId(rs.getLong("id"));
  196.                 plugin.setNome(rs.getString("nome"));
  197.                 plugin.setPosizione(rs.getInt("posizione"));
  198.                 StatoFunzionalita stato = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stato"));
  199.                 plugin.setStato(stato);
  200.                 plugin.setDescrizione(rs.getString("descrizione"));
  201.                 plugin.setData(rs.getTimestamp("data"));
  202.                 
  203.                 String compatibilita = rs.getString("compatibilita");
  204.                 if( (compatibilita!=null && !"".equals(compatibilita)) ) {
  205.                     if(compatibilita.contains(",")) {
  206.                         String [] tmp = compatibilita.split(",");
  207.                         for (int i = 0; i < tmp.length; i++) {
  208.                             plugin.addCompatibilita(tmp[i].trim());
  209.                         }
  210.                     }
  211.                     else {
  212.                         plugin.addCompatibilita(compatibilita);
  213.                     }
  214.                 }
  215.                 
  216.             }
  217.             rs.close();
  218.             stm.close();
  219.             rs=null;
  220.             stm=null;
  221.             
  222.             if(plugin!=null && !soloDati) {
  223.                 
  224.                 // archive jar
  225.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  226.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  227.                 sqlQueryObject.addWhereCondition("id_plugin=?");
  228.                 sqlQueryObject.setANDLogicOperator(true);
  229.                 sqlQuery = sqlQueryObject.createSQLQuery();
  230.                  
  231.                 stm = conParam.prepareStatement(sqlQuery);
  232.                 stm.setLong(1, plugin.getId());
  233.                 rs = stm.executeQuery();
  234.                 while(rs.next()) {
  235.                     
  236.                     RegistroPluginArchivio archivio = new RegistroPluginArchivio();
  237.                     archivio.setNome(rs.getString("nome"));
  238.                     archivio.setData(rs.getTimestamp("data"));
  239.                     IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  240.                     archivio.setSorgente( DriverConfigurazioneDBLib.getEnumPluginSorgenteArchivio(rs.getString("sorgente")));
  241.                     switch (archivio.getSorgente()) {
  242.                     case JAR:
  243.                         archivio.setContenuto(jdbcAdapter.getBinaryData(rs, "contenuto"));
  244.                         break;
  245.                     case URL:
  246.                         archivio.setUrl(rs.getString("url"));
  247.                         break;
  248.                     case DIR:
  249.                         archivio.setDir(rs.getString("dir"));
  250.                         break;
  251.                     }
  252.                     plugin.addArchivio(archivio);
  253.                     
  254.                 }
  255.                 rs.close();
  256.                 stm.close();
  257.                 rs=null;
  258.                 stm=null;

  260.             }
  261.             
  262.         } catch (SQLException se) {
  263.             throw new DriverConfigurazioneException("[getRegistroPlugin]  SqlException: " + se.getMessage(),se);
  264.         }catch (Exception se) {
  265.             throw new DriverConfigurazioneException("[getRegistroPlugin]  Exception: " + se.getMessage(),se);
  266.         } finally {
  267.             JDBCUtilities.closeResources(rs, stm);
  268.         }

  270.         if(plugin!=null) {
  271.             return plugin;
  272.         }
  273.         throw new DriverConfigurazioneNotFound("Plugin '"+nome+"' non esistente");
  274.     }
  275.     
  276.     protected RegistroPlugin getRegistroPluginFromPosizione(int posizione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  277.         return getRegistroPluginFromPosizione(posizione, false);
  278.     }
  279.     protected RegistroPlugin getDatiRegistroPluginFromPosizione(int posizione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  280.         return getRegistroPluginFromPosizione(posizione, true);
  281.     }
  282.     private RegistroPlugin getRegistroPluginFromPosizione(int posizione, boolean soloDati) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  283.         Connection con = null;
  284.         PreparedStatement stm = null;
  285.         ResultSet rs = null;
  286.         
  287.         String sqlQuery = "";

  289.         if (this.driver.atomica) {
  290.             try {
  291.                 con = this.driver.getConnectionFromDatasource("getRegistroPlugin");
  292.             } catch (Exception e) {
  293.                 throw new DriverConfigurazioneException("[getRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  295.             }
  296.         } else
  297.             con = this.driver.globalConnection;

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

  301.         RegistroPlugin plugin = null;
  302.         
  303.         try {
  304.             
  305.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  306.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  307.             sqlQueryObject.addWhereCondition("posizione=?");
  308.             sqlQueryObject.setANDLogicOperator(true);
  309.             sqlQuery = sqlQueryObject.createSQLQuery();
  310.              
  311.             stm = con.prepareStatement(sqlQuery);
  312.             stm.setInt(1, posizione);
  313.             rs = stm.executeQuery();
  314.             if(rs.next()) {
  315.                 
  316.                 plugin = new RegistroPlugin();
  317.                 
  318.                 plugin.setId(rs.getLong("id"));
  319.                 plugin.setNome(rs.getString("nome"));
  320.                 plugin.setPosizione(rs.getInt("posizione"));
  321.                 StatoFunzionalita stato = DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("stato"));
  322.                 plugin.setStato(stato);
  323.                 plugin.setDescrizione(rs.getString("descrizione"));
  324.                 plugin.setData(rs.getTimestamp("data"));
  325.                 
  326.                 String compatibilita = rs.getString("compatibilita");
  327.                 if( (compatibilita!=null && !"".equals(compatibilita)) ) {
  328.                     if(compatibilita.contains(",")) {
  329.                         String [] tmp = compatibilita.split(",");
  330.                         for (int i = 0; i < tmp.length; i++) {
  331.                             plugin.addCompatibilita(tmp[i].trim());
  332.                         }
  333.                     }
  334.                     else {
  335.                         plugin.addCompatibilita(compatibilita);
  336.                     }
  337.                 }
  338.                 
  339.             }
  340.             rs.close();
  341.             stm.close();
  342.             rs=null;
  343.             stm=null;
  344.             
  345.             if(plugin!=null && !soloDati) {
  346.                 
  347.                 // archive jar
  348.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  349.                 sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  350.                 sqlQueryObject.addWhereCondition("id_plugin=?");
  351.                 sqlQueryObject.setANDLogicOperator(true);
  352.                 sqlQuery = sqlQueryObject.createSQLQuery();
  353.                  
  354.                 stm = con.prepareStatement(sqlQuery);
  355.                 stm.setLong(1, plugin.getId());
  356.                 rs = stm.executeQuery();
  357.                 while(rs.next()) {
  358.                     
  359.                     RegistroPluginArchivio archivio = new RegistroPluginArchivio();
  360.                     archivio.setNome(rs.getString("nome"));
  361.                     archivio.setData(rs.getTimestamp("data"));
  362.                     IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  363.                     archivio.setSorgente( DriverConfigurazioneDBLib.getEnumPluginSorgenteArchivio(rs.getString("sorgente")));
  364.                     switch (archivio.getSorgente()) {
  365.                     case JAR:
  366.                         archivio.setContenuto(jdbcAdapter.getBinaryData(rs, "contenuto"));
  367.                         break;
  368.                     case URL:
  369.                         archivio.setUrl(rs.getString("url"));
  370.                         break;
  371.                     case DIR:
  372.                         archivio.setDir(rs.getString("dir"));
  373.                         break;
  374.                     }
  375.                     plugin.addArchivio(archivio);
  376.                     
  377.                 }
  378.                 rs.close();
  379.                 stm.close();
  380.                 rs=null;
  381.                 stm=null;

  383.             }
  384.             
  385.         } catch (SQLException se) {
  386.             throw new DriverConfigurazioneException("[getRegistroPlugin]  SqlException: " + se.getMessage(),se);
  387.         }catch (Exception se) {
  388.             throw new DriverConfigurazioneException("[getRegistroPlugin]  Exception: " + se.getMessage(),se);
  389.         } finally {
  390.             JDBCUtilities.closeResources(rs, stm);
  391.             this.driver.closeConnection(con);
  392.         }

  394.         if(plugin!=null) {
  395.             return plugin;
  396.         }
  397.         throw new DriverConfigurazioneNotFound("Plugin in posizione '"+posizione+"' non esistente");
  398.     }
  399.     
  400.     protected boolean existsRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  402.         Connection con = null;
  403.         PreparedStatement stm = null;
  404.         ResultSet rs = null;
  405.         
  406.         String sqlQuery = "";

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

  414.             }
  415.         } else
  416.             con = this.driver.globalConnection;

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

  420.         int count = -1;
  421.         
  422.         try {
  423.             
  424.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  425.             sqlQueryObject.addSelectCountField(CostantiDB.REGISTRO_PLUGINS+".id", "cont");
  426.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  427.             sqlQueryObject.addWhereCondition("nome=?");
  428.             sqlQueryObject.setANDLogicOperator(true);
  429.             sqlQuery = sqlQueryObject.createSQLQuery();
  430.              
  431.             stm = con.prepareStatement(sqlQuery);
  432.             stm.setString(1, nome);
  433.             rs = stm.executeQuery();
  434.             
  435.             if(rs.next()) {
  436.                 count = rs.getInt(1);
  437.             }
  438.             
  439.             return count > 0;
  440.         } catch (SQLException se) {
  441.             throw new DriverConfigurazioneException("[existsRegistroPlugin]  SqlException: " + se.getMessage(),se);
  442.         }catch (Exception se) {
  443.             throw new DriverConfigurazioneException("[existsRegistroPlugin]  Exception: " + se.getMessage(),se);
  444.         } finally {
  445.             JDBCUtilities.closeResources(rs, stm);
  446.             this.driver.closeConnection(con);
  447.         }
  448.     }
  449.     
  450.     protected int getMaxPosizioneRegistroPlugin() throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  452.         Connection con = null;
  453.         PreparedStatement stm = null;
  454.         ResultSet rs = null;
  455.         
  456.         String sqlQuery = "";

  458.         if (this.driver.atomica) {
  459.             try {
  460.                 con = this.driver.getConnectionFromDatasource("getMaxPosizioneRegistroPlugin");
  461.             } catch (Exception e) {
  462.                 throw new DriverConfigurazioneException("[getMaxPosizioneRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  464.             }
  465.         } else
  466.             con = this.driver.globalConnection;

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

  470.         try {
  471.             
  472.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  473.             sqlQueryObject.addSelectMaxField(CostantiDB.REGISTRO_PLUGINS+".posizione", "max");
  474.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  475.             sqlQueryObject.setANDLogicOperator(true);
  476.             sqlQuery = sqlQueryObject.createSQLQuery();
  477.              
  478.             stm = con.prepareStatement(sqlQuery);
  479.             rs = stm.executeQuery();
  480.             
  481.             if(rs.next()) {
  482.                 return rs.getInt(1);
  483.             }
  484.             
  485.             return 0;
  486.         } catch (SQLException se) {
  487.             throw new DriverConfigurazioneException("[getMaxPosizioneRegistroPlugin]  SqlException: " + se.getMessage(),se);
  488.         }catch (Exception se) {
  489.             throw new DriverConfigurazioneException("[getMaxPosizioneRegistroPlugin]  Exception: " + se.getMessage(),se);
  490.         } finally {
  491.             JDBCUtilities.closeResources(rs, stm);
  492.             this.driver.closeConnection(con);
  493.         }
  494.     }
  495.     
  496.     protected int getNumeroArchiviJarRegistroPlugin(String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  498.         Connection con = null;
  499.         PreparedStatement stm = null;
  500.         ResultSet rs = null;
  501.         
  502.         String sqlQuery = "";

  504.         if (this.driver.atomica) {
  505.             try {
  506.                 con = this.driver.getConnectionFromDatasource("getNumeroArchiviJarRegistroPlugin");
  507.             } catch (Exception e) {
  508.                 throw new DriverConfigurazioneException("[existsRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  510.             }
  511.         } else
  512.             con = this.driver.globalConnection;

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

  516.         int count = -1;
  517.         
  518.         try {
  519.             
  520.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  521.             sqlQueryObject.addSelectCountField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE+".id", "cont");
  522.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  523.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  524.             sqlQueryObject.addWhereCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".id_plugin = " + CostantiDB.REGISTRO_PLUGINS + ".id");
  525.             sqlQueryObject.addWhereCondition(CostantiDB.REGISTRO_PLUGINS + ".nome=?");
  526.             sqlQueryObject.setANDLogicOperator(true);
  527.             sqlQuery = sqlQueryObject.createSQLQuery();
  528.              
  529.             stm = con.prepareStatement(sqlQuery);
  530.             stm.setString(1, nome);
  531.             rs = stm.executeQuery();
  532.             
  533.             if(rs.next()) {
  534.                 count = rs.getInt(1);
  535.             }
  536.             
  537.             return count;
  538.         } catch (SQLException se) {
  539.             throw new DriverConfigurazioneException("[getNumeroArchiviJarRegistroPlugin]  SqlException: " + se.getMessage(),se);
  540.         }catch (Exception se) {
  541.             throw new DriverConfigurazioneException("[getNumeroArchiviJarRegistroPlugin]  Exception: " + se.getMessage(),se);
  542.         } finally {
  543.             JDBCUtilities.closeResources(rs, stm);
  544.             this.driver.closeConnection(con);
  545.         }
  546.     }
  547.     
  548.     protected void createRegistroPlugin(RegistroPlugin plugin) throws DriverConfigurazioneException{
  549.         Connection con = null;
  550.         boolean error = false;

  552.         if (this.driver.atomica) {
  553.             try {
  554.                 con = this.driver.getConnectionFromDatasource("createRegistroPlugin");
  555.                 con.setAutoCommit(false);
  556.             } catch (Exception e) {
  557.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  559.             }

  561.         } else
  562.             con = this.driver.globalConnection;

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

  566.         try {
  567.             this.driver.logDebug("CRUDRegistroPlugin type = 1");
  568.             DriverConfigurazioneDB_pluginsLIB.CRUDRegistroPlugin(1, plugin, con);

  570.         } catch (Exception qe) {
  571.             error = true;
  572.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRegistroPlugin] Errore durante la createRegistroPlugin : " + qe.getMessage(),qe);
  573.         } finally {

  575.             this.driver.closeConnection(error,con);
  576.         }
  577.     }
  578.     
  579.     protected void updateRegistroPlugin(RegistroPlugin plugin) throws DriverConfigurazioneException{
  580.         Connection con = null;
  581.         boolean error = false;

  583.         if (this.driver.atomica) {
  584.             try {
  585.                 con = this.driver.getConnectionFromDatasource("updateRegistroPlugin");
  586.                 con.setAutoCommit(false);
  587.             } catch (Exception e) {
  588.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  590.             }

  592.         } else
  593.             con = this.driver.globalConnection;

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

  597.         try {
  598.             this.driver.logDebug("CRUDRegistroPlugin type = 2");
  599.             DriverConfigurazioneDB_pluginsLIB.CRUDRegistroPlugin(2, plugin, con);

  601.         } catch (Exception qe) {
  602.             error = true;
  603.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateRegistroPlugin] Errore durante la updateRegistroPlugin : " + qe.getMessage(),qe);
  604.         } finally {

  606.             this.driver.closeConnection(error,con);
  607.         }
  608.     }
  609.     
  610.     protected void deleteRegistroPlugin(RegistroPlugin plugin) throws DriverConfigurazioneException{
  611.         Connection con = null;
  612.         boolean error = false;

  614.         if (this.driver.atomica) {
  615.             try {
  616.                 con = this.driver.getConnectionFromDatasource("deleteRegistroPlugin");
  617.                 con.setAutoCommit(false);
  618.             } catch (Exception e) {
  619.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  621.             }

  623.         } else
  624.             con = this.driver.globalConnection;

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

  628.         try {
  629.             this.driver.logDebug("CRUDRegistroPlugin type = 3");
  630.             DriverConfigurazioneDB_pluginsLIB.CRUDRegistroPlugin(3, plugin, con);

  632.         } catch (Exception qe) {
  633.             error = true;
  634.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRegistroPlugin] Errore durante la deleteRegistroPlugin : " + qe.getMessage(),qe);
  635.         } finally {

  637.             this.driver.closeConnection(error,con);
  638.         }
  639.     }
  640.     
  641.     protected void updateDatiRegistroPlugin(String nomePlugin, RegistroPlugin plugin) throws DriverConfigurazioneException{
  642.         Connection con = null;
  643.         boolean error = false;

  645.         if (this.driver.atomica) {
  646.             try {
  647.                 con = this.driver.getConnectionFromDatasource("updateDatiRegistroPlugin");
  648.                 con.setAutoCommit(false);
  649.             } catch (Exception e) {
  650.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateDatiRegistroPlugin] Exception accedendo al datasource :" + e.getMessage(),e);

  652.             }

  654.         } else
  655.             con = this.driver.globalConnection;

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

  659.         try {
  660.             this.driver.logDebug("updateDatiRegistroPlugin");
  661.             DriverConfigurazioneDB_pluginsLIB.updateDatiRegistroPlugin(nomePlugin, plugin, con);

  663.         } catch (Exception qe) {
  664.             error = true;
  665.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateDatiRegistroPlugin] Errore durante la updateDatiRegistroPlugin : " + qe.getMessage(),qe);
  666.         } finally {

  668.             this.driver.closeConnection(error,con);
  669.         }
  670.     }
  671.     
  672.     protected RegistroPluginArchivio getRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{
  673.         Connection con = null;
  674.         PreparedStatement stm = null;
  675.         ResultSet rs = null;
  676.         
  677.         String sqlQuery = "";

  679.         if (this.driver.atomica) {
  680.             try {
  681.                 con = this.driver.getConnectionFromDatasource("getRegistroPluginArchivio");
  682.             } catch (Exception e) {
  683.                 throw new DriverConfigurazioneException("[getRegistroPluginArchivio] Exception accedendo al datasource :" + e.getMessage(),e);

  685.             }
  686.         } else
  687.             con = this.driver.globalConnection;

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

  691.         RegistroPluginArchivio archivio = null;
  692.         
  693.         try {
  694.             
  695.             long idPlugin = DBUtils.getIdRegistroPlugin(nomePlugin, con, this.driver.tipoDB);
  696.             if(idPlugin<=0) {
  697.                 throw new DriverConfigurazioneNotFound("Plugin '"+nomePlugin+"' non esistente");
  698.             }
  699.             
  700.             if(nome==null) {
  701.                 throw new DriverConfigurazioneException("Nome archivio non indicato");
  702.             }
  703.             
  704.             // archive jar
  705.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  706.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  707.             sqlQueryObject.addWhereCondition("id_plugin=?");
  708.             sqlQueryObject.addWhereCondition("nome=?");
  709.             sqlQueryObject.setANDLogicOperator(true);
  710.             sqlQuery = sqlQueryObject.createSQLQuery();
  711.             
  712.             stm = con.prepareStatement(sqlQuery);
  713.             stm.setLong(1, idPlugin);
  714.             stm.setString(2, nome);
  715.             rs = stm.executeQuery();
  716.             if(rs.next()) {
  717.                     
  718.                 archivio = new RegistroPluginArchivio();
  719.                 archivio.setNome(rs.getString("nome"));
  720.                 archivio.setData(rs.getTimestamp("data"));
  721.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  722.                 archivio.setSorgente( DriverConfigurazioneDBLib.getEnumPluginSorgenteArchivio(rs.getString("sorgente")));
  723.                 switch (archivio.getSorgente()) {
  724.                 case JAR:
  725.                     archivio.setContenuto(jdbcAdapter.getBinaryData(rs, "contenuto"));
  726.                     break;
  727.                 case URL:
  728.                     archivio.setUrl(rs.getString("url"));
  729.                     break;
  730.                 case DIR:
  731.                     archivio.setDir(rs.getString("dir"));
  732.                     break;
  733.                 }
  734.     
  735.             }
  736.             rs.close();
  737.             stm.close();
  738.             rs=null;
  739.             stm=null;

  741.     
  742.         }catch (DriverConfigurazioneNotFound notFound) {
  743.             throw notFound;
  744.         }catch (SQLException se) {
  745.             throw new DriverConfigurazioneException("[getRegistroPluginArchivio]  SqlException: " + se.getMessage(),se);
  746.         }catch (Exception se) {
  747.             throw new DriverConfigurazioneException("[getRegistroPluginArchivio]  Exception: " + se.getMessage(),se);
  748.         }
  749.         finally {
  750.             JDBCUtilities.closeResources(rs, stm);
  751.             this.driver.closeConnection(con);
  752.         }

  754.         if(archivio!=null) {
  755.             archivio.setNomePlugin(nomePlugin);
  756.             return archivio;
  757.         }
  758.         throw new DriverConfigurazioneNotFound("Archivio '"+nome+"' non esistente nel plugin '"+nomePlugin+"'");
  759.     }
  760.     
  761.     protected boolean existsRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  763.         Connection con = null;
  764.         PreparedStatement stm = null;
  765.         ResultSet rs = null;
  766.         
  767.         String sqlQuery = "";

  769.         if (this.driver.atomica) {
  770.             try {
  771.                 con = this.driver.getConnectionFromDatasource("existsRegistroPluginArchivio");
  772.             } catch (Exception e) {
  773.                 throw new DriverConfigurazioneException("[existsRegistroPluginArchivio] Exception accedendo al datasource :" + e.getMessage(),e);

  775.             }
  776.         } else
  777.             con = this.driver.globalConnection;

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

  781.         int count = -1;
  782.         
  783.         try {
  784.             long idPlugin = DBUtils.getIdRegistroPlugin(nomePlugin, con, this.driver.tipoDB);
  785.             if(idPlugin<=0) {
  786.                 throw new DriverConfigurazioneNotFound("Plugin '"+nomePlugin+"' non esistente");
  787.             }
  788.             
  789.             if(nome==null) {
  790.                 throw new DriverConfigurazioneException("Nome archivio non indicato");
  791.             }
  792.             
  793.             // archive jar
  794.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  795.             sqlQueryObject.addSelectCountField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE+".id", "cont");
  796.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  797.             sqlQueryObject.addWhereCondition("id_plugin=?");
  798.             sqlQueryObject.addWhereCondition("nome=?");
  799.             sqlQueryObject.setANDLogicOperator(true);
  800.             sqlQuery = sqlQueryObject.createSQLQuery();
  801.             
  802.             stm = con.prepareStatement(sqlQuery);
  803.             stm.setLong(1, idPlugin);
  804.             stm.setString(2, nome);
  805.             rs = stm.executeQuery();
  806.             if(rs.next()) {
  807.                     
  808.                 count = rs.getInt(1);
  809.     
  810.             }
  811.             rs.close();
  812.             stm.close();
  813.             rs=null;
  814.             stm=null;
  815.             
  816.             return count > 0;
  817.         } catch (SQLException se) {
  818.             throw new DriverConfigurazioneException("[existsRegistroPluginArchivio]  SqlException: " + se.getMessage(),se);
  819.         }catch (Exception se) {
  820.             throw new DriverConfigurazioneException("[existsRegistroPluginArchivio]  Exception: " + se.getMessage(),se);
  821.         } finally {
  822.             JDBCUtilities.closeResources(rs, stm);
  823.             this.driver.closeConnection(con);
  824.         }
  825.     }
  826.     
  827.     protected boolean existsRegistroPluginArchivio(String nomePlugin, PluginSorgenteArchivio tipoSorgente, String sorgente) throws DriverConfigurazioneException, DriverConfigurazioneNotFound{

  829.         Connection con = null;
  830.         PreparedStatement stm = null;
  831.         ResultSet rs = null;
  832.         
  833.         String sqlQuery = "";

  835.         if (this.driver.atomica) {
  836.             try {
  837.                 con = this.driver.getConnectionFromDatasource("existsRegistroPluginArchivio");
  838.             } catch (Exception e) {
  839.                 throw new DriverConfigurazioneException("[existsRegistroPluginArchivio] Exception accedendo al datasource :" + e.getMessage(),e);

  841.             }
  842.         } else
  843.             con = this.driver.globalConnection;

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

  847.         int count = -1;
  848.         
  849.         try {
  850.             long idPlugin = DBUtils.getIdRegistroPlugin(nomePlugin, con, this.driver.tipoDB);
  851.             if(idPlugin<=0) {
  852.                 throw new DriverConfigurazioneNotFound("Plugin '"+nomePlugin+"' non esistente");
  853.             }
  854.             
  855.             if(tipoSorgente==null) {
  856.                 throw new DriverConfigurazioneException("TipoSorgente non indicata");
  857.             }
  858.             if(sorgente==null) {
  859.                 throw new DriverConfigurazioneException("Sorgente non indicata");
  860.             }
  861.             
  862.             // archive jar
  863.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  864.             sqlQueryObject.addSelectCountField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE+".id", "cont");
  865.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  866.             sqlQueryObject.addWhereCondition("id_plugin=?");
  867.             switch (tipoSorgente) {
  868.             case JAR:
  869.                 sqlQueryObject.addWhereCondition("nome=?");
  870.                 break;
  871.             case DIR:
  872.                 sqlQueryObject.addWhereCondition("dir=?");
  873.                 break;
  874.             case URL:
  875.                 sqlQueryObject.addWhereCondition("url=?");
  876.                 break;
  877.             default:
  878.                 break;
  879.             }
  880.             
  881.             sqlQueryObject.setANDLogicOperator(true);
  882.             sqlQuery = sqlQueryObject.createSQLQuery();
  883.             
  884.             stm = con.prepareStatement(sqlQuery);
  885.             stm.setLong(1, idPlugin);
  886.             stm.setString(2, sorgente);
  887.             rs = stm.executeQuery();
  888.             if(rs.next()) {
  889.                     
  890.                 count = rs.getInt(1);
  891.     
  892.             }
  893.             rs.close();
  894.             stm.close();
  895.             rs=null;
  896.             stm=null;
  897.             
  898.             return count > 0;
  899.         } catch (SQLException se) {
  900.             throw new DriverConfigurazioneException("[existsRegistroPluginArchivio]  SqlException: " + se.getMessage(),se);
  901.         }catch (Exception se) {
  902.             throw new DriverConfigurazioneException("[existsRegistroPluginArchivio]  Exception: " + se.getMessage(),se);
  903.         } finally {
  904.             JDBCUtilities.closeResources(rs, stm);
  905.             this.driver.closeConnection(con);
  906.         }
  907.     }
  908.     
  909.     protected void createRegistroPluginArchivio(String nomePlugin, RegistroPluginArchivio plugin) throws DriverConfigurazioneException{
  910.         Connection con = null;
  911.         boolean error = false;

  913.         if (this.driver.atomica) {
  914.             try {
  915.                 con = this.driver.getConnectionFromDatasource("createRegistroPluginArchivio");
  916.                 con.setAutoCommit(false);
  917.             } catch (Exception e) {
  918.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRegistroPluginArchivio] Exception accedendo al datasource :" + e.getMessage(),e);

  920.             }

  922.         } else
  923.             con = this.driver.globalConnection;

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

  927.         try {
  928.             this.driver.logDebug("CRUDRegistroPlugin type = 1");
  929.             DriverConfigurazioneDB_pluginsLIB.CRUDRegistroPluginArchivio(1, nomePlugin, plugin, con);

  931.         } catch (Exception qe) {
  932.             error = true;
  933.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRegistroPluginArchivio] Errore durante la createRegistroPluginArchivio : " + qe.getMessage(),qe);
  934.         } finally {

  936.             this.driver.closeConnection(error,con);
  937.         }
  938.     }
  939.     
  940.     protected void updateRegistroPluginArchivio(String nomePlugin, RegistroPluginArchivio plugin) throws DriverConfigurazioneException{
  941.         Connection con = null;
  942.         boolean error = false;

  944.         if (this.driver.atomica) {
  945.             try {
  946.                 con = this.driver.getConnectionFromDatasource("updateRegistroPluginArchivio");
  947.                 con.setAutoCommit(false);
  948.             } catch (Exception e) {
  949.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateRegistroPluginArchivio] Exception accedendo al datasource :" + e.getMessage(),e);

  951.             }

  953.         } else
  954.             con = this.driver.globalConnection;

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

  958.         try {
  959.             this.driver.logDebug("CRUDRegistroPlugin type = 2");
  960.             DriverConfigurazioneDB_pluginsLIB.CRUDRegistroPluginArchivio(2, nomePlugin, plugin, con);

  962.         } catch (Exception qe) {
  963.             error = true;
  964.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateRegistroPluginArchivio] Errore durante la updateRegistroPluginArchivio : " + qe.getMessage(),qe);
  965.         } finally {

  967.             this.driver.closeConnection(error,con);
  968.         }
  969.     }
  970.     
  971.     protected void deleteRegistroPluginArchivio(String nomePlugin, RegistroPluginArchivio plugin) throws DriverConfigurazioneException{
  972.         Connection con = null;
  973.         boolean error = false;

  975.         if (this.driver.atomica) {
  976.             try {
  977.                 con = this.driver.getConnectionFromDatasource("deleteRegistroPluginArchivio");
  978.                 con.setAutoCommit(false);
  979.             } catch (Exception e) {
  980.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRegistroPluginArchivio] Exception accedendo al datasource :" + e.getMessage(),e);

  982.             }

  984.         } else
  985.             con = this.driver.globalConnection;

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

  989.         try {
  990.             this.driver.logDebug("CRUDRegistroPlugin type = 3");
  991.             DriverConfigurazioneDB_pluginsLIB.CRUDRegistroPluginArchivio(3, nomePlugin, plugin, con);

  993.         } catch (Exception qe) {
  994.             error = true;
  995.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRegistroPluginArchivio] Errore durante la deleteRegistroPluginArchivio : " + qe.getMessage(),qe);
  996.         } finally {

  998.             this.driver.closeConnection(error,con);
  999.         }
  1000.     }
  1001.     
  1002.     protected List<RegistroPlugin> pluginsArchiviList(ISearch ricerca) throws DriverConfigurazioneException {
  1003.         String nomeMetodo = "pluginsArchiviList";
  1004.         int idLista = Liste.CONFIGURAZIONE_PLUGINS_ARCHIVI;
  1005.         int offset;
  1006.         int limit;
  1007.         String queryString;
  1008.         String search;

  1010.         limit = ricerca.getPageSize(idLista);
  1011.         offset = ricerca.getIndexIniziale(idLista);
  1012.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  1014.         Connection con = null;
  1015.         PreparedStatement stmt=null;
  1016.         ResultSet risultato=null;
  1017.         ArrayList<RegistroPlugin> lista = new ArrayList<>();

  1019.         if (this.driver.atomica) {
  1020.             try {
  1021.                 con = this.driver.getConnectionFromDatasource("pluginsArchiviList");
  1022.             } catch (Exception e) {
  1023.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1025.             }

  1027.         } else
  1028.             con = this.driver.globalConnection;

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

  1032.         try {

  1034.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1035.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  1036.             sqlQueryObject.addSelectCountField("id", "cont");
  1037.             
  1038.             if (!search.equals("")) {
  1039.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  1040.             }
  1041.             
  1042.             queryString = sqlQueryObject.createSQLQuery();
  1043.             stmt = con.prepareStatement(queryString);
  1044.             risultato = stmt.executeQuery();
  1045.             if (risultato.next())
  1046.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  1047.             risultato.close();
  1048.             stmt.close();

  1050.             // ricavo le entries
  1051.             if (limit == 0) // con limit
  1052.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  1054.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1055.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  1056.             sqlQueryObject.addSelectField("id");
  1057.             sqlQueryObject.addSelectField("nome");            
  1058.             sqlQueryObject.addSelectField("posizione");       
  1059.             sqlQueryObject.addSelectField("stato");           
  1060.             sqlQueryObject.addSelectField("descrizione");     
  1061.             sqlQueryObject.addSelectField("data");         
  1062.             sqlQueryObject.addSelectField("compatibilita");          
  1063.             
  1064.             if (!search.equals("")) {
  1065.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  1066.             }
  1067.             sqlQueryObject.addOrderBy("posizione");
  1068.             sqlQueryObject.addOrderBy("nome");
  1069.             sqlQueryObject.setSortType(true);
  1070.             sqlQueryObject.setLimit(limit);
  1071.             sqlQueryObject.setOffset(offset);
  1072.             queryString = sqlQueryObject.createSQLQuery();
  1073.             stmt = con.prepareStatement(queryString);
  1074.             risultato = stmt.executeQuery();

  1076.             
  1077.             while (risultato.next()) { 
  1078.                 RegistroPlugin regola = new RegistroPlugin();
  1079.                 regola.setId(risultato.getLong("id"));
  1080.                 regola.setNome(risultato.getString("nome"));
  1081.                 regola.setPosizione(risultato.getInt("posizione"));
  1082.                 regola.setStato(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(risultato.getString("stato")));
  1083.                 regola.setDescrizione(risultato.getString("descrizione"));
  1084.                 Timestamp timestamp = risultato.getTimestamp("data");
  1085.                 regola.setData(new Date(timestamp.getTime()));
  1086.                 
  1087.                 String compatibilita = risultato.getString("compatibilita");
  1088.                 if(compatibilita != null)
  1089.                     regola.setCompatibilitaList(Arrays.asList(compatibilita.split(",")));
  1090.                 
  1091.                 lista.add(regola);
  1092.             
  1093.             }
  1094.             risultato.close();
  1095.             stmt.close();
  1096.             
  1097.             return lista;

  1099.         } catch (Exception qe) {
  1100.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1101.         } finally {

  1103.             //Chiudo statement and resultset
  1104.             JDBCUtilities.closeResources(risultato, stmt);

  1106.             this.driver.closeConnection(con);
  1107.         }
  1108.     }
  1109.     protected List<RegistroPluginArchivio> pluginsArchiviJarList(String nome, ISearch ricerca) throws DriverConfigurazioneException {
  1110.         return this.pluginsArchiviJarList(nome, ricerca, true);
  1111.     }
  1112.     
  1113.     private List<RegistroPluginArchivio> pluginsArchiviJarList(String nome, ISearch ricerca, boolean escludiContenuto) throws DriverConfigurazioneException {
  1114.         String nomeMetodo = "pluginsArchiviList";
  1115.         int idLista = Liste.CONFIGURAZIONE_PLUGINS_ARCHIVI_JAR;
  1116.         int offset;
  1117.         int limit;
  1118.         String queryString;
  1119.         String search;

  1121.         limit = ricerca.getPageSize(idLista);
  1122.         offset = ricerca.getIndexIniziale(idLista);
  1123.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  1125.         Connection con = null;
  1126.         PreparedStatement stmt=null;
  1127.         ResultSet risultato=null;
  1128.         ArrayList<RegistroPluginArchivio> lista = new ArrayList<>();

  1130.         if (this.driver.atomica) {
  1131.             try {
  1132.                 con = this.driver.getConnectionFromDatasource("pluginsArchiviList");
  1133.             } catch (Exception e) {
  1134.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  1136.             }

  1138.         } else
  1139.             con = this.driver.globalConnection;

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

  1143.         try {

  1145.             ISQLQueryObject sqlQueryObjectOr = null;
  1146.             if (!search.equals("")) {
  1147.                 ISQLQueryObject sqlQueryObjectJar = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1148.                 sqlQueryObjectJar.addWhereLikeCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".nome", search, true, true);
  1149.                 sqlQueryObjectJar.addWhereCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".sorgente = ?");
  1150.                 sqlQueryObjectJar.setANDLogicOperator(true);    
  1151.                 
  1152.                 ISQLQueryObject sqlQueryObjectUrl = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1153.                 sqlQueryObjectUrl.addWhereLikeCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".url", search, true, true);
  1154.                 sqlQueryObjectUrl.addWhereCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".sorgente = ?");
  1155.                 sqlQueryObjectUrl.setANDLogicOperator(true);    
  1156.                 
  1157.                 ISQLQueryObject sqlQueryObjectDir = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1158.                 sqlQueryObjectDir.addWhereLikeCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".dir", search, true, true);
  1159.                 sqlQueryObjectDir.addWhereCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".sorgente = ?");
  1160.                 sqlQueryObjectDir.setANDLogicOperator(true);    
  1161.                 
  1162.                 sqlQueryObjectOr = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1163.                 sqlQueryObjectOr.setANDLogicOperator(false);    
  1164.                 sqlQueryObjectOr.addWhereCondition(sqlQueryObjectJar.createSQLConditions());
  1165.                 sqlQueryObjectOr.addWhereCondition(sqlQueryObjectUrl.createSQLConditions());
  1166.                 sqlQueryObjectOr.addWhereCondition(sqlQueryObjectDir.createSQLConditions());
  1167.             }
  1168.             
  1169.             
  1170.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1171.             sqlQueryObject.addSelectCountField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE+".id", "cont");
  1172.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  1173.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  1174.             sqlQueryObject.addWhereCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".id_plugin = " + CostantiDB.REGISTRO_PLUGINS + ".id");
  1175.             sqlQueryObject.addWhereCondition(CostantiDB.REGISTRO_PLUGINS + ".nome=?");
  1176.             sqlQueryObject.setANDLogicOperator(true);
  1177.             
  1178.             if (sqlQueryObjectOr!=null) {
  1179.                 sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  1180.             }
  1181.             
  1182.             queryString = sqlQueryObject.createSQLQuery();
  1183.             stmt = con.prepareStatement(queryString);
  1184.             int parameterIndex = 1;
  1185.             stmt.setString(parameterIndex ++, nome);
  1186.             if (sqlQueryObjectOr!=null) {
  1187.                 stmt.setString(parameterIndex ++, DriverConfigurazioneDBLib.getValue(PluginSorgenteArchivio.JAR));
  1188.                 stmt.setString(parameterIndex ++, DriverConfigurazioneDBLib.getValue(PluginSorgenteArchivio.URL));
  1189.                 stmt.setString(parameterIndex ++, DriverConfigurazioneDBLib.getValue(PluginSorgenteArchivio.DIR));
  1190.             }
  1191.             risultato = stmt.executeQuery();
  1192.             if (risultato.next())
  1193.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  1194.             risultato.close();
  1195.             stmt.close();

  1197.             // ricavo le entries
  1198.             if (limit == 0) // con limit
  1199.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  1201.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  1202.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  1203.             sqlQueryObject.addFromTable(CostantiDB.REGISTRO_PLUGINS);
  1204.             sqlQueryObject.addWhereCondition(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".id_plugin = " + CostantiDB.REGISTRO_PLUGINS + ".id");
  1205.             sqlQueryObject.addWhereCondition(CostantiDB.REGISTRO_PLUGINS + ".nome=?");
  1206.             sqlQueryObject.setANDLogicOperator(true);
  1207.             
  1208.             if (sqlQueryObjectOr!=null) {
  1209.                 sqlQueryObject.addWhereCondition(sqlQueryObjectOr.createSQLConditions());
  1210.             }
  1211.             
  1212.             sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".id");
  1213.             sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".nome");            
  1214.             sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".data");       
  1215.             sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".sorgente");   
  1216.             
  1217.             if(!escludiContenuto) {
  1218.                 sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".contenuto");     
  1219.             }
  1220.             sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".url");         
  1221.             sqlQueryObject.addSelectField(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".dir");
  1222.                         
  1223.             sqlQueryObject.addOrderBy(CostantiDB.REGISTRO_PLUGINS_ARCHIVE + ".data");
  1224.             sqlQueryObject.setSortType(true);
  1225.             sqlQueryObject.setLimit(limit);
  1226.             sqlQueryObject.setOffset(offset);
  1227.             queryString = sqlQueryObject.createSQLQuery();
  1228.             stmt = con.prepareStatement(queryString);
  1229.             parameterIndex = 1;
  1230.             stmt.setString(parameterIndex ++, nome);
  1231.             if (sqlQueryObjectOr!=null) {
  1232.                 stmt.setString(parameterIndex ++, DriverConfigurazioneDBLib.getValue(PluginSorgenteArchivio.JAR));
  1233.                 stmt.setString(parameterIndex ++, DriverConfigurazioneDBLib.getValue(PluginSorgenteArchivio.URL));
  1234.                 stmt.setString(parameterIndex ++, DriverConfigurazioneDBLib.getValue(PluginSorgenteArchivio.DIR));
  1235.             }
  1236.             risultato = stmt.executeQuery();

  1238.             
  1239.             while (risultato.next()) { 
  1240.                 RegistroPluginArchivio archivio = new RegistroPluginArchivio();
  1241.                 archivio.setNome(risultato.getString("nome"));
  1242.                 archivio.setNomePlugin(nome);
  1243.                 Timestamp timestamp = risultato.getTimestamp("data");
  1244.                 archivio.setData(new Date(timestamp.getTime()));
  1245.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(this.driver.tipoDB);
  1246.                 archivio.setSorgente( DriverConfigurazioneDBLib.getEnumPluginSorgenteArchivio(risultato.getString("sorgente")));
  1247.                 switch (archivio.getSorgente()) {
  1248.                 case JAR:
  1249.                     if(!escludiContenuto) {
  1250.                         archivio.setContenuto(jdbcAdapter.getBinaryData(risultato, "contenuto"));
  1251.                     }
  1252.                     break;
  1253.                 case URL:
  1254.                     archivio.setUrl(risultato.getString("url"));
  1255.                     break;
  1256.                 case DIR:
  1257.                     archivio.setDir(risultato.getString("dir"));
  1258.                     break;
  1259.                 }
  1260.                 lista.add(archivio);
  1261.             }
  1262.             risultato.close();
  1263.             stmt.close();
  1264.             
  1265.             return lista;

  1267.         } catch (Exception qe) {
  1268.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1269.         } finally {

  1271.             //Chiudo statement and resultset
  1272.             JDBCUtilities.closeResources(risultato, stmt);

  1274.             this.driver.closeConnection(con);
  1275.         }
  1276.     }
  1277. }
Created with JaCoCo 0.8.8.202204050719