DriverConfigurazioneDB_pluginsLIB.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 static org.openspcoop2.core.constants.CostantiDB.CREATE;
  23. import static org.openspcoop2.core.constants.CostantiDB.DELETE;
  24. import static org.openspcoop2.core.constants.CostantiDB.UPDATE;

  26. import java.sql.Connection;
  27. import java.sql.PreparedStatement;
  28. import java.sql.ResultSet;
  29. import java.sql.SQLException;
  30. import java.sql.Timestamp;
  31. import java.util.ArrayList;
  32. import java.util.List;

  34. import org.openspcoop2.core.commons.DBUtils;
  35. import org.openspcoop2.core.config.RegistroPlugin;
  36. import org.openspcoop2.core.config.RegistroPluginArchivio;
  37. import org.openspcoop2.core.config.constants.PluginSorgenteArchivio;
  38. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  39. import org.openspcoop2.core.constants.CostantiDB;
  40. import org.openspcoop2.utils.TipiDatabase;
  41. import org.openspcoop2.utils.date.DateManager;
  42. import org.openspcoop2.utils.jdbc.CustomKeyGeneratorObject;
  43. import org.openspcoop2.utils.jdbc.IJDBCAdapter;
  44. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKey;
  45. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyJDBCType;
  46. import org.openspcoop2.utils.jdbc.InsertAndGeneratedKeyObject;
  47. import org.openspcoop2.utils.jdbc.JDBCAdapterFactory;
  48. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  49. import org.openspcoop2.utils.sql.ISQLQueryObject;
  50. import org.openspcoop2.utils.sql.SQLObjectFactory;

  52. /**
  53.  * DriverConfigurazioneDB_pluginLIB
  54.  * 
  55.  * @author Stefano Corallo - corallo@link.it
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  */
  59. public class DriverConfigurazioneDB_pluginsLIB {


  62.     
  63.     
  64.     
  65.     public static void CRUDRegistroPlugin(int type, RegistroPlugin plugin, Connection con) throws DriverConfigurazioneException {
  66.         if (plugin == null)
  67.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] Il plugin non possono essere NULL");
  68.         PreparedStatement updateStmt = null;
  69.         String updateQuery = "";
  70.         PreparedStatement selectStmt = null;
  71.         //String selectQuery = "";
  72.         ResultSet selectRS = null;
  73.         

  75.         try {
  76.             
  77.             if(plugin.getNome()==null) {
  78.                 throw new DriverConfigurazioneException("Nome non fornito");
  79.             }
  80.             
  81.             // Recupero id generic properties
  82.             long idParent = -1;
  83.             if(type == CostantiDB.UPDATE || type == CostantiDB.DELETE) {
  84.                 
  85.                 idParent = DBUtils.getIdRegistroPlugin(plugin.getNome(), con, DriverConfigurazioneDBLib.tipoDB);
  86.                 if(idParent<=0) {
  87.                     throw new DriverConfigurazioneException("Plugin con nome '"+plugin.getNome()+"' non trovato");
  88.                 }
  89.                 
  90.                 // Elimino anche gli archivi (nell'update le ricreo)
  91.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  92.                 sqlQueryObject.addDeleteTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  93.                 sqlQueryObject.addWhereCondition("id_plugin=?");
  94.                 sqlQueryObject.setANDLogicOperator(true);
  95.                 updateQuery = sqlQueryObject.createSQLDelete();
  96.                 updateStmt = con.prepareStatement(updateQuery);
  97.                 updateStmt.setLong(1, idParent);
  98.                 updateStmt.executeUpdate();
  99.                 updateStmt.close();

  101.                 // delete
  102.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  103.                 sqlQueryObject.addDeleteTable(CostantiDB.REGISTRO_PLUGINS);
  104.                 sqlQueryObject.addWhereCondition("id=?");
  105.                 updateQuery = sqlQueryObject.createSQLDelete();
  106.                 updateStmt = con.prepareStatement(updateQuery);
  107.                 updateStmt.setLong(1, idParent);
  108.                 updateStmt.executeUpdate();
  109.                 updateStmt.close();
  110.             }
  111.             

  113.             switch (type) {
  114.             case CREATE:
  115.             case UPDATE:
  116.         
  117.                 // insert

  119.                 List<InsertAndGeneratedKeyObject> listInsertAndGeneratedKeyObject = new ArrayList<>();
  120.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("nome", plugin.getNome() , InsertAndGeneratedKeyJDBCType.STRING) );
  121.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("posizione", plugin.getPosizione() , InsertAndGeneratedKeyJDBCType.INT) );
  122.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("stato",  DriverConfigurazioneDBLib.getValue(plugin.getStato()) , InsertAndGeneratedKeyJDBCType.STRING) );
  123.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("descrizione", plugin.getDescrizione() , InsertAndGeneratedKeyJDBCType.STRING) );
  124.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("data", plugin.getData() , InsertAndGeneratedKeyJDBCType.TIMESTAMP) );
  125.                 String compatibilita = null;
  126.                 if(plugin.sizeCompatibilitaList()>0) {
  127.                     StringBuilder bf = new StringBuilder();
  128.                     for (int i = 0; i < plugin.sizeCompatibilitaList(); i++) {
  129.                         if(i>0) {
  130.                             bf.append(",");
  131.                         }
  132.                         bf.append(plugin.getCompatibilita(i));
  133.                     }
  134.                     if(bf.length()>0) {
  135.                         compatibilita = bf.toString();
  136.                     }
  137.                 }
  138.                 listInsertAndGeneratedKeyObject.add( new InsertAndGeneratedKeyObject("compatibilita", compatibilita , InsertAndGeneratedKeyJDBCType.STRING) );
  139.                             
  140.                 long idPlugin = InsertAndGeneratedKey.insertAndReturnGeneratedKey(con, TipiDatabase.toEnumConstant(DriverConfigurazioneDBLib.tipoDB), 
  141.                         new CustomKeyGeneratorObject(CostantiDB.REGISTRO_PLUGINS, CostantiDB.REGISTRO_PLUGINS_COLUMN_ID, 
  142.                                 CostantiDB.REGISTRO_PLUGINS_SEQUENCE, CostantiDB.REGISTRO_PLUGINS_TABLE_FOR_ID),
  143.                         listInsertAndGeneratedKeyObject.toArray(new InsertAndGeneratedKeyObject[1]));
  144.                 if(idPlugin<=0){
  145.                     throw new Exception("ID (RegistroPlugins) autoincrementale non ottenuto");
  146.                 }

  148.                 for(int l=0; l<plugin.sizeArchivioList();l++){
  149.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  150.                     sqlQueryObject.addInsertTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  151.                     sqlQueryObject.addInsertField("id_plugin", "?");
  152.                     sqlQueryObject.addInsertField("nome", "?");
  153.                     sqlQueryObject.addInsertField("data", "?");
  154.                     sqlQueryObject.addInsertField("sorgente", "?");
  155.                     sqlQueryObject.addInsertField("contenuto", "?");
  156.                     sqlQueryObject.addInsertField("url", "?");
  157.                     sqlQueryObject.addInsertField("dir", "?");
  158.                     updateQuery = sqlQueryObject.createSQLInsert();
  159.                     updateStmt = con.prepareStatement(updateQuery);
  160.                     int index = 1;
  161.                     updateStmt.setLong(index++, idPlugin);
  162.                     updateStmt.setString(index++, plugin.getArchivio(l).getNome());
  163.                     
  164.                     Timestamp t = DateManager.getTimestamp();
  165.                     if( plugin.getArchivio(l).getData()!=null ) {
  166.                         t = new Timestamp( plugin.getArchivio(l).getData().getTime() );
  167.                     }
  168.                     updateStmt.setTimestamp(index++, t);
  169.                     
  170.                     PluginSorgenteArchivio sorgente = plugin.getArchivio(l).getSorgente();
  171.                     updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(sorgente));
  172.                     IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  173.                     byte[] archivio = null;
  174.                     String url = null;
  175.                     String dir = null;
  176.                     switch (sorgente) {
  177.                     case JAR:
  178.                         archivio = plugin.getArchivio(l).getContenuto();
  179.                         break;
  180.                     case URL:
  181.                         url = plugin.getArchivio(l).getUrl();
  182.                         break;
  183.                     case DIR:
  184.                         dir = plugin.getArchivio(l).getDir();
  185.                         break;
  186.                     }
  187.                     jdbcAdapter.setBinaryData(updateStmt, index++, archivio);
  188.                     updateStmt.setString(index++, url);
  189.                     updateStmt.setString(index++, dir);
  190.                     
  191.                     updateStmt.executeUpdate();
  192.                     updateStmt.close();
  193.                 }

  195.                 break;
  196.             case DELETE:
  197.                 // non rimuovo in quanto gia fatto sopra.
  198.                 break;
  199.             }


  202.         } catch (SQLException se) {
  203.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] SQLException [" + se.getMessage() + "].",se);
  204.         }catch (Exception se) {
  205.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] Exception [" + se.getMessage() + "].",se);
  206.         } finally {

  208.             JDBCUtilities.closeResources(selectRS, selectStmt);
  209.             JDBCUtilities.closeResources(updateStmt);
  210.         }

  212.     }
  213.     
  214.     public static void updateDatiRegistroPlugin(String nome, RegistroPlugin plugin, Connection con) throws DriverConfigurazioneException{
  215.         if (plugin == null)
  216.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] Il plugin non possono essere NULL");
  217.         PreparedStatement updateStmt = null;
  218.         String updateQuery = "";
  219.         PreparedStatement selectStmt = null;
  220.         ResultSet selectRS = null;
  221.     
  222.         try {
  223.             
  224.             long idParent = DBUtils.getIdRegistroPlugin(nome, con, DriverConfigurazioneDBLib.tipoDB);
  225.             if(idParent<=0) {
  226.                 throw new DriverConfigurazioneException("Plugin con nome '"+nome+"' non trovato");
  227.             }
  228.             
  229.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  230.             sqlQueryObject.addUpdateTable(CostantiDB.REGISTRO_PLUGINS);
  231.             sqlQueryObject.addUpdateField("nome", "?");
  232.             sqlQueryObject.addUpdateField("posizione", "?");
  233.             sqlQueryObject.addUpdateField("stato", "?");
  234.             sqlQueryObject.addUpdateField("descrizione", "?");
  235.             sqlQueryObject.addUpdateField("data", "?");
  236.             sqlQueryObject.addUpdateField("compatibilita", "?");
  237.             sqlQueryObject.addWhereCondition("id=?");
  238.             sqlQueryObject.setANDLogicOperator(true);
  239.             
  240.             updateQuery = sqlQueryObject.createSQLUpdate();
  241.             updateStmt = con.prepareStatement(updateQuery);
  242.             int index = 1;
  243.             updateStmt.setString(index++, plugin.getNome());
  244.             updateStmt.setInt(index++, plugin.getPosizione());
  245.             updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(plugin.getStato()));
  246.             updateStmt.setString(index++, plugin.getDescrizione());
  247.             
  248.             Timestamp t = DateManager.getTimestamp();
  249.             if( plugin.getData()!=null ) {
  250.                 t = new Timestamp( plugin.getData().getTime() );
  251.             }
  252.             updateStmt.setTimestamp(index++, t);
  253.             
  254.             String compatibilita = null;
  255.             if(plugin.sizeCompatibilitaList()>0) {
  256.                 StringBuilder bf = new StringBuilder();
  257.                 for (int i = 0; i < plugin.sizeCompatibilitaList(); i++) {
  258.                     if(i>0) {
  259.                         bf.append(",");
  260.                     }
  261.                     bf.append(plugin.getCompatibilita(i));
  262.                 }
  263.                 if(bf.length()>0) {
  264.                     compatibilita = bf.toString();
  265.                 }
  266.             }
  267.             updateStmt.setString(index++, compatibilita);
  268.                     
  269.             updateStmt.setLong(index++, idParent);
  270.     
  271.             updateStmt.executeUpdate();
  272.             updateStmt.close();
  273.             updateStmt=null;

  275.         } catch (SQLException se) {
  276.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] SQLException [" + se.getMessage() + "].",se);
  277.         }catch (Exception se) {
  278.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPlugin] Exception [" + se.getMessage() + "].",se);
  279.         } finally {

  281.             JDBCUtilities.closeResources(selectRS, selectStmt);
  282.             JDBCUtilities.closeResources(updateStmt);
  283.         }
  284.     }
  285.     
  286.     public static void CRUDRegistroPluginArchivio(int type, String nomePlugin, RegistroPluginArchivio plugin, Connection con) throws DriverConfigurazioneException {
  287.         if (plugin == null)
  288.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPluginArchivio] Il plugin non possono essere NULL");
  289.         PreparedStatement updateStmt = null;
  290.         String updateQuery = "";
  291.         PreparedStatement selectStmt = null;
  292.         //String selectQuery = "";
  293.         ResultSet selectRS = null;
  294.         

  296.         try {
  297.             
  298.             long idParent = DBUtils.getIdRegistroPlugin(nomePlugin, con, DriverConfigurazioneDBLib.tipoDB);
  299.             if(idParent<=0) {
  300.                 throw new DriverConfigurazioneException("Plugin con nome '"+nomePlugin+"' non trovato");
  301.             }
  302.             
  303.             switch (type) {
  304.             case CREATE:
  305.                 
  306.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  307.                 sqlQueryObject.addInsertTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  308.                 sqlQueryObject.addInsertField("id_plugin", "?");
  309.                 sqlQueryObject.addInsertField("nome", "?");
  310.                 sqlQueryObject.addInsertField("data", "?");
  311.                 sqlQueryObject.addInsertField("sorgente", "?");
  312.                 sqlQueryObject.addInsertField("contenuto", "?");
  313.                 sqlQueryObject.addInsertField("url", "?");
  314.                 sqlQueryObject.addInsertField("dir", "?");
  315.                 updateQuery = sqlQueryObject.createSQLInsert();
  316.                 updateStmt = con.prepareStatement(updateQuery);
  317.                 int index = 1;
  318.                 updateStmt.setLong(index++, idParent);
  319.                 updateStmt.setString(index++, plugin.getNome());
  320.                 
  321.                 Timestamp t = DateManager.getTimestamp();
  322.                 if( plugin.getData()!=null ) {
  323.                     t = new Timestamp( plugin.getData().getTime() );
  324.                 }
  325.                 updateStmt.setTimestamp(index++, t);
  326.                 
  327.                 PluginSorgenteArchivio sorgente = plugin.getSorgente();
  328.                 updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(sorgente));
  329.                 IJDBCAdapter jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  330.                 byte[] archivio = null;
  331.                 String url = null;
  332.                 String dir = null;
  333.                 switch (sorgente) {
  334.                 case JAR:
  335.                     archivio = plugin.getContenuto();
  336.                     break;
  337.                 case URL:
  338.                     url = plugin.getUrl();
  339.                     break;
  340.                 case DIR:
  341.                     dir = plugin.getDir();
  342.                     break;
  343.                 }
  344.                 jdbcAdapter.setBinaryData(updateStmt, index++, archivio);
  345.                 updateStmt.setString(index++, url);
  346.                 updateStmt.setString(index++, dir);
  347.                 
  348.                 updateStmt.executeUpdate();
  349.                 updateStmt.close();
  350.                 
  351.                 break;
  352.                 
  353.             case UPDATE:
  354.         
  355.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  356.                 sqlQueryObject.addUpdateTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  357.                 sqlQueryObject.addUpdateField("data", "?");
  358.                 sqlQueryObject.addUpdateField("sorgente", "?");
  359.                 sqlQueryObject.addUpdateField("contenuto", "?");
  360.                 sqlQueryObject.addUpdateField("url", "?");
  361.                 sqlQueryObject.addUpdateField("dir", "?");
  362.                 sqlQueryObject.addWhereCondition("id_plugin = ?");
  363.                 sqlQueryObject.addWhereCondition("nome = ?");
  364.                 sqlQueryObject.setANDLogicOperator(true);
  365.                 updateQuery = sqlQueryObject.createSQLUpdate();
  366.                 updateStmt = con.prepareStatement(updateQuery);
  367.                 index = 1;
  368.                 
  369.                 t = DateManager.getTimestamp();
  370.                 updateStmt.setTimestamp(index++, t);
  371.                 
  372.                 sorgente = plugin.getSorgente();
  373.                 updateStmt.setString(index++, DriverConfigurazioneDBLib.getValue(sorgente));
  374.                 jdbcAdapter = JDBCAdapterFactory.createJDBCAdapter(DriverConfigurazioneDBLib.tipoDB);
  375.                 archivio = null;
  376.                 url = null;
  377.                 dir = null;
  378.                 switch (sorgente) {
  379.                 case JAR:
  380.                     archivio = plugin.getContenuto();
  381.                     break;
  382.                 case URL:
  383.                     url = plugin.getUrl();
  384.                     break;
  385.                 case DIR:
  386.                     dir = plugin.getDir();
  387.                     break;
  388.                 }
  389.                 jdbcAdapter.setBinaryData(updateStmt, index++, archivio);
  390.                 updateStmt.setString(index++, url);
  391.                 updateStmt.setString(index++, dir);

  393.                 updateStmt.setLong(index++, idParent);
  394.                 updateStmt.setString(index++, plugin.getNome());
  395.                 updateStmt.executeUpdate();
  396.                 updateStmt.close();
  397.                 
  398.                 break;
  399.             case DELETE:
  400.                 
  401.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(DriverConfigurazioneDBLib.tipoDB);
  402.                 sqlQueryObject.addDeleteTable(CostantiDB.REGISTRO_PLUGINS_ARCHIVE);
  403.                 sqlQueryObject.addWhereCondition("id_plugin = ?");
  404.                 sqlQueryObject.addWhereCondition("nome = ?");
  405.                 sqlQueryObject.setANDLogicOperator(true);
  406.                 updateQuery = sqlQueryObject.createSQLDelete();
  407.                 updateStmt = con.prepareStatement(updateQuery);
  408.                 index = 1;
  409.                 updateStmt.setLong(index++, idParent);
  410.                 updateStmt.setString(index++, plugin.getNome());
  411.                 updateStmt.executeUpdate();
  412.                 updateStmt.close();
  413.                 
  414.                 break;
  415.             }


  418.         } catch (SQLException se) {
  419.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPluginArchivio] SQLException [" + se.getMessage() + "].",se);
  420.         }catch (Exception se) {
  421.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB_LIB::CRUDRegistroPluginArchivio] Exception [" + se.getMessage() + "].",se);
  422.         } finally {

  424.             JDBCUtilities.closeResources(selectRS, selectStmt);
  425.             JDBCUtilities.closeResources(updateStmt);
  426.         }

  428.     }
  429.     
  430. }
Created with JaCoCo 0.8.8.202204050719