DriverConfigurazioneDB_routingTableDriver.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.core.config.driver.db;

  22. import java.sql.Connection;
  23. import java.sql.PreparedStatement;
  24. import java.sql.ResultSet;
  25. import java.sql.SQLException;
  26. import java.util.ArrayList;
  27. import java.util.List;

  29. import org.openspcoop2.core.commons.DBUtils;
  30. import org.openspcoop2.core.commons.ISearch;
  31. import org.openspcoop2.core.commons.Liste;
  32. import org.openspcoop2.core.config.Route;
  33. import org.openspcoop2.core.config.RouteGateway;
  34. import org.openspcoop2.core.config.RouteRegistro;
  35. import org.openspcoop2.core.config.RoutingTable;
  36. import org.openspcoop2.core.config.RoutingTableDefault;
  37. import org.openspcoop2.core.config.RoutingTableDestinazione;
  38. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  39. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  40. import org.openspcoop2.core.constants.CostantiDB;
  41. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  42. import org.openspcoop2.utils.sql.ISQLQueryObject;
  43. import org.openspcoop2.utils.sql.SQLObjectFactory;

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

  56.     private DriverConfigurazioneDB driver = null;
  57.     
  58.     protected DriverConfigurazioneDB_routingTableDriver(DriverConfigurazioneDB driver) {
  59.         this.driver = driver;
  60.     }

  62.     
  63.     protected RoutingTable getRoutingTable() throws DriverConfigurazioneException {

  65.         Connection con = null;
  66.         PreparedStatement stm = null;
  67.         ResultSet rs = null;
  68.         PreparedStatement stmSearch = null;
  69.         ResultSet rsSearch = null;
  70.         String sqlQuery = "";

  72.         if (this.driver.atomica) {
  73.             try {
  74.                 con = this.driver.getConnectionFromDatasource("getRoutingTable");

  76.             } catch (Exception e) {
  77.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getRoutingTable] Exception accedendo al datasource :" + e.getMessage(),e);

  79.             }

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

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

  86.         try {
  87.             boolean routingEnabled = false;
  88.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  89.             sqlQueryObject.addFromTable(CostantiDB.CONFIGURAZIONE);
  90.             sqlQueryObject.addSelectField("*");
  91.             sqlQuery = sqlQueryObject.createSQLQuery();
  92.             this.driver.logDebug("eseguo query per routing enabled : " + DBUtils.formatSQLString(sqlQuery));
  93.             stm = con.prepareStatement(sqlQuery);

  95.             rs = stm.executeQuery();

  97.             if (rs.next()) {
  98.                 this.driver.logDebug("ConfigurazionePresente");
  99.                 this.driver.logDebug("Risultato query per routing enabled ["+rs.getString("routing_enabled")+"]");
  100.                 routingEnabled = CostantiConfigurazione.ABILITATO.equals(DriverConfigurazioneDBLib.getEnumStatoFunzionalita(rs.getString("routing_enabled")));
  101.             }
  102.             rs.close();
  103.             stm.close();
  104.             this.driver.logDebug("RoutingEnabled: "+routingEnabled);

  106.             RoutingTable rt = new RoutingTable();
  107.             rt.setAbilitata(routingEnabled);
  108.             //sia che il routing sia abilitato/disabilitato
  109.             //le rotte possono essere comunque presenti
  110.             //if (routingEnabled) {

  112.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  113.             sqlQueryObject.addFromTable(CostantiDB.ROUTING);
  114.             sqlQueryObject.addSelectField("*");
  115.             sqlQuery = sqlQueryObject.createSQLQuery();
  116.             this.driver.logDebug("eseguo query per routing table : " + DBUtils.formatSQLString(sqlQuery));
  117.             stm = con.prepareStatement(sqlQuery);

  119.             rs = stm.executeQuery();

  121.             String tipo = null;
  122.             String nome = null;
  123.             String tipoRotta = null;
  124.             String tiposoggrotta = null;
  125.             String nomesoggrotta = null;
  126.             long id_registrorotta = 0;
  127.             boolean is_default = false;
  128.             long idR = 0;

  130.             RoutingTableDefault rtdefault = null;
  131.             Route route = null;
  132.             RouteGateway routeGateway = null;
  133.             RouteRegistro routeRegistro = null;
  134.             RoutingTableDestinazione rtd = null;

  136.             int nroute = 0;
  137.             this.driver.logDebug("Check esistenza rotte....");
  138.             while (rs.next()) {

  140.                 this.driver.logDebug("Nuova rotta....["+rs.getInt("is_default")+"]");

  142.                 nroute++;
  143.                 // nuova route
  144.                 route = new Route();

  146.                 idR = rs.getLong("id");
  147.                 tipo = rs.getString("tipo");
  148.                 nome = rs.getString("nome");
  149.                 tipoRotta = rs.getString("tiporotta");
  150.                 nomesoggrotta = rs.getString("nomesoggrotta");
  151.                 tiposoggrotta = rs.getString("tiposoggrotta");
  152.                 id_registrorotta = rs.getLong("registrorotta");
  153.                 if(rs.getInt("is_default")==1)
  154.                     is_default = true;
  155.                 else
  156.                     is_default = false;

  158.                 if (tipoRotta.equalsIgnoreCase("registro")) {
  159.                     // e' una rotta registro
  160.                     routeRegistro = new RouteRegistro();

  162.                     // se e' 0 allora significa ke voglio tutte le rotte
  163.                     if (id_registrorotta != 0) {
  164.                         // mi serve il nome di questa rotta
  165.                         sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  166.                         sqlQueryObject.addFromTable(CostantiDB.REGISTRI);
  167.                         sqlQueryObject.addSelectField("*");
  168.                         sqlQueryObject.addWhereCondition("id = ?");
  169.                         sqlQuery = sqlQueryObject.createSQLQuery();
  170.                         stmSearch = con.prepareStatement(sqlQuery);
  171.                         stmSearch.setLong(1, id_registrorotta);

  173.                         this.driver.logDebug("eseguo query : " + DBUtils.formatSQLString(sqlQuery, id_registrorotta));

  175.                         rsSearch = stmSearch.executeQuery();
  176.                         if (rsSearch.next()) {
  177.                             routeRegistro.setNome(rsSearch.getString("nome"));

  179.                         }
  180.                         rsSearch.close();
  181.                         stmSearch.close();
  182.                     }

  184.                     route.setRegistro(routeRegistro);

  186.                 } else if (tipoRotta.equalsIgnoreCase("gateway")) {
  187.                     // e' una rotta gw
  188.                     routeGateway = new RouteGateway();

  190.                     routeGateway.setNome(nomesoggrotta);
  191.                     routeGateway.setTipo(tiposoggrotta);

  193.                     route.setGateway(routeGateway);
  194.                 }

  196.                 route.setId(idR);

  198.                 // e' di default
  199.                 if (is_default){
  200.                     if(rtdefault==null){
  201.                         rtdefault = new RoutingTableDefault();
  202.                         rt.setDefault(rtdefault);
  203.                     }
  204.                     rt.getDefault().addRoute(route);
  205.                 }
  206.                 else {// allora e' di destinazione
  207.                     rtd = new RoutingTableDestinazione();
  208.                     rtd.setNome(nome);
  209.                     rtd.setTipo(tipo);
  210.                     rtd.addRoute(route);
  211.                     rt.addDestinazione(rtd);
  212.                 }
  213.             }

  215.             this.driver.logDebug("Ci sono " + nroute + " rotte configurate.");
  216.             rs.close();
  217.             stm.close();
  218.             //if (nroute == 0)
  219.             //  throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getRoutingTable] Routing Abilitato ma nessuna route trovata.]");



  223.             //}
  224.             //else {
  225.             //  throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::getRoutingTable] Routing Disabilitato]");
  226.             //}

  228.             return rt;


  231.         } catch (SQLException se) {

  233.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getRoutingTable] SqlException: " + se.getMessage(),se);
  234.         }catch (Exception se) {

  236.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::getRoutingTable] Exception: " + se.getMessage(),se);
  237.         } finally {

  239.             //Chiudo statement and resultset
  240.             JDBCUtilities.closeResources(rsSearch, stmSearch);
  241.             JDBCUtilities.closeResources(rs, stm);

  243.             this.driver.closeConnection(con);
  244.         }

  246.     }

  248.     protected void createRoutingTable(RoutingTable routingTable) throws DriverConfigurazioneException {

  250.         if (routingTable == null ||  routingTable.getDefault() == null || routingTable.getDefault().sizeRouteList() == 0)
  251.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRoutingTable] Parametri non validi.");

  253.         Connection con = null;
  254.         boolean error = false;

  256.         if (this.driver.atomica) {
  257.             try {
  258.                 con = this.driver.getConnectionFromDatasource("createRoutingTable");
  259.                 con.setAutoCommit(false);
  260.             } catch (Exception e) {
  261.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRoutingTable] Exception accedendo al datasource :" + e.getMessage(),e);

  263.             }

  265.         } else
  266.             con = this.driver.globalConnection;

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

  270.         try {
  271.             this.driver.logDebug("CRUDRoutingTable type = 1");
  272.             // creo soggetto
  273.             DriverConfigurazioneDB_routingTableLIB.CRUDRoutingTable(1, routingTable, con);

  275.         } catch (Exception qe) {
  276.             error = true;
  277.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRoutingTable] Errore durante la creazione della RoutingTable : " + qe.getMessage(),qe);
  278.         } finally {

  280.             this.driver.closeConnection(error,con);
  281.         }
  282.     }

  284.     protected void updateRoutingTable(RoutingTable routingTable) throws DriverConfigurazioneException {
  285.         if (routingTable == null ||  routingTable.getDefault() == null || routingTable.getDefault().sizeRouteList() == 0)
  286.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateRoutingTable] Parametri non validi.");

  288.         Connection con = null;
  289.         boolean error = false;

  291.         if (this.driver.atomica) {
  292.             try {
  293.                 con = this.driver.getConnectionFromDatasource("updateRoutingTable");
  294.                 con.setAutoCommit(false);
  295.             } catch (Exception e) {
  296.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::createRoutingTable] Exception accedendo al datasource :" + e.getMessage(),e);

  298.             }

  300.         } else
  301.             con = this.driver.globalConnection;

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

  305.         try {
  306.             this.driver.logDebug("CRUDRoutingTable type = 2");
  307.             // creo soggetto
  308.             DriverConfigurazioneDB_routingTableLIB.CRUDRoutingTable(2, routingTable, con);

  310.         } catch (Exception qe) {
  311.             error = true;
  312.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::updateRoutingTable] Errore durante la update della RoutingTable : " + qe.getMessage(),qe);
  313.         } finally {

  315.             this.driver.closeConnection(error,con);
  316.         }
  317.     }

  319.     protected void deleteRoutingTable(RoutingTable routingTable) throws DriverConfigurazioneException {
  320.         if (routingTable == null)
  321.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRoutingTable] Parametri non validi.");

  323.         Connection con = null;
  324.         boolean error = false;

  326.         if (this.driver.atomica) {
  327.             try {
  328.                 con = this.driver.getConnectionFromDatasource("deleteRoutingTable");
  329.                 con.setAutoCommit(false);
  330.             } catch (Exception e) {
  331.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRoutingTable] Exception accedendo al datasource :" + e.getMessage(),e);

  333.             }

  335.         } else
  336.             con = this.driver.globalConnection;

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

  340.         try {
  341.             this.driver.logDebug("CRUDRoutingTable type = 3");
  342.             // creo soggetto
  343.             DriverConfigurazioneDB_routingTableLIB.CRUDRoutingTable(3, routingTable, con);

  345.         } catch (Exception qe) {
  346.             error = true;
  347.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::deleteRoutingTable] Errore durante la delete della RoutingTable : " + qe.getMessage(),qe);
  348.         } finally {

  350.             this.driver.closeConnection(error,con);
  351.         }
  352.     }

  354.     protected List<RoutingTableDestinazione> routingList(ISearch ricerca) throws DriverConfigurazioneException {
  355.         String nomeMetodo = "routingList";
  356.         int idLista = Liste.ROUTING;
  357.         int offset;
  358.         int limit;
  359.         String search;
  360.         String queryString;

  362.         limit = ricerca.getPageSize(idLista);
  363.         offset = ricerca.getIndexIniziale(idLista);
  364.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));


  367.         Connection con = null;
  368.         PreparedStatement stmt=null;
  369.         ResultSet risultato=null;
  370.         ArrayList<RoutingTableDestinazione> lista = new ArrayList<>();

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

  378.             }

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

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

  385.         try {

  387.             if (!search.equals("")) {
  388.                 //query con search
  389.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  390.                 sqlQueryObject.addFromTable(CostantiDB.ROUTING);
  391.                 sqlQueryObject.addSelectCountField("*", "cont");
  392.                 sqlQueryObject.addWhereCondition("is_default = 0");
  393.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("tipo",search,true,true), sqlQueryObject.getWhereLikeCondition("nome",search,true,true));
  394.                 sqlQueryObject.setANDLogicOperator(true);
  395.                 queryString = sqlQueryObject.createSQLQuery();
  396.             } else {
  397.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  398.                 sqlQueryObject.addFromTable(CostantiDB.ROUTING);
  399.                 sqlQueryObject.addSelectCountField("*", "cont");
  400.                 sqlQueryObject.addWhereCondition("is_default = 0");
  401.                 queryString = sqlQueryObject.createSQLQuery();
  402.             }
  403.             stmt = con.prepareStatement(queryString);
  404.             risultato = stmt.executeQuery();
  405.             if (risultato.next())
  406.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  407.             risultato.close();
  408.             stmt.close();

  410.             // ricavo le entries
  411.             if (limit == 0) // con limit
  412.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  414.             if (!search.equals("")) { // con search
  415.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  416.                 sqlQueryObject.addFromTable(CostantiDB.ROUTING);
  417.                 sqlQueryObject.addSelectField("id");
  418.                 sqlQueryObject.addSelectField("nome");
  419.                 sqlQueryObject.addSelectField("tipo");
  420.                 sqlQueryObject.addSelectField("tiporotta");
  421.                 sqlQueryObject.addSelectField("is_default");
  422.                 sqlQueryObject.addWhereCondition("is_default = 0");
  423.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("tipo",search,true,true), sqlQueryObject.getWhereLikeCondition("nome",search,true,true));
  424.                 sqlQueryObject.setANDLogicOperator(true);
  425.                 sqlQueryObject.addOrderBy("tipo");
  426.                 sqlQueryObject.addOrderBy("nome");
  427.                 sqlQueryObject.setSortType(true);
  428.                 sqlQueryObject.setLimit(limit);
  429.                 sqlQueryObject.setOffset(offset);
  430.                 queryString = sqlQueryObject.createSQLQuery();
  431.             } else {
  432.                 // senza search
  433.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.driver.tipoDB);
  434.                 sqlQueryObject.addFromTable(CostantiDB.ROUTING);
  435.                 sqlQueryObject.addSelectField("id");
  436.                 sqlQueryObject.addSelectField("nome");
  437.                 sqlQueryObject.addSelectField("tipo");
  438.                 sqlQueryObject.addSelectField("tiporotta");
  439.                 sqlQueryObject.addSelectField("is_default");
  440.                 sqlQueryObject.addWhereCondition("is_default = 0");
  441.                 sqlQueryObject.addOrderBy("tipo");
  442.                 sqlQueryObject.addOrderBy("nome");
  443.                 sqlQueryObject.setSortType(true);
  444.                 sqlQueryObject.setLimit(limit);
  445.                 sqlQueryObject.setOffset(offset);
  446.                 queryString = sqlQueryObject.createSQLQuery();
  447.             }
  448.             stmt = con.prepareStatement(queryString);
  449.             risultato = stmt.executeQuery();

  451.             RoutingTableDestinazione rtd;
  452.             while (risultato.next()) {

  454.                 rtd = new RoutingTableDestinazione();

  456.                 rtd.setId(risultato.getLong("id"));
  457.                 rtd.setNome(risultato.getString("nome"));
  458.                 rtd.setTipo(risultato.getString("tipo"));
  459.                 // Non è necessario popolare rg e rr
  460.                 // perchè tanto il metodo che prepara la lista
  461.                 // deve solo decidere il tiporotta scelto
  462.                 Route tmpR = new Route();
  463.                 if ("gateway".equals(risultato.getString("tiporotta"))) {
  464.                     RouteGateway rg = new RouteGateway();
  465.                     tmpR.setGateway(rg);
  466.                 } else {
  467.                     RouteRegistro rr = new RouteRegistro();
  468.                     tmpR.setRegistro(rr);
  469.                 }
  470.                 rtd.addRoute(tmpR);

  472.                 lista.add(rtd);
  473.             }

  475.             return lista;

  477.         } catch (Exception qe) {
  478.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  479.         } finally {

  481.             //Chiudo statement and resultset
  482.             JDBCUtilities.closeResources(risultato, stmt);

  484.             this.driver.closeConnection(con);
  485.         }
  486.     }
  487. }
Created with JaCoCo 0.8.8.202204050719