HandlersDriverUtils.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.plugins.utils.handlers;

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

  28. import org.openspcoop2.core.commons.ISearch;
  29. import org.openspcoop2.core.config.ConfigurazioneHandler;
  30. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  31. import org.openspcoop2.core.constants.CostantiDB;
  32. import org.openspcoop2.core.constants.TipoPdD;
  33. import org.openspcoop2.core.plugins.Plugin;
  34. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  35. import org.openspcoop2.core.plugins.dao.jdbc.converter.PluginFieldConverter;
  36. import org.openspcoop2.core.plugins.utils.PluginsDriverUtils;
  37. import org.openspcoop2.generic_project.exception.ServiceException;
  38. import org.openspcoop2.utils.sql.ISQLQueryObject;
  39. import org.openspcoop2.utils.sql.SQLObjectFactory;
  40. import org.slf4j.Logger;

  42. /**
  43.  * HandlersDriverUtils
  44.  *
  45.  * @author Poli Andrea (apoli@link.it)
  46.  * @author Pintori Giuliano (pintori@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class HandlersDriverUtils {

  52.     public static int numeroHandlerList(String tipologia, TipoPdD ruoloPorta, Long idPorta, TipoPlugin tipoPlugin, String nomeMetodo, Connection con, Logger log, String tipoDB) throws ServiceException {
  53.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  54.         if(ruoloPorta !=null) {
  55.             if(ruoloPorta.equals(TipoPdD.DELEGATA)) {
  56.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  57.             }
  58.             else if(ruoloPorta.equals(TipoPdD.APPLICATIVA)) {
  59.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  60.             }
  61.         }       
  62.         
  63.         String queryString;

  65.         PreparedStatement stmt=null;
  66.         ResultSet risultato=null;

  68.         try {
  69.             PluginFieldConverter converter = new PluginFieldConverter(tipoDB);
  70.             String tabellaPlugin = converter.toTable(Plugin.model());
  71.             
  72.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  73.             sqlQueryObject.addFromTable(tabella);
  74.             sqlQueryObject.addFromTable(tabellaPlugin);
  75.             sqlQueryObject.addSelectCountField(tabella + ".id", "cont");
  76.             
  77.             sqlQueryObject.addWhereCondition(tabellaPlugin +".tipo=" + tabella + ".tipo");
  78.             if(idPorta !=null) {
  79.                 sqlQueryObject.addWhereCondition(tabella + ".id_porta=?");
  80.             }
  81.             sqlQueryObject.addWhereCondition(tabella + ".tipologia=?");
  82.             sqlQueryObject.addWhereCondition(tabellaPlugin + ".tipo_plugin=?");
  83.             sqlQueryObject.setANDLogicOperator(true);
  84.             queryString = sqlQueryObject.createSQLQuery();
  85.             stmt = con.prepareStatement(queryString);
  86.             int index = 1;
  87.             if(idPorta!=null) {
  88.                 stmt.setLong(index++, idPorta);
  89.             }
  90.             stmt.setString(index++, tipologia);
  91.             stmt.setString(index++, tipoPlugin.getValue());
  92.             
  93.             risultato = stmt.executeQuery();
  94.             int res = 0;
  95.             if (risultato.next()) {
  96.                 res = risultato.getInt(1);
  97.             }
  98.             risultato.close();
  99.             stmt.close();

  101.             return res;
  102.         } catch (Exception se) {
  103.             throw new ServiceException("[" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  104.         } finally {

  106.             //Chiudo statement and resultset
  107.             try{
  108.                 if(risultato!=null) 
  109.                     risultato.close();
  110.             }catch (Exception e) {
  111.                 //ignore
  112.             }
  113.             try{
  114.                 if(stmt!=null) 
  115.                     stmt.close();
  116.             }catch (Exception e) {
  117.                 //ignore
  118.             }
  119.         }
  120.     }
  121.     
  122.     public static List<ConfigurazioneHandlerBean> handlerList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta,
  123.             Long idPorta, String nomeMetodo, int idLista, TipoPlugin tipoPlugin, Connection con, Logger log, String tipoDB) throws ServiceException {
  124.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  125.         if(ruoloPorta !=null) {
  126.             if(ruoloPorta.equals(TipoPdD.DELEGATA)) {
  127.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  128.             }
  129.             else if(ruoloPorta.equals(TipoPdD.APPLICATIVA)) {
  130.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  131.             }
  132.         }       
  133.         
  134.         int offset;
  135.         int limit;
  136.         String queryString;
  137.         String search;

  139.         limit = ricerca.getPageSize(idLista);
  140.         offset = ricerca.getIndexIniziale(idLista);
  141.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  143.         PreparedStatement stmt=null;
  144.         ResultSet risultato=null;
  145.         ArrayList<ConfigurazioneHandlerBean> lista = new ArrayList<ConfigurazioneHandlerBean>();

  147.         try {
  148.             PluginFieldConverter converter = new PluginFieldConverter(tipoDB);
  149.             String tabellaPlugin = converter.toTable(Plugin.model());
  150.             
  151.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  152.             sqlQueryObject.addFromTable(tabella);
  153.             sqlQueryObject.addFromTable(tabellaPlugin);
  154.             
  155.             sqlQueryObject.addSelectCountField(tabella + ".id", "cont");
  156.             sqlQueryObject.addWhereCondition(tabellaPlugin +".tipo=" + tabella + ".tipo");
  157.             
  158.             if (!search.equals("")) {
  159.                 sqlQueryObject.addWhereLikeCondition(tabellaPlugin +".label", search, true, true);
  160.             }
  161.             if(idPorta !=null) {
  162.                 sqlQueryObject.addWhereCondition(tabella + ".id_porta=?");
  163.             }
  164.             sqlQueryObject.addWhereCondition(tabella + ".tipologia=?");
  165.             sqlQueryObject.addWhereCondition(tabellaPlugin + ".tipo_plugin=?");
  166.             sqlQueryObject.setANDLogicOperator(true);
  167.             
  168.             queryString = sqlQueryObject.createSQLQuery();
  169.             stmt = con.prepareStatement(queryString);
  170.             int index = 1;
  171.             if(idPorta!=null) {
  172.                 stmt.setLong(index++, idPorta);
  173.             }
  174.             stmt.setString(index++, tipologia);
  175.             stmt.setString(index++, tipoPlugin.getValue());
  176.             
  177.             risultato = stmt.executeQuery();
  178.             if (risultato.next())
  179.                 ricerca.setNumEntries(idLista,risultato.getInt(1));
  180.             risultato.close();
  181.             stmt.close();

  183.             // ricavo le entries
  184.             if (limit == 0) // con limit
  185.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;

  187.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  188.             sqlQueryObject.addFromTable(tabella);
  189.             sqlQueryObject.addFromTable(tabellaPlugin);
  190.             sqlQueryObject.addSelectAliasField(tabella, "id","IdHandler");
  191.             sqlQueryObject.addSelectField(tabella,"tipologia"); 
  192.             String aliasTIPO = "tipoTabConf";
  193.             sqlQueryObject.addSelectAliasField(tabella,"tipo",aliasTIPO);         
  194.             sqlQueryObject.addSelectField(tabella,"posizione");       
  195.             sqlQueryObject.addSelectField(tabella,"stato");
  196.             if(idPorta !=null) {
  197.                 sqlQueryObject.addSelectField(tabella,"id_porta");
  198.             }
  199.             
  200.             sqlQueryObject.addWhereCondition(tabellaPlugin +".tipo=" + tabella + ".tipo");
  201.             
  202.             if (!search.equals("")) {
  203.                 sqlQueryObject.addWhereLikeCondition(tabellaPlugin +".label", search, true, true);
  204.             }
  205.             if(idPorta !=null) {
  206.                 sqlQueryObject.addWhereCondition(tabella + ".id_porta=?");
  207.             }
  208.             sqlQueryObject.addWhereCondition(tabella + ".tipologia=?");
  209.             sqlQueryObject.addWhereCondition(tabellaPlugin + ".tipo_plugin=?");
  210.             sqlQueryObject.setANDLogicOperator(true);
  211.             sqlQueryObject.addOrderBy(tabella + ".posizione");
  212.             /**sqlQueryObject.addOrderBy(tabella + ".tipo");*/
  213.             sqlQueryObject.addOrderBy(aliasTIPO);
  214.             sqlQueryObject.setSortType(true);
  215.             sqlQueryObject.setLimit(limit);
  216.             sqlQueryObject.setOffset(offset);
  217.             queryString = sqlQueryObject.createSQLQuery();
  218.             stmt = con.prepareStatement(queryString);
  219.             index = 1;
  220.             if(idPorta!=null) {
  221.                 stmt.setLong(index++, idPorta);
  222.             }
  223.             stmt.setString(index++, tipologia);
  224.             stmt.setString(index++, tipoPlugin.getValue());
  225.             risultato = stmt.executeQuery();

  227.             
  228.             while (risultato.next()) { 
  229.                 ConfigurazioneHandler handler = new ConfigurazioneHandler();
  230.                 handler.setId(risultato.getLong("IdHandler"));
  231.                 handler.setPosizione(risultato.getInt("posizione"));
  232.                 handler.setStato(getEnumStatoFunzionalita(risultato.getString("stato")));
  233.                 /**handler.setTipo(risultato.getString("tipo"));*/
  234.                 handler.setTipo(risultato.getString(aliasTIPO));
  235.                 
  236.                 Plugin plugin = PluginsDriverUtils.getPlugin(tipoPlugin.getValue(), handler.getTipo(), true, con, log, tipoDB);
  237.                 
  238.                 ConfigurazioneHandlerBean bean = new ConfigurazioneHandlerBean(handler, plugin);
  239.                 
  240.                 lista.add(bean);
  241.             
  242.             }
  243.             risultato.close();
  244.             stmt.close();
  245.             
  246.             return lista;

  248.         } catch (Exception se) {
  249.             throw new ServiceException("[" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  250.         } finally {

  252.             //Chiudo statement and resultset
  253.             try{
  254.                 if(risultato!=null) 
  255.                     risultato.close();
  256.             }catch (Exception e) {
  257.                 //ignore
  258.             }
  259.             try{
  260.                 if(stmt!=null) 
  261.                     stmt.close();
  262.             }catch (Exception e) {
  263.                 //ignore
  264.             }
  265.         }
  266.     }
  267.     
  268.     public static int getMaxPosizioneHandlers(String tipologia, TipoPdD ruoloPorta, Long idPorta, String nomeMetodo, TipoPlugin tipoPlugin, Connection con, Logger log, String tipoDB) throws ServiceException {
  269.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  270.         if(ruoloPorta !=null) {
  271.             if(ruoloPorta.equals(TipoPdD.DELEGATA)) {
  272.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  273.             }
  274.             else if(ruoloPorta.equals(TipoPdD.APPLICATIVA)) {
  275.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  276.             }
  277.         }       
  278.         
  279.         String queryString;

  281.         PreparedStatement stmt=null;
  282.         ResultSet risultato=null;
  283.         int posizione = 0;

  285.         try {
  286.             PluginFieldConverter converter = new PluginFieldConverter(tipoDB);
  287.             String tabellaPlugin = converter.toTable(Plugin.model());
  288.             
  289.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  290.             sqlQueryObject.addFromTable(tabella);
  291.             sqlQueryObject.addFromTable(tabellaPlugin);
  292.             sqlQueryObject.addWhereCondition(tabellaPlugin +".tipo=" + tabella + ".tipo");
  293.             
  294.             sqlQueryObject.addSelectMaxField(tabella + ".posizione", "posizione");       

  296.             if(idPorta !=null) {
  297.                 sqlQueryObject.addWhereCondition(tabella + ".id_porta=?");
  298.             }
  299.             sqlQueryObject.addWhereCondition(tabella + ".tipologia=?");
  300.             sqlQueryObject.addWhereCondition(tabellaPlugin + ".tipo_plugin=?");
  301.             sqlQueryObject.setANDLogicOperator(true);
  302.             queryString = sqlQueryObject.createSQLQuery();
  303.             stmt = con.prepareStatement(queryString);
  304.             int index = 1;
  305.             if(idPorta!=null) {
  306.                 stmt.setLong(index++, idPorta);
  307.             }
  308.             stmt.setString(index++, tipologia);
  309.             stmt.setString(index++, tipoPlugin.getValue());
  310.             risultato = stmt.executeQuery();

  312.             if(risultato.next()) {
  313.                 posizione = risultato.getInt("posizione");
  314.             }
  315.             
  316.             risultato.close();
  317.             stmt.close();
  318.             
  319.             return posizione;

  321.         } catch (Exception se) {
  322.             throw new ServiceException("[" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  323.         } finally {

  325.             //Chiudo statement and resultset
  326.             try{
  327.                 if(risultato!=null) 
  328.                     risultato.close();
  329.             }catch (Exception e) {
  330.                 //ignore
  331.             }
  332.             try{
  333.                 if(stmt!=null) 
  334.                     stmt.close();
  335.             }catch (Exception e) {
  336.                 //ignore
  337.             }
  338.         }
  339.     }
  340.     
  341.     public static boolean existsHandler(String tipologia, TipoPdD ruoloPorta, Long idPorta, String nomeMetodo, TipoPlugin tipoPlugin, String tipo, Connection con, Logger log, String tipoDB) throws ServiceException {
  342.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  343.         if(ruoloPorta !=null) {
  344.             if(ruoloPorta.equals(TipoPdD.DELEGATA)) {
  345.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  346.             }
  347.             else if(ruoloPorta.equals(TipoPdD.APPLICATIVA)) {
  348.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  349.             }
  350.         }       
  351.         
  352.         String queryString;

  354.         PreparedStatement stmt=null;
  355.         ResultSet risultato=null;
  356.         boolean exists = false;

  358.         try {
  359.             PluginFieldConverter converter = new PluginFieldConverter(tipoDB);
  360.             String tabellaPlugin = converter.toTable(Plugin.model());
  361.             
  362.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  363.             sqlQueryObject.addFromTable(tabella);
  364.             sqlQueryObject.addFromTable(tabellaPlugin);
  365.             sqlQueryObject.addWhereCondition(tabellaPlugin +".tipo=" + tabella + ".tipo");
  366.             
  367.             sqlQueryObject.addSelectCountField(tabella + ".id", "cont");  

  369.             if(idPorta !=null) {
  370.                 sqlQueryObject.addWhereCondition(tabella + ".id_porta=?");
  371.             }
  372.             sqlQueryObject.addWhereCondition(tabella + ".tipologia=?");
  373.             sqlQueryObject.addWhereCondition(tabella + ".tipo=?");
  374.             sqlQueryObject.addWhereCondition(tabellaPlugin + ".tipo_plugin=?");
  375.             sqlQueryObject.setANDLogicOperator(true);
  376.             queryString = sqlQueryObject.createSQLQuery();
  377.             stmt = con.prepareStatement(queryString);
  378.             int index = 1;
  379.             if(idPorta!=null) {
  380.                 stmt.setLong(index++, idPorta);
  381.             }
  382.             stmt.setString(index++, tipologia);
  383.             stmt.setString(index++, tipo);
  384.             stmt.setString(index++, tipoPlugin.getValue());
  385.             risultato = stmt.executeQuery();

  387.             if(risultato.next()) {
  388.                 exists = risultato.getInt(1) > 0;
  389.             }
  390.             
  391.             risultato.close();
  392.             stmt.close();
  393.             
  394.             return exists;

  396.         } catch (Exception se) {
  397.             throw new ServiceException("[" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  398.         } finally {

  400.             //Chiudo statement and resultset
  401.             try{
  402.                 if(risultato!=null) 
  403.                     risultato.close();
  404.             }catch (Exception e) {
  405.                 //ignore
  406.             }
  407.             try{
  408.                 if(stmt!=null) 
  409.                     stmt.close();
  410.             }catch (Exception e) {
  411.                 //ignore
  412.             }
  413.         }
  414.     }
  415.     
  416.     public static ConfigurazioneHandlerBean getHandler(String tipologia, TipoPdD ruoloPorta,
  417.             Long idPorta, Long idHandler, String nomeMetodo, TipoPlugin tipoPlugin, Connection con, Logger log, String tipoDB) throws ServiceException {
  418.         
  419.         String tabella = CostantiDB.CONFIGURAZIONE_HANDLERS;
  420.         if(ruoloPorta !=null) {
  421.             if(ruoloPorta.equals(TipoPdD.DELEGATA)) {
  422.                 tabella = CostantiDB.PORTE_DELEGATE_HANDLERS;
  423.             }
  424.             else if(ruoloPorta.equals(TipoPdD.APPLICATIVA)) {
  425.                 tabella = CostantiDB.PORTE_APPLICATIVE_HANDLERS;
  426.             }
  427.         }       
  428.         
  429.         String queryString;

  431.         PreparedStatement stmt=null;
  432.         ResultSet risultato=null;
  433.         ConfigurazioneHandlerBean bean = null;

  435.         try {
  436.             PluginFieldConverter converter = new PluginFieldConverter(tipoDB);
  437.             String tabellaPlugin = converter.toTable(Plugin.model());
  438.             
  439.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(tipoDB);
  440.             sqlQueryObject.addFromTable(tabella);
  441.             sqlQueryObject.addFromTable(tabellaPlugin);
  442.             sqlQueryObject.addSelectField(tabella + ".id");
  443.             sqlQueryObject.addSelectField(tabella + ".tipologia"); 
  444.             sqlQueryObject.addSelectField(tabella + ".tipo");         
  445.             sqlQueryObject.addSelectField(tabella + ".posizione");       
  446.             sqlQueryObject.addSelectField(tabella + ".stato");
  447.             if(idPorta !=null) {
  448.                 sqlQueryObject.addSelectField(tabella + ".id_porta");
  449.             }
  450.             
  451.             sqlQueryObject.addWhereCondition(tabellaPlugin +".tipo=" + tabella + ".tipo");
  452.             
  453.             sqlQueryObject.addWhereCondition(tabella + ".id=?");
  454.             if(idPorta !=null) {
  455.                 sqlQueryObject.addWhereCondition(tabella + ".id_porta=?");
  456.             }
  457.             sqlQueryObject.addWhereCondition(tabella + ".tipologia=?");
  458.             sqlQueryObject.addWhereCondition(tabellaPlugin + ".tipo_plugin=?");
  459.             sqlQueryObject.setANDLogicOperator(true);
  460.             queryString = sqlQueryObject.createSQLQuery();
  461.             stmt = con.prepareStatement(queryString);
  462.             int index = 1;
  463.             
  464.             stmt.setLong(index++, idHandler);
  465.             if(idPorta!=null) {
  466.                 stmt.setLong(index++, idPorta);
  467.             }
  468.             stmt.setString(index++, tipologia);
  469.             stmt.setString(index++, tipoPlugin.getValue());
  470.             risultato = stmt.executeQuery();

  472.             
  473.             while (risultato.next()) { 
  474.                 ConfigurazioneHandler handler = new ConfigurazioneHandler();
  475.                 handler.setId(risultato.getLong("id"));
  476.                 handler.setPosizione(risultato.getInt("posizione"));
  477.                 handler.setStato(getEnumStatoFunzionalita(risultato.getString("stato")));
  478.                 handler.setTipo(risultato.getString("tipo"));
  479.                 
  480.                 Plugin plugin = PluginsDriverUtils.getPlugin(tipoPlugin.getValue(), handler.getTipo(), true, con, log, tipoDB);
  481.                 
  482.                 bean = new ConfigurazioneHandlerBean(handler, plugin);
  483.             
  484.             }
  485.             risultato.close();
  486.             stmt.close();
  487.             
  488.             return bean;

  490.         } catch (Exception se) {
  491.             throw new ServiceException("[" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  492.         } finally {

  494.             //Chiudo statement and resultset
  495.             try{
  496.                 if(risultato!=null) 
  497.                     risultato.close();
  498.             }catch (Exception e) {
  499.                 //ignore
  500.             }
  501.             try{
  502.                 if(stmt!=null) 
  503.                     stmt.close();
  504.             }catch (Exception e) {
  505.                 //ignore
  506.             }
  507.         }
  508.     }
  509.     
  510.     private static StatoFunzionalita getEnumStatoFunzionalita(String value){
  511.         if(value==null){
  512.             return null;
  513.         }
  514.         else{
  515.             return StatoFunzionalita.toEnumConstant(value);
  516.         }
  517.     }
  518. }
Created with JaCoCo 0.8.8.202204050719