ConfigurazioneCore.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.web.ctrlstat.servlet.config;

  22. import java.sql.Connection;
  23. import java.util.ArrayList;
  24. import java.util.Collections;
  25. import java.util.EnumMap;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;
  29. import java.util.Properties;

  31. import org.apache.commons.lang.StringUtils;
  32. import org.openspcoop2.core.allarmi.Allarme;
  33. import org.openspcoop2.core.allarmi.AllarmeParametro;
  34. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  35. import org.openspcoop2.core.allarmi.constants.TipoAllarme;
  36. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  37. import org.openspcoop2.core.commons.Filtri;
  38. import org.openspcoop2.core.commons.ISearch;
  39. import org.openspcoop2.core.commons.Liste;
  40. import org.openspcoop2.core.config.AccessoConfigurazione;
  41. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  42. import org.openspcoop2.core.config.AccessoRegistro;
  43. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  44. import org.openspcoop2.core.config.CanaleConfigurazione;
  45. import org.openspcoop2.core.config.CanaleConfigurazioneNodo;
  46. import org.openspcoop2.core.config.Configurazione;
  47. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazione;
  48. import org.openspcoop2.core.config.ConfigurazioneUrlInvocazioneRegola;
  49. import org.openspcoop2.core.config.GenericProperties;
  50. import org.openspcoop2.core.config.GestioneErrore;
  51. import org.openspcoop2.core.config.PortaApplicativa;
  52. import org.openspcoop2.core.config.PortaDelegata;
  53. import org.openspcoop2.core.config.Property;
  54. import org.openspcoop2.core.config.Proprieta;
  55. import org.openspcoop2.core.config.RegistroPlugin;
  56. import org.openspcoop2.core.config.RegistroPluginArchivio;
  57. import org.openspcoop2.core.config.RegistroPlugins;
  58. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  59. import org.openspcoop2.core.config.RoutingTable;
  60. import org.openspcoop2.core.config.RoutingTableDestinazione;
  61. import org.openspcoop2.core.config.SystemProperties;
  62. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  63. import org.openspcoop2.core.config.constants.FaseMessageHandler;
  64. import org.openspcoop2.core.config.constants.FaseServiceHandler;
  65. import org.openspcoop2.core.config.constants.PluginSorgenteArchivio;
  66. import org.openspcoop2.core.config.constants.RuoloContesto;
  67. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  68. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  69. import org.openspcoop2.core.constants.CostantiDB;
  70. import org.openspcoop2.core.constants.TipoPdD;
  71. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  72. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  73. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyRaggruppamento;
  74. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  75. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  76. import org.openspcoop2.core.controllo_traffico.IdPolicy;
  77. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  78. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  79. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  80. import org.openspcoop2.core.id.IDGenericProperties;
  81. import org.openspcoop2.core.id.IDServizio;
  82. import org.openspcoop2.core.id.IDServizioApplicativo;
  83. import org.openspcoop2.core.id.IDSoggetto;
  84. import org.openspcoop2.core.mvc.properties.utils.DBPropertiesUtils;
  85. import org.openspcoop2.core.registry.beans.AccordoServizioParteComuneSintetico;
  86. import org.openspcoop2.generic_project.exception.NotFoundException;
  87. import org.openspcoop2.message.constants.ServiceBinding;
  88. import org.openspcoop2.monitor.engine.alarm.AlarmContext;
  89. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  90. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeHistoryBean;
  91. import org.openspcoop2.core.plugins.IdPlugin;
  92. import org.openspcoop2.core.plugins.Plugin;
  93. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  94. import org.openspcoop2.core.plugins.utils.handlers.ConfigurazioneHandlerBean;
  95. import org.openspcoop2.monitor.engine.dynamic.DynamicFactory;
  96. import org.openspcoop2.monitor.engine.dynamic.IDynamicLoader;
  97. import org.openspcoop2.monitor.sdk.condition.Context;
  98. import org.openspcoop2.monitor.sdk.constants.ParameterType;
  99. import org.openspcoop2.monitor.sdk.parameters.Parameter;
  100. import org.openspcoop2.monitor.sdk.plugins.FiltersConfiguration;
  101. import org.openspcoop2.monitor.sdk.plugins.GroupByConfiguration;
  102. import org.openspcoop2.monitor.sdk.plugins.IAlarmProcessing;
  103. import org.openspcoop2.pdd.config.UrlInvocazioneAPI;
  104. import org.openspcoop2.pdd.core.autorizzazione.canali.CanaliUtils;
  105. import org.openspcoop2.pdd.core.controllo_traffico.policy.config.PolicyConfiguration;
  106. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  107. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  108. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  109. import org.openspcoop2.protocol.sdk.ProtocolException;
  110. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  111. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  112. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  113. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationException;
  114. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationNotFound;
  115. import org.openspcoop2.web.lib.audit.AuditException;
  116. import org.openspcoop2.web.lib.audit.DriverAudit;
  117. import org.openspcoop2.web.lib.audit.dao.Filtro;
  118. import org.openspcoop2.web.lib.mvc.Costanti;
  119. import org.openspcoop2.web.lib.mvc.dynamic.DynamicComponentUtils;
  120. import org.openspcoop2.web.lib.mvc.dynamic.components.BaseComponent;

  122. /**
  123.  * ConfigurazioneCore
  124.  *
  125.  * @author Poli Andrea (apoli@link.it)
  126.  * @author $Author$
  127.  * @version $Rev$, $Date$
  128.  */
  129. public class ConfigurazioneCore extends ControlStationCore {


  132.     public ConfigurazioneCore() throws Exception {
  133.         super();
  134.     }
  135.     public ConfigurazioneCore(ControlStationCore core) throws Exception {
  136.         super(core);
  137.     }
  138.     
  139.     
  140.     public List<RoutingTableDestinazione> routingList(ISearch ricerca) throws DriverConfigurazioneException {
  141.         Connection con = null;
  142.         String nomeMetodo = "routingList";
  143.         DriverControlStationDB driver = null;

  145.         try {
  146.             // prendo una connessione
  147.             con = ControlStationCore.dbM.getConnection();
  148.             // istanzio il driver
  149.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  150.             return driver.getDriverConfigurazioneDB().routingList(ricerca);
  151.         } catch (Exception e) {
  152.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  153.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  154.         } finally {
  155.             ControlStationCore.dbM.releaseConnection(con);
  156.         }
  157.     }

  159.     
  160.     public List<AccessoRegistroRegistro> registriList(ISearch ricerca) throws DriverConfigurazioneException {
  161.         Connection con = null;
  162.         String nomeMetodo = "registriList";
  163.         DriverControlStationDB driver = null;

  165.         try {
  166.             // prendo una connessione
  167.             con = ControlStationCore.dbM.getConnection();
  168.             // istanzio il driver
  169.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  170.             return driver.getDriverConfigurazioneDB().registriList(ricerca);
  171.         } catch (Exception e) {
  172.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  173.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  174.         } finally {
  175.             ControlStationCore.dbM.releaseConnection(con);
  176.         }
  177.     }
  178.     
  179.     
  180.     public List<ResponseCachingConfigurazioneRegola> responseCachingConfigurazioneRegolaList(ISearch ricerca) throws DriverConfigurazioneException {
  181.         Connection con = null;
  182.         String nomeMetodo = "responseCachingConfigurazioneRegolaList";
  183.         DriverControlStationDB driver = null;

  185.         try {
  186.             // prendo una connessione
  187.             con = ControlStationCore.dbM.getConnection();
  188.             // istanzio il driver
  189.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  190.             return driver.getDriverConfigurazioneDB().responseCachingConfigurazioneRegolaList(ricerca);
  191.         } catch (Exception e) {
  192.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  193.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  194.         } finally {
  195.             ControlStationCore.dbM.releaseConnection(con);
  196.         }
  197.     }
  198.     
  199.     public List<ConfigurazioneUrlInvocazioneRegola> proxyPassConfigurazioneRegolaList(ISearch ricerca) throws DriverConfigurazioneException {
  200.         Connection con = null;
  201.         String nomeMetodo = "responseCachingConfigurazioneRegolaList";
  202.         DriverControlStationDB driver = null;

  204.         try {
  205.             // prendo una connessione
  206.             con = ControlStationCore.dbM.getConnection();
  207.             // istanzio il driver
  208.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  209.             return driver.getDriverConfigurazioneDB().proxyPassConfigurazioneRegolaList(ricerca);
  210.         } catch (Exception e) {
  211.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  212.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  213.         } finally {
  214.             ControlStationCore.dbM.releaseConnection(con);
  215.         }
  216.     }
  217.     
  218.     public boolean existsResponseCachingConfigurazioneRegola(Integer statusMin, Integer statusMax, boolean fault) throws DriverConfigurazioneException{
  219.         Connection con = null;
  220.         String nomeMetodo = "existsResponseCachingConfigurazioneRegola";
  221.         DriverControlStationDB driver = null;

  223.         try {
  224.             // prendo una connessione
  225.             con = ControlStationCore.dbM.getConnection();
  226.             // istanzio il driver
  227.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  228.             return driver.getDriverConfigurazioneDB().existsResponseCachingConfigurazioneRegola(statusMin,statusMax,fault);
  229.         } catch (Exception e) {
  230.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  231.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  232.         } finally {
  233.             ControlStationCore.dbM.releaseConnection(con);
  234.         }
  235.     }
  236.     
  237.     public boolean existsProxyPassConfigurazioneRegola(String nome) throws DriverConfigurazioneException{
  238.         Connection con = null;
  239.         String nomeMetodo = "existsProxyPassConfigurazioneRegola";
  240.         DriverControlStationDB driver = null;

  242.         try {
  243.             // prendo una connessione
  244.             con = ControlStationCore.dbM.getConnection();
  245.             // istanzio il driver
  246.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  247.             return driver.getDriverConfigurazioneDB().existsProxyPassConfigurazioneRegola(nome);
  248.         } catch (Exception e) {
  249.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  250.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  251.         } finally {
  252.             ControlStationCore.dbM.releaseConnection(con);
  253.         }
  254.     }
  255.     
  256.     public List<RegistroPlugin> pluginsArchiviList(ISearch ricerca) throws DriverConfigurazioneException {
  257.         Connection con = null;
  258.         String nomeMetodo = "pluginsArchiviList";
  259.         DriverControlStationDB driver = null;

  261.         try {
  262.             // prendo una connessione
  263.             con = ControlStationCore.dbM.getConnection();
  264.             // istanzio il driver
  265.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  266.             return driver.getDriverConfigurazioneDB().pluginsArchiviList(ricerca);
  267.         } catch (Exception e) {
  268.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  269.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  270.         } finally {
  271.             ControlStationCore.dbM.releaseConnection(con);
  272.         }
  273.     }
  274.     
  275.     public int numeroPluginsArchiviList() throws DriverConfigurazioneException {
  276.         Connection con = null;
  277.         String nomeMetodo = "numeroPluginsArchiviList";
  278.         DriverControlStationDB driver = null;

  280.         try {
  281.             // prendo una connessione
  282.             con = ControlStationCore.dbM.getConnection();
  283.             // istanzio il driver
  284.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  285.             ConsoleSearch searchForCount = new ConsoleSearch(true,1);
  286.             driver.getDriverConfigurazioneDB().pluginsArchiviList(searchForCount);
  287.             return searchForCount.getNumEntries(Liste.CONFIGURAZIONE_PLUGINS_ARCHIVI);
  288.         } catch (Exception e) {
  289.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  290.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  291.         } finally {
  292.             ControlStationCore.dbM.releaseConnection(con);
  293.         }
  294.     }
  295.     
  296.     public RegistroPlugin getRegistroPlugin(String nome) throws DriverConfigurazioneException {
  297.         Connection con = null;
  298.         String nomeMetodo = "getRegistroPlugin";
  299.         DriverControlStationDB driver = null;

  301.         try {
  302.             // prendo una connessione
  303.             con = ControlStationCore.dbM.getConnection();
  304.             // istanzio il driver
  305.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  306.             return driver.getDriverConfigurazioneDB().getRegistroPlugin(nome);
  307.         } catch (Exception e) {
  308.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  309.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  310.         } finally {
  311.             ControlStationCore.dbM.releaseConnection(con);
  312.         }
  313.     }
  314.     
  315.     public RegistroPlugin getDatiRegistroPlugin(String nome) throws DriverConfigurazioneException {
  316.         Connection con = null;
  317.         String nomeMetodo = "getDatiRegistroPlugin";
  318.         DriverControlStationDB driver = null;

  320.         try {
  321.             // prendo una connessione
  322.             con = ControlStationCore.dbM.getConnection();
  323.             // istanzio il driver
  324.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  325.             return driver.getDriverConfigurazioneDB().getDatiRegistroPlugin(nome);
  326.         } catch (Exception e) {
  327.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  328.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  329.         } finally {
  330.             ControlStationCore.dbM.releaseConnection(con);
  331.         }
  332.     }
  333.     
  334.     public RegistroPluginArchivio getRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException {
  335.         Connection con = null;
  336.         String nomeMetodo = "getRegistroPluginArchivio";
  337.         DriverControlStationDB driver = null;

  339.         try {
  340.             // prendo una connessione
  341.             con = ControlStationCore.dbM.getConnection();
  342.             // istanzio il driver
  343.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  344.             return driver.getDriverConfigurazioneDB().getRegistroPluginArchivio(nomePlugin, nome);
  345.         } catch (Exception e) {
  346.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  347.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  348.         } finally {
  349.             ControlStationCore.dbM.releaseConnection(con);
  350.         }
  351.     }
  352.     
  353.     public boolean existsRegistroPluginArchivio(String nomePlugin, String nome) throws DriverConfigurazioneException {
  354.         Connection con = null;
  355.         String nomeMetodo = "existsRegistroPluginArchivio";
  356.         DriverControlStationDB driver = null;

  358.         try {
  359.             // prendo una connessione
  360.             con = ControlStationCore.dbM.getConnection();
  361.             // istanzio il driver
  362.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  363.             return driver.getDriverConfigurazioneDB().existsRegistroPluginArchivio(nomePlugin, nome);
  364.         } catch (Exception e) {
  365.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  366.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  367.         } finally {
  368.             ControlStationCore.dbM.releaseConnection(con);
  369.         }
  370.     }
  371.     
  372.     public boolean existsRegistroPluginArchivio(String nomePlugin, PluginSorgenteArchivio tipoSorgente, String sorgente) throws DriverConfigurazioneException {
  373.         Connection con = null;
  374.         String nomeMetodo = "existsRegistroPluginArchivio";
  375.         DriverControlStationDB driver = null;

  377.         try {
  378.             // prendo una connessione
  379.             con = ControlStationCore.dbM.getConnection();
  380.             // istanzio il driver
  381.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  382.             return driver.getDriverConfigurazioneDB().existsRegistroPluginArchivio(nomePlugin, tipoSorgente, sorgente);
  383.         } catch (Exception e) {
  384.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  385.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  386.         } finally {
  387.             ControlStationCore.dbM.releaseConnection(con);
  388.         }
  389.     }
  390.     
  391.     public RegistroPlugin getRegistroPluginFromPosizione(int posizione) throws DriverConfigurazioneException {
  392.         Connection con = null;
  393.         String nomeMetodo = "getRegistroPluginFromPosizione";
  394.         DriverControlStationDB driver = null;

  396.         try {
  397.             // prendo una connessione
  398.             con = ControlStationCore.dbM.getConnection();
  399.             // istanzio il driver
  400.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  401.             return driver.getDriverConfigurazioneDB().getRegistroPluginFromPosizione(posizione);
  402.         } catch (Exception e) {
  403.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  404.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  405.         } finally {
  406.             ControlStationCore.dbM.releaseConnection(con);
  407.         }
  408.     }
  409.     
  410.     public RegistroPlugin getDatiRegistroPluginFromPosizione(int posizione) throws DriverConfigurazioneException {
  411.         Connection con = null;
  412.         String nomeMetodo = "getDatiRegistroPluginFromPosizione";
  413.         DriverControlStationDB driver = null;

  415.         try {
  416.             // prendo una connessione
  417.             con = ControlStationCore.dbM.getConnection();
  418.             // istanzio il driver
  419.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  420.             return driver.getDriverConfigurazioneDB().getDatiRegistroPluginFromPosizione(posizione);
  421.         } catch (Exception e) {
  422.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  423.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  424.         } finally {
  425.             ControlStationCore.dbM.releaseConnection(con);
  426.         }
  427.     }
  428.     
  429.     public boolean existsRegistroPlugin(String nome) throws DriverConfigurazioneException {
  430.         Connection con = null;
  431.         String nomeMetodo = "existsRegistroPlugin";
  432.         DriverControlStationDB driver = null;

  434.         try {
  435.             // prendo una connessione
  436.             con = ControlStationCore.dbM.getConnection();
  437.             // istanzio il driver
  438.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  439.             return driver.getDriverConfigurazioneDB().existsRegistroPlugin(nome);
  440.         } catch (Exception e) {
  441.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  442.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  443.         } finally {
  444.             ControlStationCore.dbM.releaseConnection(con);
  445.         }
  446.     }
  447.     
  448.     public int getMaxPosizioneRegistroPlugin() throws DriverConfigurazioneException {
  449.         Connection con = null;
  450.         String nomeMetodo = "getMaxPosizioneRegistroPlugin";
  451.         DriverControlStationDB driver = null;

  453.         try {
  454.             // prendo una connessione
  455.             con = ControlStationCore.dbM.getConnection();
  456.             // istanzio il driver
  457.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  458.             return driver.getDriverConfigurazioneDB().getMaxPosizioneRegistroPlugin();
  459.         } catch (Exception e) {
  460.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  461.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  462.         } finally {
  463.             ControlStationCore.dbM.releaseConnection(con);
  464.         }
  465.     }
  466.     
  467.     public int getNumeroArchiviJarRegistroPlugin(String nome) throws DriverConfigurazioneException {
  468.         Connection con = null;
  469.         String nomeMetodo = "getNumeroArchiviJarRegistroPlugin";
  470.         DriverControlStationDB driver = null;

  472.         try {
  473.             // prendo una connessione
  474.             con = ControlStationCore.dbM.getConnection();
  475.             // istanzio il driver
  476.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  477.             return driver.getDriverConfigurazioneDB().getNumeroArchiviJarRegistroPlugin(nome);
  478.         } catch (Exception e) {
  479.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  480.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  481.         } finally {
  482.             ControlStationCore.dbM.releaseConnection(con);
  483.         }
  484.     }
  485.     
  486.     public List<RegistroPluginArchivio> pluginsArchiviJarList(String nome, ISearch ricerca) throws DriverConfigurazioneException {
  487.         Connection con = null;
  488.         String nomeMetodo = "pluginsArchiviJarList";
  489.         DriverControlStationDB driver = null;

  491.         try {
  492.             // prendo una connessione
  493.             con = ControlStationCore.dbM.getConnection();
  494.             // istanzio il driver
  495.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  496.             return driver.getDriverConfigurazioneDB().pluginsArchiviJarList(nome, ricerca);
  497.         } catch (Exception e) {
  498.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  499.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  500.         } finally {
  501.             ControlStationCore.dbM.releaseConnection(con);
  502.         }
  503.     }
  504.     
  505.     public List<Plugin> pluginsClassiList(ISearch ricerca) throws DriverConfigurazioneException {
  506.         Connection con = null;
  507.         String nomeMetodo = "pluginsClassiList";
  508.         DriverControlStationDB driver = null;

  510.         try {
  511.             // prendo una connessione
  512.             con = ControlStationCore.dbM.getConnection();
  513.             // istanzio il driver
  514.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  515.             return driver.pluginsClassiList(ricerca);
  516.         } catch (Exception e) {
  517.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  518.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  519.         } finally {
  520.             ControlStationCore.dbM.releaseConnection(con);
  521.         }
  522.     }
  523.     
  524.     public List<Plugin> pluginsAllarmiList(String applicabilita, boolean soloAbilitati) throws DriverConfigurazioneException {
  525.         Connection con = null;
  526.         String nomeMetodo = "pluginsClassiList";
  527.         DriverControlStationDB driver = null;

  529.         try {
  530.             ISearch ricercaPlugin = new ConsoleSearch(true);
  531.             ricercaPlugin.addFilter( Liste.CONFIGURAZIONE_PLUGINS_CLASSI, Filtri.FILTRO_TIPO_PLUGIN_CLASSI, TipoPlugin.ALLARME.toString());
  532.             ricercaPlugin.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI,  Filtri.FILTRO_APPLICABILITA_NOME, applicabilita);
  533.             if(soloAbilitati) {
  534.                 ricercaPlugin.addFilter(Liste.CONFIGURAZIONE_PLUGINS_CLASSI, Filtri.FILTRO_STATO, Filtri.FILTRO_STATO_VALORE_ABILITATO);
  535.             }
  536.             // prendo una connessione
  537.             con = ControlStationCore.dbM.getConnection();
  538.             // istanzio il driver
  539.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  540.             List<Plugin> pluginsClassiList = new ArrayList<>();
  541.             List<Plugin> p = driver.pluginsClassiList(ricercaPlugin);
  542.             
  543.             Map<String, Plugin> plugins = new HashMap<>();
  544.             List<String> keys = new ArrayList<>();
  545.             if(p!=null && !p.isEmpty()){
  546.                 for (Plugin plugin : p) {
  547.                     String key = plugin.getLabel() + "_" + plugin.getClassName();
  548.                     keys.add(key); // possono esistere più plugin con lo stesso label
  549.                     plugins.put(key, plugin);
  550.                 }   
  551.                 
  552.                 // ordino
  553.                 Collections.sort(keys);
  554.                 
  555.                 for (String key : keys) {
  556.                     pluginsClassiList.add(plugins.get(key));
  557.                 }
  558.             }
  559.             
  560.             return pluginsClassiList;
  561.         } catch (Exception e) {
  562.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  563.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  564.         } finally {
  565.             ControlStationCore.dbM.releaseConnection(con);
  566.         }
  567.     }
  568.     
  569.     
  570.     public RegistroPlugins getRegistroPlugins() throws DriverConfigurazioneException {
  571.         Connection con = null;
  572.         String nomeMetodo = "getRegistroPlugins";
  573.         DriverControlStationDB driver = null;

  575.         try {
  576.             // prendo una connessione
  577.             con = ControlStationCore.dbM.getConnection();
  578.             // istanzio il driver
  579.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  580.             return driver.getDriverConfigurazioneDB().getRegistroPlugins();
  581.         } catch (Exception e) {
  582.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  583.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  584.         } finally {
  585.             ControlStationCore.dbM.releaseConnection(con);
  586.         }
  587.     }
  588.     
  589.     public int numeroPluginsClassiList() throws DriverConfigurazioneException {
  590.         Connection con = null;
  591.         String nomeMetodo = "numeroPluginsClassiList";
  592.         DriverControlStationDB driver = null;

  594.         try {
  595.             // prendo una connessione
  596.             con = ControlStationCore.dbM.getConnection();
  597.             // istanzio il driver
  598.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  599.             return driver.numeroPluginsClassiList();
  600.         } catch (Exception e) {
  601.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  602.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  603.         } finally {
  604.             ControlStationCore.dbM.releaseConnection(con);
  605.         }
  606.     }
  607.     
  608.     public boolean existsPlugin(TipoPlugin tipoPlugin, String tipo, String label, String className) throws DriverConfigurazioneException { 
  609.         Connection con = null;
  610.         String nomeMetodo = "existsPlugin";
  611.         DriverControlStationDB driver = null;

  613.         try {
  614.             // prendo una connessione
  615.             con = ControlStationCore.dbM.getConnection();
  616.             // istanzio il driver
  617.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  618.             return driver.existsPlugin(tipoPlugin, tipo,label, className); 
  619.         } catch (Exception e) {
  620.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  621.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  622.         } finally {
  623.             ControlStationCore.dbM.releaseConnection(con);
  624.         }
  625.     }
  626.     
  627.     public boolean existsPluginConTipo(TipoPlugin tipoPlugin, String tipo) throws DriverConfigurazioneException { 
  628.         Connection con = null;
  629.         String nomeMetodo = "existsPluginConTipo";
  630.         DriverControlStationDB driver = null;

  632.         try {
  633.             // prendo una connessione
  634.             con = ControlStationCore.dbM.getConnection();
  635.             // istanzio il driver
  636.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  637.             return driver.existsPluginConTipo(tipoPlugin, tipo); 
  638.         } catch (Exception e) {
  639.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  640.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  641.         } finally {
  642.             ControlStationCore.dbM.releaseConnection(con);
  643.         }
  644.     }
  645.     
  646.     public boolean existsPluginConLabel(TipoPlugin tipoPlugin, String label) throws DriverConfigurazioneException { 
  647.         Connection con = null;
  648.         String nomeMetodo = "existsPluginConLabel";
  649.         DriverControlStationDB driver = null;

  651.         try {
  652.             // prendo una connessione
  653.             con = ControlStationCore.dbM.getConnection();
  654.             // istanzio il driver
  655.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  656.             return driver.existsPluginConLabel(tipoPlugin, label); 
  657.         } catch (Exception e) {
  658.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  659.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  660.         } finally {
  661.             ControlStationCore.dbM.releaseConnection(con);
  662.         }
  663.     }
  664.     
  665.     public boolean existsPluginConClassName(TipoPlugin tipoPlugin, String className) throws DriverConfigurazioneException { 
  666.         Connection con = null;
  667.         String nomeMetodo = "existsPluginConClassName";
  668.         DriverControlStationDB driver = null;

  670.         try {
  671.             // prendo una connessione
  672.             con = ControlStationCore.dbM.getConnection();
  673.             // istanzio il driver
  674.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  675.             return driver.existsPluginConClassName(tipoPlugin, className); 
  676.         } catch (Exception e) {
  677.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  678.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  679.         } finally {
  680.             ControlStationCore.dbM.releaseConnection(con);
  681.         }
  682.     }
  683.     
  684.     public Plugin getPlugin(long idPlugin) throws DriverConfigurazioneException {
  685.         Connection con = null;
  686.         String nomeMetodo = "getPlugin";
  687.         DriverControlStationDB driver = null;

  689.         try {
  690.             // prendo una connessione
  691.             con = ControlStationCore.dbM.getConnection();
  692.             // istanzio il driver
  693.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  694.             return driver.getPlugin(idPlugin);  
  695.         } catch (Exception e) {
  696.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  697.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  698.         } finally {
  699.             ControlStationCore.dbM.releaseConnection(con);
  700.         }
  701.     }
  702.     
  703.     public Plugin getPlugin(TipoPlugin tipoPlugin, String tipo, boolean throwNotFound) throws DriverConfigurazioneException {
  704.         Connection con = null;
  705.         String nomeMetodo = "getPlugin";
  706.         DriverControlStationDB driver = null;

  708.         try {
  709.             // prendo una connessione
  710.             con = ControlStationCore.dbM.getConnection();
  711.             // istanzio il driver
  712.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  713.             return driver.getPlugin(tipoPlugin,tipo, throwNotFound);  
  714.         } catch (Exception e) {
  715.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  716.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  717.         } finally {
  718.             ControlStationCore.dbM.releaseConnection(con);
  719.         }
  720.     }
  721.     
  722.     public boolean isPluginInUso(String className, String label, String tipoPlugin, String tipo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  723.         Connection con = null;
  724.         String nomeMetodo = "isPluginInUso";
  725.         DriverControlStationDB driver = null;

  727.         try {
  728.             // prendo una connessione
  729.             con = ControlStationCore.dbM.getConnection();
  730.             // istanzio il driver
  731.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  733.             return driver.isPluginInUso(className, label, tipoPlugin, tipo, whereIsInUso, normalizeObjectIds);

  735.         } catch (Exception e) {
  736.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  737.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  738.         } finally {
  739.             ControlStationCore.dbM.releaseConnection(con);
  740.         }

  742.     }
  743.     
  744.     public int numeroHandlersRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  745.         Connection con = null;
  746.         String nomeMetodo = "numeroHandlersRichiestaList";
  747.         DriverControlStationDB driver = null;

  749.         try {
  750.             // prendo una connessione
  751.             con = ControlStationCore.dbM.getConnection();
  752.             // istanzio il driver
  753.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  754.             return driver.numeroHandlersRichiestaList(getTipologiaFromFaseMessageHandler(tipologia, true), ruoloPorta, idPorta);
  755.         } catch (Exception e) {
  756.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  757.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  758.         } finally {
  759.             ControlStationCore.dbM.releaseConnection(con);
  760.         }
  761.     }
  762.     
  763.     public int numeroHandlersRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  764.         Connection con = null;
  765.         String nomeMetodo = "numeroHandlersRispostaList";
  766.         DriverControlStationDB driver = null;

  768.         try {
  769.             // prendo una connessione
  770.             con = ControlStationCore.dbM.getConnection();
  771.             // istanzio il driver
  772.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  773.             return driver.numeroHandlersRispostaList(getTipologiaFromFaseMessageHandler(tipologia, false), ruoloPorta, idPorta);
  774.         } catch (Exception e) {
  775.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  776.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  777.         } finally {
  778.             ControlStationCore.dbM.releaseConnection(con);
  779.         }
  780.     }
  781.     
  782.     public int numeroHandlersServizio(String tipologia) throws DriverConfigurazioneException {
  783.         Connection con = null;
  784.         String nomeMetodo = "numeroHandlersServizioList";
  785.         DriverControlStationDB driver = null;

  787.         try {
  788.             // prendo una connessione
  789.             con = ControlStationCore.dbM.getConnection();
  790.             // istanzio il driver
  791.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  792.             return driver.numeroHandlersServizioList(getTipologiaFromFaseServiceHandler(tipologia), null, null);
  793.         } catch (Exception e) {
  794.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  795.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  796.         } finally {
  797.             ControlStationCore.dbM.releaseConnection(con);
  798.         }
  799.     }
  800.     
  801.     public List<ConfigurazioneHandlerBean> handlersRichiestaList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  802.         Connection con = null;
  803.         String nomeMetodo = "handlersRichiestaList";
  804.         DriverControlStationDB driver = null;

  806.         try {
  807.             // prendo una connessione
  808.             con = ControlStationCore.dbM.getConnection();
  809.             // istanzio il driver
  810.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  811.             return driver.handlersRichiestaList(ricerca, getTipologiaFromFaseMessageHandler(tipologia, true), ruoloPorta, idPorta);
  812.         } catch (Exception e) {
  813.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  814.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  815.         } finally {
  816.             ControlStationCore.dbM.releaseConnection(con);
  817.         }
  818.     }
  819.     
  820.     public List<ConfigurazioneHandlerBean> handlersRispostaList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  821.         Connection con = null;
  822.         String nomeMetodo = "handlersRispostaList";
  823.         DriverControlStationDB driver = null;

  825.         try {
  826.             // prendo una connessione
  827.             con = ControlStationCore.dbM.getConnection();
  828.             // istanzio il driver
  829.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  830.             return driver.handlersRispostaList(ricerca, getTipologiaFromFaseMessageHandler(tipologia, false), ruoloPorta, idPorta);
  831.         } catch (Exception e) {
  832.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  833.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  834.         } finally {
  835.             ControlStationCore.dbM.releaseConnection(con);
  836.         }
  837.     }
  838.     
  839.     public List<ConfigurazioneHandlerBean> handlersServizioList(ISearch ricerca, String tipologia) throws DriverConfigurazioneException {
  840.         Connection con = null;
  841.         String nomeMetodo = "handlersServizioList";
  842.         DriverControlStationDB driver = null;

  844.         try {
  845.             // prendo una connessione
  846.             con = ControlStationCore.dbM.getConnection();
  847.             // istanzio il driver
  848.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  849.             return driver.handlersServizioList(ricerca, getTipologiaFromFaseServiceHandler(tipologia), null, null);
  850.         } catch (Exception e) {
  851.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  852.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  853.         } finally {
  854.             ControlStationCore.dbM.releaseConnection(con);
  855.         }
  856.     }
  857.     
  858.     public int getMaxPosizioneHandlersRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  859.         Connection con = null;
  860.         String nomeMetodo = "getMaxPosizioneHandlersRichiesta";
  861.         DriverControlStationDB driver = null;

  863.         try {
  864.             // prendo una connessione
  865.             con = ControlStationCore.dbM.getConnection();
  866.             // istanzio il driver
  867.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  868.             return driver.getMaxPosizioneHandlersRichiesta(getTipologiaFromFaseMessageHandler(tipologia, true), ruoloPorta, idPorta);
  869.         } catch (Exception e) {
  870.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  871.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  872.         } finally {
  873.             ControlStationCore.dbM.releaseConnection(con);
  874.         }
  875.     }
  876.     
  877.     public int getMaxPosizioneHandlersRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  878.         Connection con = null;
  879.         String nomeMetodo = "getMaxPosizioneHandlersRisposta";
  880.         DriverControlStationDB driver = null;

  882.         try {
  883.             // prendo una connessione
  884.             con = ControlStationCore.dbM.getConnection();
  885.             // istanzio il driver
  886.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  887.             return driver.getMaxPosizioneHandlersRisposta(getTipologiaFromFaseMessageHandler(tipologia, false), ruoloPorta, idPorta);
  888.         } catch (Exception e) {
  889.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  890.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  891.         } finally {
  892.             ControlStationCore.dbM.releaseConnection(con);
  893.         }
  894.     }
  895.     
  896.     public int getMaxPosizioneHandlersServizio(String tipologia) throws DriverConfigurazioneException {
  897.         Connection con = null;
  898.         String nomeMetodo = "getMaxPosizioneHandlersServizio";
  899.         DriverControlStationDB driver = null;

  901.         try {
  902.             // prendo una connessione 
  903.             con = ControlStationCore.dbM.getConnection();
  904.             // istanzio il driver
  905.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  906.             return driver.getMaxPosizioneHandlersServizio(getTipologiaFromFaseServiceHandler(tipologia), null, null);
  907.         } catch (Exception e) {
  908.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  909.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  910.         } finally {
  911.             ControlStationCore.dbM.releaseConnection(con);
  912.         }
  913.     }
  914.     
  915.     public boolean existsHandlerRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta, String tipo) throws DriverConfigurazioneException {
  916.         Connection con = null;
  917.         String nomeMetodo = "existsHandlerRichiesta";
  918.         DriverControlStationDB driver = null;

  920.         try {
  921.             // prendo una connessione
  922.             con = ControlStationCore.dbM.getConnection();
  923.             // istanzio il driver
  924.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  925.             return driver.existsHandlerRichiesta(getTipologiaFromFaseMessageHandler(tipologia, true), ruoloPorta, idPorta, tipo);
  926.         } catch (Exception e) {
  927.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  928.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  929.         } finally {
  930.             ControlStationCore.dbM.releaseConnection(con);
  931.         }
  932.     }
  933.     
  934.     public boolean existsHandlerRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta, String tipo) throws DriverConfigurazioneException {
  935.         Connection con = null;
  936.         String nomeMetodo = "existsHandlerRisposta";
  937.         DriverControlStationDB driver = null;

  939.         try {
  940.             // prendo una connessione
  941.             con = ControlStationCore.dbM.getConnection();
  942.             // istanzio il driver
  943.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  944.             return driver.existsHandlerRisposta(getTipologiaFromFaseMessageHandler(tipologia, false), ruoloPorta, idPorta, tipo);
  945.         } catch (Exception e) {
  946.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  947.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  948.         } finally {
  949.             ControlStationCore.dbM.releaseConnection(con);
  950.         }
  951.     }
  952.     
  953.     public boolean existsHandlerServizio(String tipologia, String tipo) throws DriverConfigurazioneException {
  954.         Connection con = null;
  955.         String nomeMetodo = "existsHandlerServizio";
  956.         DriverControlStationDB driver = null;

  958.         try {
  959.             // prendo una connessione 
  960.             con = ControlStationCore.dbM.getConnection();
  961.             // istanzio il driver
  962.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  963.             return driver.existsHandlerServizio(getTipologiaFromFaseServiceHandler(tipologia), null, null, tipo);
  964.         } catch (Exception e) {
  965.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  966.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  967.         } finally {
  968.             ControlStationCore.dbM.releaseConnection(con);
  969.         }
  970.     }
  971.     
  972.     public ConfigurazioneHandlerBean getHandlerRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta, Long idHandler) throws DriverConfigurazioneException {
  973.         Connection con = null;
  974.         String nomeMetodo = "getHandlerRichiesta";
  975.         DriverControlStationDB driver = null;

  977.         try {
  978.             // prendo una connessione
  979.             con = ControlStationCore.dbM.getConnection();
  980.             // istanzio il driver
  981.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  982.             return driver.getHandlerRichiesta(getTipologiaFromFaseMessageHandler(tipologia, true), ruoloPorta, idPorta, idHandler);
  983.         } catch (Exception e) {
  984.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  985.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  986.         } finally {
  987.             ControlStationCore.dbM.releaseConnection(con);
  988.         }
  989.     }
  990.     
  991.     public ConfigurazioneHandlerBean getHandlerRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta, Long idHandler) throws DriverConfigurazioneException {
  992.         Connection con = null;
  993.         String nomeMetodo = "getHandlerRisposta";
  994.         DriverControlStationDB driver = null;

  996.         try {
  997.             // prendo una connessione
  998.             con = ControlStationCore.dbM.getConnection();
  999.             // istanzio il driver
  1000.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1001.             return driver.getHandlerRisposta(getTipologiaFromFaseMessageHandler(tipologia, false), ruoloPorta, idPorta, idHandler);
  1002.         } catch (Exception e) {
  1003.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1004.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1005.         } finally {
  1006.             ControlStationCore.dbM.releaseConnection(con);
  1007.         }
  1008.     }
  1009.     
  1010.     public ConfigurazioneHandlerBean getHandlerServizio(String tipologia, Long idHandler) throws DriverConfigurazioneException {
  1011.         Connection con = null;
  1012.         String nomeMetodo = "getHandlerServizio";
  1013.         DriverControlStationDB driver = null;

  1015.         try {
  1016.             // prendo una connessione 
  1017.             con = ControlStationCore.dbM.getConnection();
  1018.             // istanzio il driver
  1019.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1020.             return driver.getHandlerServizio(getTipologiaFromFaseServiceHandler(tipologia), null, null, idHandler);
  1021.         } catch (Exception e) {
  1022.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1023.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1024.         } finally {
  1025.             ControlStationCore.dbM.releaseConnection(con);
  1026.         }
  1027.     }
  1028.     
  1029.     private String getTipologiaFromFaseMessageHandler(String fase, boolean request) {
  1030.         if(fase != null) {
  1031.             return getTipologiaFromFaseMessageHandler(FaseMessageHandler.toEnumConstant(fase), request);
  1032.         }
  1033.         return null;
  1034.     }
  1035.     private String getTipologiaFromFaseMessageHandler(FaseMessageHandler fase, boolean request) {
  1036.         if(fase != null) {
  1037.             String suffix = request ? CostantiDB.HANDLER_REQUEST_SUFFIX : CostantiDB.HANDLER_RESPONSE_SUFFIX; 
  1038.             switch (fase) {
  1039.             case IN:
  1040.                 return CostantiDB.HANDLER_IN+suffix;
  1041.             case IN_PROTOCOL_INFO:
  1042.                 return CostantiDB.HANDLER_IN_PROTOCOL+suffix;
  1043.             case OUT:
  1044.                 return CostantiDB.HANDLER_OUT+suffix;
  1045.             case POST_OUT:
  1046.                 return CostantiDB.HANDLER_POST_OUT+suffix;
  1047.             case PRE_IN:
  1048.                 return CostantiDB.HANDLER_PRE_IN+suffix;
  1049.             }
  1050.         }
  1051.         
  1052.         return null;
  1053.     }
  1054.     
  1055.     private String getTipologiaFromFaseServiceHandler(String fase) {
  1056.         if(fase != null) {
  1057.             return getTipologiaFromFaseServiceHandler(FaseServiceHandler.toEnumConstant(fase));
  1058.         }
  1059.         return null;
  1060.     }
  1061.     private String getTipologiaFromFaseServiceHandler(FaseServiceHandler fase) {
  1062.         if(fase != null) {
  1063.             switch (fase) {
  1064.             case EXIT:
  1065.                 return CostantiDB.HANDLER_EXIT;
  1066.             case INIT:
  1067.                 return CostantiDB.HANDLER_INIT;
  1068.             case INTEGRATION_MANAGER_REQUEST:
  1069.                 return CostantiDB.HANDLER_INTEGRATION_MANAGER_REQUEST;
  1070.             case INTEGRATION_MANAGER_RESPONSE:
  1071.                 return CostantiDB.HANDLER_INTEGRATION_MANAGER_RESPONSE;
  1072.             }
  1073.         }
  1074.         
  1075.         return null;
  1076.     }
  1077.         
  1078.     /**
  1079.      * Restituisce la gestione dell'errore di default definita nella Porta di
  1080.      * Dominio per il componente di cooperazione
  1081.      * 
  1082.      * @return La gestione dell'errore
  1083.      * 
  1084.      */
  1085.     public GestioneErrore getGestioneErroreComponenteCooperazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1086.         return this.getGestioneErrore(true);
  1087.     }

  1089.     /**
  1090.      * Restituisce la gestione dell'errore di default definita nella Porta di
  1091.      * Dominio per il componente di integrazione
  1092.      * 
  1093.      * @return La gestione dell'errore
  1094.      * 
  1095.      */
  1096.     public GestioneErrore getGestioneErroreComponenteIntegrazione() throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1097.         return this.getGestioneErrore(false);
  1098.     }

  1100.     private GestioneErrore getGestioneErrore(boolean cooperazione) throws DriverConfigurazioneException, DriverConfigurazioneNotFound {
  1101.         Connection con = null;
  1102.         String nomeMetodo = "getGestioneErrore";
  1103.         DriverControlStationDB driver = null;

  1105.         try {
  1106.             // prendo una connessione
  1107.             con = ControlStationCore.dbM.getConnection();
  1108.             // istanzio il driver
  1109.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1111.             if (cooperazione)
  1112.                 return driver.getDriverConfigurazioneDB().getGestioneErroreComponenteCooperazione();
  1113.             else
  1114.                 return driver.getDriverConfigurazioneDB().getGestioneErroreComponenteIntegrazione();

  1116.         } catch (DriverConfigurazioneNotFound de) {
  1117.             ControlStationCore.logError(getPrefixError(nomeMetodo,  de),de);
  1118.             throw de;
  1119.         } catch (Exception e) {
  1120.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1121.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1122.         } finally {
  1123.             ControlStationCore.dbM.releaseConnection(con);
  1124.         }

  1126.     }
  1127.     
  1128.     public AccessoRegistro getAccessoRegistro() throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  1129.         Connection con = null;
  1130.         String nomeMetodo = "getAccessoRegistro";
  1131.         DriverControlStationDB driver = null;

  1133.         try {
  1134.             // prendo una connessione
  1135.             con = ControlStationCore.dbM.getConnection();
  1136.             // istanzio il driver
  1137.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1139.             return driver.getDriverConfigurazioneDB().getAccessoRegistro();

  1141.         } catch (DriverConfigurazioneNotFound de) {
  1142.             ControlStationCore.logError(getPrefixError(nomeMetodo,  de),de);
  1143.             throw de;
  1144.         } catch (Exception e) {
  1145.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1146.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1147.         } finally {
  1148.             ControlStationCore.dbM.releaseConnection(con);
  1149.         }

  1151.     }
  1152.     
  1153.     public AccessoConfigurazione getAccessoConfigurazione() throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  1154.         Connection con = null;
  1155.         String nomeMetodo = "getAccessoConfigurazione";
  1156.         DriverControlStationDB driver = null;

  1158.         try {
  1159.             // prendo una connessione
  1160.             con = ControlStationCore.dbM.getConnection();
  1161.             // istanzio il driver
  1162.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1164.             return driver.getDriverConfigurazioneDB().getAccessoConfigurazione();

  1166.         } catch (DriverConfigurazioneNotFound de) {
  1167.             ControlStationCore.logError(getPrefixError(nomeMetodo,  de),de);
  1168.             throw de;
  1169.         } catch (Exception e) {
  1170.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1171.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1172.         } finally {
  1173.             ControlStationCore.dbM.releaseConnection(con);
  1174.         }

  1176.     }
  1177.     
  1178.     public AccessoDatiAutorizzazione getAccessoDatiAutorizzazione() throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  1179.         Connection con = null;
  1180.         String nomeMetodo = "getAccessoDatiAutorizzazione";
  1181.         DriverControlStationDB driver = null;

  1183.         try {
  1184.             // prendo una connessione
  1185.             con = ControlStationCore.dbM.getConnection();
  1186.             // istanzio il driver
  1187.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1189.             return driver.getDriverConfigurazioneDB().getAccessoDatiAutorizzazione();

  1191.         } catch (DriverConfigurazioneNotFound de) {
  1192.             ControlStationCore.logError(getPrefixError(nomeMetodo,  de),de);
  1193.             throw de;
  1194.         } catch (Exception e) {
  1195.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1196.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1197.         } finally {
  1198.             ControlStationCore.dbM.releaseConnection(con);
  1199.         }

  1201.     }
  1202.     
  1203.     public SystemProperties getSystemPropertiesPdD() throws DriverConfigurazioneNotFound, DriverConfigurazioneException {
  1204.         Connection con = null;
  1205.         String nomeMetodo = "getSystemPropertiesPdD";
  1206.         DriverControlStationDB driver = null;

  1208.         try {
  1209.             // prendo una connessione
  1210.             con = ControlStationCore.dbM.getConnection();
  1211.             // istanzio il driver
  1212.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1214.             return driver.getDriverConfigurazioneDB().getSystemPropertiesPdD();

  1216.         } catch (DriverConfigurazioneNotFound de) {
  1217.             return new SystemProperties();
  1218.         } catch (Exception e) {
  1219.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1220.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1221.         } finally {
  1222.             ControlStationCore.dbM.releaseConnection(con);
  1223.         }

  1225.     }
  1226.     
  1227.     public List<Property> systemPropertyList(ISearch ricerca) throws DriverConfigurazioneException {
  1228.         Connection con = null;
  1229.         String nomeMetodo = "systemPropertyList";
  1230.         DriverControlStationDB driver = null;

  1232.         try {
  1233.             // prendo una connessione
  1234.             con = ControlStationCore.dbM.getConnection();
  1235.             // istanzio il driver
  1236.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1238.             return driver.getDriverConfigurazioneDB().systemPropertyList(ricerca);

  1240.         } 
  1241.         catch (Exception e) {
  1242.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1243.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1244.         } finally {
  1245.             ControlStationCore.dbM.releaseConnection(con);
  1246.         }
  1247.     }
  1248.     
  1249.     public RoutingTable getRoutingTable() throws DriverConfigurazioneException {
  1250.         Connection con = null;
  1251.         String nomeMetodo = "getRoutingTable";
  1252.         DriverControlStationDB driver = null;

  1254.         try {
  1255.             // prendo una connessione
  1256.             con = ControlStationCore.dbM.getConnection();
  1257.             // istanzio il driver
  1258.             driver = new DriverControlStationDB(con, null, this.tipoDB);

  1260.             return driver.getDriverConfigurazioneDB().getRoutingTable();
  1261.         } catch (Exception e) {
  1262.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1263.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  1264.         } finally {
  1265.             ControlStationCore.dbM.releaseConnection(con);
  1266.         }

  1268.     }
  1269.     
  1270.     
  1271.     public List<Filtro> filtriList(ISearch ricerca) throws AuditException {
  1272.         Connection con = null;
  1273.         String nomeMetodo = "filtriList";
  1274.         DriverAudit driver = null;

  1276.         try {
  1277.             // prendo una connessione
  1278.             con = ControlStationCore.dbM.getConnection();
  1279.             // istanzio il driver
  1280.             driver = new DriverAudit(con, this.tipoDB);
  1281.             return driver.filtriList(ricerca, Liste.FILTRI);
  1282.         } catch (Exception e) {
  1283.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1284.             throw new AuditException(getPrefixError(nomeMetodo,  e),e);
  1285.         } finally {
  1286.             ControlStationCore.dbM.releaseConnection(con);
  1287.         }
  1288.     }

  1290.     public Filtro getFiltro(long idFiltro) throws AuditException {
  1291.         Connection con = null;
  1292.         String nomeMetodo = "getFiltro";
  1293.         DriverAudit driver = null;

  1295.         try {
  1296.             // prendo una connessione
  1297.             con = ControlStationCore.dbM.getConnection();
  1298.             // istanzio il driver
  1299.             driver = new DriverAudit(con, this.tipoDB);
  1300.             return driver.getFiltro(idFiltro);
  1301.         } catch (Exception e) {
  1302.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1303.             throw new AuditException(getPrefixError(nomeMetodo,  e),e);
  1304.         } finally {
  1305.             ControlStationCore.dbM.releaseConnection(con);
  1306.         }
  1307.     }
  1308.     
  1309.     
  1310.     public UrlInvocazioneAPI getConfigurazioneUrlInvocazione(String protocollo,
  1311.             RuoloContesto ruolo, ServiceBinding serviceBinding, String interfaceName, IDSoggetto soggettoOperativo,
  1312.             AccordoServizioParteComuneSintetico aspc, String canalePorta, boolean analizeProxyPassRules) throws DriverConfigurazioneException, DriverConfigurazioneNotFound, ProtocolException  {
  1313.         
  1314.         IProtocolFactory<?>protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo);
  1315.         
  1316.         Configurazione config = this.getConfigurazioneGenerale();
  1317.         
  1318.         ConfigurazioneUrlInvocazione configurazioneUrlInvocazione = null;
  1319.         if(config!=null && config.getUrlInvocazione()!=null) {
  1320.             configurazioneUrlInvocazione = config.getUrlInvocazione();
  1321.         }
  1322.         
  1323.         List<String> tags = new ArrayList<>();
  1324.         if(aspc!=null && aspc.getGruppo()!=null && !aspc.getGruppo().isEmpty()) {
  1325.             for (int i = 0; i < aspc.getGruppo().size(); i++) {
  1326.                 tags.add(aspc.getGruppo().get(i).getNome());
  1327.             }
  1328.         }
  1329.         
  1330.         String canaleApi = null;
  1331.         if(aspc!=null) {
  1332.             canaleApi = aspc.getCanale();
  1333.         }
  1334.         String canale = CanaliUtils.getCanale(config!=null ? config.getGestioneCanali() : null, canaleApi, canalePorta);
  1335.         
  1336.         return UrlInvocazioneAPI.getConfigurazioneUrlInvocazione(configurazioneUrlInvocazione, protocolFactory, ruolo, serviceBinding, interfaceName, soggettoOperativo,
  1337.                 tags, canale, analizeProxyPassRules);

  1339.     }
  1340.     
  1341.     
  1342.     /**
  1343.      * Accesso alla configurazione di controllo del traffico
  1344.      * 
  1345.      * @return configurazione controllo del traffico della Pdd
  1346.      * @throws DriverControlStationNotFound
  1347.      * @throws DriverControlStationException
  1348.      */
  1349.     public ConfigurazioneGenerale getConfigurazioneControlloTraffico() throws DriverControlStationNotFound, DriverControlStationException {
  1350.         Connection con = null;
  1351.         String nomeMetodo = "getConfigurazioneControlloTraffico";
  1352.         DriverControlStationDB driver = null;

  1354.         try {
  1355.             // prendo una connessione
  1356.             con = ControlStationCore.dbM.getConnection();
  1357.             // istanzio il driver
  1358.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1359.             
  1360.             return driver.getConfigurazioneControlloTraffico();
  1361.             
  1362.         } catch (DriverControlStationNotFound de) {
  1363.             ControlStationCore.logError(getPrefixError(nomeMetodo,  de),de);
  1364.             throw de;
  1365.         } catch (Exception e) {
  1366.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1367.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1368.         } finally {
  1369.             ControlStationCore.dbM.releaseConnection(con);
  1370.         }

  1372.     }
  1373.     
  1374.     public PolicyConfiguration getConfigurazioneControlloTrafficoRateLimitingProperties() throws DriverControlStationNotFound, DriverControlStationException {
  1375.         Connection con = null;
  1376.         String nomeMetodo = "getConfigurazioneControlloTrafficoRateLimitingProperties";
  1377.         DriverControlStationDB driver = null;

  1379.         try {
  1380.             // prendo una connessione
  1381.             con = ControlStationCore.dbM.getConnection();
  1382.             // istanzio il driver
  1383.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1384.             
  1385.             List<Proprieta> l = driver.getProprietaRateLimiting();
  1386.             return new PolicyConfiguration(l, this.getControlloTrafficoPolicyRateLimitingTipiGestori(), false);
  1387.             
  1388.         } catch (DriverControlStationNotFound de) {
  1389.             ControlStationCore.logError(getPrefixError(nomeMetodo,  de),de);
  1390.             throw de;
  1391.         } catch (Exception e) {
  1392.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1393.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1394.         } finally {
  1395.             ControlStationCore.dbM.releaseConnection(con);
  1396.         }

  1398.     }
  1399.     
  1400.     public long countConfigurazionePolicy(ConsoleSearch ricerca)  throws DriverControlStationException {
  1401.         String nomeMetodo = "countConfigurazionePolicy";
  1402.         Connection con = null;
  1403.         DriverControlStationDB driver = null;
  1404.         try {
  1405.             // prendo una connessione
  1406.             con = ControlStationCore.dbM.getConnection();
  1407.             
  1408.             // istanzio il driver
  1409.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1410.             
  1411.             return driver.countConfigurazioneControlloTrafficoConfigurazionePolicy(ricerca);
  1412.         } catch (Exception e) {
  1413.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1414.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1415.         }finally{
  1416.             ControlStationCore.dbM.releaseConnection(con);
  1417.         }
  1418.     }
  1419.     
  1420.     public long countAttivazionePolicy(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta)  throws DriverControlStationException{
  1421.         String nomeMetodo = "countAttivazionePolicy";
  1422.         Connection con = null;
  1423.         DriverControlStationDB driver = null;
  1424.         try {
  1425.             // prendo una connessione
  1426.             con = ControlStationCore.dbM.getConnection();
  1427.             
  1428.             // istanzio il driver
  1429.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1430.             
  1431.             return driver.countConfigurazioneControlloTrafficoAttivazionePolicy(ricerca, ruoloPorta, nomePorta);
  1432.         } catch (Exception e) {
  1433.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1434.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1435.         }finally{
  1436.             ControlStationCore.dbM.releaseConnection(con);
  1437.         }
  1438.     }
  1439.     
  1440.     public List<ConfigurazionePolicy> configurazionePolicyList(ConsoleSearch ricerca)  throws DriverControlStationException{
  1441.         String nomeMetodo = "configurazionePolicyList";
  1442.         Connection con = null;
  1443.         DriverControlStationDB driver = null;
  1444.         try {
  1445.             // prendo una connessione
  1446.             con = ControlStationCore.dbM.getConnection();
  1447.             
  1448.             // istanzio il driver
  1449.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1450.             
  1451.             return driver.configurazioneControlloTrafficoConfigurazionePolicyList(ricerca);
  1452.         } catch (Exception e) {
  1453.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1454.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1455.         }finally{
  1456.             ControlStationCore.dbM.releaseConnection(con);
  1457.         }
  1458.     }
  1459.     
  1460.     public List<ConfigurazionePolicy> configurazioneControlloTrafficoConfigurazionePolicyListConApplicabilitaAllarme(String idAllarme) throws DriverControlStationException{
  1461.         String nomeMetodo = "configurazioneControlloTrafficoConfigurazionePolicyListConApplicabilitaAllarme";
  1462.         Connection con = null;
  1463.         DriverControlStationDB driver = null;
  1464.         try {
  1465.             // prendo una connessione
  1466.             con = ControlStationCore.dbM.getConnection();
  1467.             
  1468.             // istanzio il driver
  1469.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1470.             
  1471.             return driver.configurazioneControlloTrafficoConfigurazionePolicyList_conApplicabilitaAllarme(idAllarme);
  1472.         } catch (Exception e) {
  1473.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1474.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1475.         }finally{
  1476.             ControlStationCore.dbM.releaseConnection(con);
  1477.         }
  1478.     }
  1479.     
  1480.     public List<TipoRisorsaPolicyAttiva> attivazionePolicyTipoRisorsaList(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta)  throws DriverControlStationException{
  1481.         String nomeMetodo = "attivazionePolicyTipoRisorsaList";
  1482.         Connection con = null;
  1483.         DriverControlStationDB driver = null;
  1484.         try {
  1485.             // prendo una connessione
  1486.             con = ControlStationCore.dbM.getConnection();
  1487.             
  1488.             // istanzio il driver
  1489.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1490.             
  1491.             return driver.configurazioneControlloTrafficoAttivazionePolicyTipoRisorsaList(ricerca, ruoloPorta, nomePorta);
  1492.         } catch (Exception e) {
  1493.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1494.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1495.         }finally{
  1496.             ControlStationCore.dbM.releaseConnection(con);
  1497.         }
  1498.     }
  1499.     
  1500.     public void updatePosizioneAttivazionePolicy(InfoPolicy infoPolicy, AttivazionePolicy policy,
  1501.             RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException{
  1502.         String nomeMetodo = "updatePosizioneAttivazionePolicy";
  1503.         Connection con = null;
  1504.         DriverControlStationDB driver = null;
  1505.         try {
  1506.             // prendo una connessione
  1507.             con = ControlStationCore.dbM.getConnection();
  1508.             
  1509.             // istanzio il driver
  1510.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1511.             
  1512.             driver.updatePosizioneAttivazionePolicy(infoPolicy, policy,
  1513.                     ruoloPorta, nomePorta);
  1514.         } catch (Exception e) {
  1515.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1516.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1517.         }finally{
  1518.             ControlStationCore.dbM.releaseConnection(con);
  1519.         }
  1520.     }
  1521.     
  1522.     public List<AttivazionePolicy> attivazionePolicyList(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta)  throws DriverControlStationException{
  1523.         String nomeMetodo = "attivazionePolicyList";
  1524.         Connection con = null;
  1525.         DriverControlStationDB driver = null;
  1526.         try {
  1527.             // prendo una connessione
  1528.             con = ControlStationCore.dbM.getConnection();
  1529.             
  1530.             // istanzio il driver
  1531.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1532.             
  1533.             return driver.configurazioneControlloTrafficoAttivazionePolicyList(ricerca, ruoloPorta, nomePorta);
  1534.         } catch (Exception e) {
  1535.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1536.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1537.         }finally{
  1538.             ControlStationCore.dbM.releaseConnection(con);
  1539.         }
  1540.     }

  1542.     public List<AttivazionePolicy> attivazionePolicyListByFilter(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta,
  1543.             IDSoggetto filtroSoggettoFruitore, IDServizioApplicativo filtroApplicativoFruitore,String filtroRuoloFruitore,
  1544.             IDSoggetto filtroSoggettoErogatore, String filtroRuoloErogatore,
  1545.             IDServizio filtroServizioAzione, String filtroRuolo)  throws DriverControlStationException{
  1546.         String nomeMetodo = "attivazionePolicyListByFilter";
  1547.         Connection con = null;
  1548.         DriverControlStationDB driver = null;
  1549.         try {
  1550.             // prendo una connessione
  1551.             con = ControlStationCore.dbM.getConnection();
  1552.             
  1553.             // istanzio il driver
  1554.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1555.             
  1556.             return driver.configurazioneControlloTrafficoAttivazionePolicyListByFilter(ricerca, ruoloPorta, nomePorta,
  1557.                     filtroSoggettoFruitore, filtroApplicativoFruitore, filtroRuoloFruitore,
  1558.                     filtroSoggettoErogatore, filtroRuoloErogatore,
  1559.                     filtroServizioAzione, filtroRuolo);
  1560.         } catch (Exception e) {
  1561.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1562.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1563.         }finally{
  1564.             ControlStationCore.dbM.releaseConnection(con);
  1565.         }
  1566.     }
  1567.     
  1568.     public AttivazionePolicy getAttivazionePolicy(String alias, RuoloPolicy ruoloPorta, String nomePorta)  throws DriverControlStationException, DriverControlStationNotFound{
  1569.         String nomeMetodo = "getAttivazionePolicy(alias,ruoloPorta,nomePorta)";
  1570.         Connection con = null;
  1571.         DriverControlStationDB driver = null;
  1572.         try {
  1573.             // prendo una connessione
  1574.             con = ControlStationCore.dbM.getConnection();
  1575.             
  1576.             // istanzio il driver
  1577.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1578.             
  1579.             return driver.getAttivazionePolicy(alias, ruoloPorta, nomePorta);
  1580.         } catch(NotFoundException notFound) {
  1581.             throw new DriverControlStationNotFound(notFound.getMessage(),notFound);
  1582.         } catch (Exception e) {
  1583.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1584.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1585.         }finally{
  1586.             ControlStationCore.dbM.releaseConnection(con);
  1587.         }
  1588.     }
  1589.     
  1590.     public boolean usedInConfigurazioneControlloTrafficoAttivazionePolicy(RuoloPolicy ruoloPorta, String nomePorta, String azione)  throws DriverControlStationException{
  1591.         String nomeMetodo = "usedInConfigurazioneControlloTrafficoAttivazionePolicy";
  1592.         Connection con = null;
  1593.         DriverControlStationDB driver = null;
  1594.         try {
  1595.             // prendo una connessione
  1596.             con = ControlStationCore.dbM.getConnection();
  1597.             
  1598.             // istanzio il driver
  1599.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1600.             
  1601.             return driver.usedInConfigurazioneControlloTrafficoAttivazionePolicy(ruoloPorta, nomePorta, azione);
  1602.         } catch (Exception e) {
  1603.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1604.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1605.         }finally{
  1606.             ControlStationCore.dbM.releaseConnection(con);
  1607.         }
  1608.     }
  1609.     
  1610.     public List<InfoPolicy> infoPolicyList(Boolean builtIn)  throws DriverControlStationException{
  1611.         String nomeMetodo = "infoPolicyList";
  1612.         Connection con = null;
  1613.         DriverControlStationDB driver = null;
  1614.         try {
  1615.             // prendo una connessione
  1616.             con = ControlStationCore.dbM.getConnection();
  1617.             
  1618.             // istanzio il driver
  1619.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1620.             
  1621.             return driver.getInfoPolicyList(builtIn, null);
  1622.         } catch (Exception e) {
  1623.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1624.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1625.         }finally{
  1626.             ControlStationCore.dbM.releaseConnection(con);
  1627.         }
  1628.     }
  1629.     
  1630.     public InfoPolicy getInfoPolicy(String idPolicyParam)  throws DriverControlStationException{
  1631.         String nomeMetodo = "getInfoPolicy";
  1632.         Connection con = null;
  1633.         DriverControlStationDB driver = null;
  1634.         try {
  1635.             // prendo una connessione
  1636.             con = ControlStationCore.dbM.getConnection();
  1637.             
  1638.             // istanzio il driver
  1639.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1640.             
  1641.             List<InfoPolicy> lst = driver.getInfoPolicyList(null, idPolicyParam); 
  1642.             return (lst != null && !lst.isEmpty()) ? lst.get(0) : null;
  1643.         } catch (Exception e) {
  1644.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1645.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1646.         }finally{
  1647.             ControlStationCore.dbM.releaseConnection(con);
  1648.         }
  1649.     }
  1650.     
  1651.     public List<AttivazionePolicy> findInUseAttivazioni(String idPolicy) throws DriverControlStationException{
  1652.         return findInUseAttivazioni(idPolicy, false);
  1653.     }
  1654.     
  1655.     public List<AttivazionePolicy> findInUseAttivazioni(String idPolicy, boolean escludiDisabilitate) throws DriverControlStationException{
  1656.         String nomeMetodo = "findInUseAttivazioni";
  1657.         Connection con = null;
  1658.         DriverControlStationDB driver = null;
  1659.         try {
  1660.             // prendo una connessione
  1661.             con = ControlStationCore.dbM.getConnection();
  1662.             
  1663.             // istanzio il driver
  1664.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1665.             
  1666.             return driver.findInUseAttivazioni(idPolicy, escludiDisabilitate);
  1667.         } catch (Exception e) {
  1668.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1669.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1670.         }finally{
  1671.             ControlStationCore.dbM.releaseConnection(con);
  1672.         }
  1673.     }
  1674.     
  1675.     public long countInUseAttivazioni(String idPolicy) throws DriverControlStationException{
  1676.         return countInUseAttivazioni(idPolicy, false);
  1677.     }
  1678.     
  1679.     public long countInUseAttivazioni(String idPolicy, boolean escludiDisabilitate) throws DriverControlStationException{
  1680.         String nomeMetodo = "countInUseAttivazioni";
  1681.         Connection con = null;
  1682.         DriverControlStationDB driver = null;
  1683.         try {
  1684.             // prendo una connessione
  1685.             con = ControlStationCore.dbM.getConnection();
  1686.             
  1687.             // istanzio il driver
  1688.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  1689.             
  1690.             return driver.countInUseAttivazioni(idPolicy, escludiDisabilitate);
  1691.         } catch (Exception e) {
  1692.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1693.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1694.         }finally{
  1695.             ControlStationCore.dbM.releaseConnection(con);
  1696.         }
  1697.     }
  1698.     
  1699.     
  1700.     public ConfigurazionePolicy getConfigurazionePolicy(long id) throws DriverControlStationNotFound, DriverControlStationException{
  1701.         String nomeMetodo = "getConfigurazionePolicy";
  1702.         Connection con = null;
  1703.         DriverControlStationDB driver = null;
  1704.         try {
  1705.             // prendo una connessione
  1706.             con = ControlStationCore.dbM.getConnection();
  1707.             
  1708.             // istanzio il driver
  1709.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1710.             
  1711.             return driver.getConfigurazionePolicy(id);
  1712.         } catch (DriverControlStationNotFound e) {
  1713.             ControlStationCore.logDebug(getPrefixMethod(nomeMetodo)+"Configurazione ["+id+"] policy non presente");
  1714.             throw e;
  1715.         } catch (Exception e) {
  1716.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1717.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1718.         }finally{
  1719.             ControlStationCore.dbM.releaseConnection(con);
  1720.         }
  1721.     }
  1722.     
  1723.     public ConfigurazionePolicy getConfigurazionePolicy(String nomePolicy)  throws DriverControlStationNotFound, DriverControlStationException{
  1724.         String nomeMetodo = "getConfigurazionePolicy";
  1725.         Connection con = null;
  1726.         DriverControlStationDB driver = null;
  1727.         try {
  1728.             // prendo una connessione
  1729.             con = ControlStationCore.dbM.getConnection();
  1730.             
  1731.             // istanzio il driver
  1732.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1733.             
  1734.             return driver.getConfigurazionePolicy(nomePolicy);
  1735.         } catch (DriverControlStationNotFound e) {
  1736.             ControlStationCore.logDebug(getPrefixMethod(nomeMetodo)+"Configurazione ["+nomePolicy+"] policy non presente");
  1737.             throw e;
  1738.         } catch (Exception e) {
  1739.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1740.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1741.         }finally{
  1742.             ControlStationCore.dbM.releaseConnection(con);
  1743.         }
  1744.     }
  1745.     
  1746.     public AttivazionePolicy getAttivazionePolicy(long id)  throws DriverControlStationNotFound, DriverControlStationException{
  1747.         String nomeMetodo = "getAttivazionePolicy";
  1748.         Connection con = null;
  1749.         DriverControlStationDB driver = null;
  1750.         try {
  1751.             // prendo una connessione
  1752.             con = ControlStationCore.dbM.getConnection();
  1753.             
  1754.             // istanzio il driver
  1755.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1756.             
  1757.             return driver.getAttivazionePolicy(id);
  1758.         } catch (DriverControlStationNotFound e) {
  1759.             ControlStationCore.logDebug(getPrefixMethod(nomeMetodo)+"AttivazionePolicy ["+id+"] non presente");
  1760.             throw e;
  1761.         } catch (Exception e) {
  1762.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1763.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1764.         }finally{
  1765.             ControlStationCore.dbM.releaseConnection(con);
  1766.         }
  1767.     }
  1768.     
  1769.     public AttivazionePolicy getAttivazionePolicy(String nomePolicy)  throws DriverControlStationNotFound, DriverControlStationException{
  1770.         String nomeMetodo = "getAttivazionePolicy";
  1771.         Connection con = null;
  1772.         DriverControlStationDB driver = null;
  1773.         try {
  1774.             // prendo una connessione
  1775.             con = ControlStationCore.dbM.getConnection();
  1776.             
  1777.             // istanzio il driver
  1778.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1779.             
  1780.             return driver.getAttivazionePolicy(nomePolicy);
  1781.         } catch (DriverControlStationNotFound e) {
  1782.             ControlStationCore.logDebug("[ControlStationCore::" + nomeMetodo + "] Configurazione ["+nomePolicy+"] non presente");
  1783.             throw e;
  1784.         } catch (Exception e) {
  1785.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1786.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1787.         }finally{
  1788.             ControlStationCore.dbM.releaseConnection(con);
  1789.         }
  1790.     }
  1791.     
  1792.     public String getNextPolicyInstanceSerialId(String policyId) throws DriverControlStationException{
  1793.         String nomeMetodo = "getNextPolicyInstanceSerialId";
  1794.         Connection con = null;
  1795.         DriverControlStationDB driver = null;
  1796.         try {
  1797.             // prendo una connessione
  1798.             con = ControlStationCore.dbM.getConnection();
  1799.             
  1800.             // istanzio il driver
  1801.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1802.             
  1803.             return driver.getNextPolicyInstanceSerialId(policyId);
  1804.         } catch (Exception e) {
  1805.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1806.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1807.         }finally{
  1808.             ControlStationCore.dbM.releaseConnection(con);
  1809.         }
  1810.     }
  1811.     
  1812.     public AttivazionePolicy getPolicy(String policyId, AttivazionePolicyFiltro filtro, AttivazionePolicyRaggruppamento groupBy,
  1813.             RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationNotFound, DriverControlStationException{
  1814.         String nomeMetodo = "getGlobalPolicy";
  1815.         Connection con = null;
  1816.         DriverControlStationDB driver = null;
  1817.         try {
  1818.             // prendo una connessione
  1819.             con = ControlStationCore.dbM.getConnection();
  1820.             
  1821.             // istanzio il driver
  1822.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1823.             
  1824.             return driver.getPolicy(policyId, filtro, groupBy, ruoloPorta, nomePorta); 
  1825.         } catch (DriverControlStationNotFound e) {
  1826.             throw e;
  1827.         } catch (Exception e) {
  1828.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1829.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1830.         }finally{
  1831.             ControlStationCore.dbM.releaseConnection(con);
  1832.         }
  1833.     }
  1834.     
  1835.     public AttivazionePolicy getPolicyByAlias(String alias,
  1836.             RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationNotFound, DriverControlStationException{
  1837.         String nomeMetodo = "getGlobalPolicyByAlias";
  1838.         Connection con = null;
  1839.         DriverControlStationDB driver = null;
  1840.         try {
  1841.             // prendo una connessione
  1842.             con = ControlStationCore.dbM.getConnection();
  1843.             
  1844.             // istanzio il driver
  1845.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1846.             
  1847.             return driver.getPolicyByAlias(alias, ruoloPorta, nomePorta);
  1848.         } catch (DriverControlStationNotFound e) {
  1849.             throw e;
  1850.         } catch (Exception e) {
  1851.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1852.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1853.         }finally{
  1854.             ControlStationCore.dbM.releaseConnection(con);
  1855.         }
  1856.     }
  1857.     
  1858.     public List<AttivazionePolicy> getPolicyByServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverControlStationNotFound, DriverControlStationException{
  1859.         String nomeMetodo = "getPolicyByServizioApplicativo";
  1860.         Connection con = null;
  1861.         DriverControlStationDB driver = null;
  1862.         try {
  1863.             // prendo una connessione
  1864.             con = ControlStationCore.dbM.getConnection();
  1865.             
  1866.             // istanzio il driver
  1867.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1868.             
  1869.             return driver.getPolicyByServizioApplicativo(idServizioApplicativo);
  1870.         } catch (DriverControlStationNotFound e) {
  1871.             throw e;
  1872.         } catch (Exception e) {
  1873.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1874.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1875.         }finally{
  1876.             ControlStationCore.dbM.releaseConnection(con);
  1877.         }
  1878.     }
  1879.     
  1880.     
  1881.     public List<IDSoggetto> getSoggettiErogatori(String protocolloSelezionato,List<String> protocolliSupportati) throws DriverControlStationException{
  1882.         String nomeMetodo = "getSoggettiErogatori";
  1883.         Connection con = null;
  1884.         DriverControlStationDB driver = null;
  1885.         try {
  1886.             // prendo una connessione
  1887.             con = ControlStationCore.dbM.getConnection();
  1888.             
  1889.             // istanzio il driver
  1890.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1891.         
  1892.             return driver.getSoggettiErogatori(protocolloSelezionato,protocolliSupportati);
  1893.         } catch (Exception e) {
  1894.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1895.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1896.         }finally{
  1897.             ControlStationCore.dbM.releaseConnection(con);
  1898.         }
  1899.     }
  1900.     public List<IDServizio> getServizi(String protocolloSelezionato,List<String> protocolliSupportati, 
  1901.             String tipoErogatore, String nomeErogatore, String tag) throws DriverControlStationException{
  1902.         String nomeMetodo = "getServizi";
  1903.         Connection con = null;
  1904.         DriverControlStationDB driver = null;
  1905.         try {
  1906.             // prendo una connessione
  1907.             con = ControlStationCore.dbM.getConnection();
  1908.             
  1909.             // istanzio il driver
  1910.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1911.             
  1912.             return driver.getServizi(protocolloSelezionato,protocolliSupportati, tipoErogatore, nomeErogatore, tag);
  1913.         } catch (Exception e) {
  1914.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1915.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1916.         }finally{
  1917.             ControlStationCore.dbM.releaseConnection(con);
  1918.         }
  1919.     }
  1920.     public List<IDServizio> getServizi(String protocolloSelezionato,List<String> protocolliSupportati, 
  1921.             String tipoServizio, String nomeServizio, Integer versioneServizio, String tag) throws DriverControlStationException{
  1922.         String nomeMetodo = "getServizi";
  1923.         Connection con = null;
  1924.         DriverControlStationDB driver = null;
  1925.         try {
  1926.             // prendo una connessione
  1927.             con = ControlStationCore.dbM.getConnection();
  1928.             
  1929.             // istanzio il driver
  1930.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1931.             
  1932.             return driver.getServizi(protocolloSelezionato,protocolliSupportati, tipoServizio, nomeServizio, versioneServizio, tag);
  1933.         } catch (Exception e) {
  1934.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1935.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1936.         }finally{
  1937.             ControlStationCore.dbM.releaseConnection(con);
  1938.         }
  1939.     }
  1940.     public List<String> getAzioni(String protocolloSelezionato,List<String> protocolliSupportati, 
  1941.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverControlStationException{
  1942.         String nomeMetodo = "getAzioni";
  1943.         Connection con = null;
  1944.         DriverControlStationDB driver = null;
  1945.         try {
  1946.             // prendo una connessione
  1947.             con = ControlStationCore.dbM.getConnection();
  1948.             
  1949.             // istanzio il driver
  1950.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1951.         
  1952.             return driver.getAzioni(protocolloSelezionato,protocolliSupportati, 
  1953.                     tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio); 
  1954.         } catch (Exception e) {
  1955.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1956.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1957.         }finally{
  1958.             ControlStationCore.dbM.releaseConnection(con);
  1959.         }
  1960.     }
  1961.     public List<IDServizioApplicativo> getServiziApplicativiErogatori(String protocolloSelezionato,List<String> protocolliSupportati, 
  1962.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio,
  1963.             String azione) throws DriverControlStationException {
  1964.         String nomeMetodo = "getServiziApplicativiErogatori";
  1965.         Connection con = null;
  1966.         DriverControlStationDB driver = null;
  1967.         try {
  1968.             // prendo una connessione
  1969.             con = ControlStationCore.dbM.getConnection();
  1970.             
  1971.             // istanzio il driver
  1972.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1973.         
  1974.             return driver.getServiziApplicativiErogatori(protocolloSelezionato,protocolliSupportati, 
  1975.                     tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, 
  1976.                     azione);
  1977.         } catch (Exception e) {
  1978.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1979.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1980.         }finally{
  1981.             ControlStationCore.dbM.releaseConnection(con);
  1982.         }
  1983.     }
  1984.     public List<IDSoggetto> getSoggetti(String protocolloSelezionato,List<String> protocolliSupportati) throws DriverControlStationException{
  1985.         String nomeMetodo = "getSoggetti";
  1986.         Connection con = null;
  1987.         DriverControlStationDB driver = null;
  1988.         try {
  1989.             // prendo una connessione
  1990.             con = ControlStationCore.dbM.getConnection();
  1991.             
  1992.             // istanzio il driver
  1993.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  1994.         
  1995.             return driver.getSoggetti(protocolloSelezionato,protocolliSupportati);
  1996.         } catch (Exception e) {
  1997.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  1998.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  1999.         }finally{
  2000.             ControlStationCore.dbM.releaseConnection(con);
  2001.         }
  2002.     }
  2003.     public List<IDSoggetto> getSoggettiFruitori(String protocolloSelezionato,List<String> protocolliSupportati, 
  2004.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverControlStationException{
  2005.         String nomeMetodo = "getSoggettiFruitori";
  2006.         Connection con = null;
  2007.         DriverControlStationDB driver = null;
  2008.         try {
  2009.             // prendo una connessione
  2010.             con = ControlStationCore.dbM.getConnection();
  2011.             
  2012.             // istanzio il driver
  2013.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2014.         
  2015.             return driver.getSoggettiFruitori(protocolloSelezionato,protocolliSupportati, 
  2016.                     tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio);
  2017.         } catch (Exception e) {
  2018.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2019.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2020.         }finally{
  2021.             ControlStationCore.dbM.releaseConnection(con);
  2022.         }
  2023.     }
  2024.     public List<IDServizioApplicativo> getServiziApplicativiFruitore(String protocolloSelezionato,List<String> protocolliSupportati,
  2025.             String tipoFruitore, String nomeFruitore,   
  2026.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio,
  2027.             String azione) throws DriverControlStationException{
  2028.         String nomeMetodo = "getServiziApplicativiFruitore(protocollo,protocolli,fruitore,erogatore,servizio,azione)";
  2029.         Connection con = null;
  2030.         DriverControlStationDB driver = null;
  2031.         try {
  2032.             // prendo una connessione
  2033.             con = ControlStationCore.dbM.getConnection();
  2034.             
  2035.             // istanzio il driver
  2036.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2037.             
  2038.             return driver.getServiziApplicativiFruitore(protocolloSelezionato,protocolliSupportati, 
  2039.                     tipoFruitore, nomeFruitore, 
  2040.                     tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio,
  2041.                     azione);
  2042.         } catch (Exception e) {
  2043.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2044.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2045.         }finally{
  2046.             ControlStationCore.dbM.releaseConnection(con);
  2047.         }
  2048.     }
  2049.     public List<IDServizioApplicativo> getServiziApplicativiFruitore(String protocolloSelezionato,List<String> protocolliSupportati,
  2050.             String tipoFruitore, String nomeFruitore) throws DriverControlStationException{
  2051.         String nomeMetodo = "getServiziApplicativiFruitore";
  2052.         Connection con = null;
  2053.         DriverControlStationDB driver = null;
  2054.         try {
  2055.             // prendo una connessione
  2056.             con = ControlStationCore.dbM.getConnection();
  2057.             
  2058.             // istanzio il driver
  2059.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2060.             
  2061.             return driver.getServiziApplicativiFruitore(protocolloSelezionato,protocolliSupportati, 
  2062.                     tipoFruitore, nomeFruitore);
  2063.         } catch (Exception e) {
  2064.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2065.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2066.         }finally{
  2067.             ControlStationCore.dbM.releaseConnection(con);
  2068.         }
  2069.     }
  2070.     public List<IDServizioApplicativo> getServiziApplicativi(String protocolloSelezionato,List<String> protocolliSupportati,
  2071.             String tipoProprietario, String nomeProprietario) throws DriverControlStationException{
  2072.         String nomeMetodo = "getServiziApplicativiFruitore";
  2073.         Connection con = null;
  2074.         DriverControlStationDB driver = null;
  2075.         try {
  2076.             // prendo una connessione
  2077.             con = ControlStationCore.dbM.getConnection();
  2078.             
  2079.             // istanzio il driver
  2080.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2081.             
  2082.             return driver.getServiziApplicativi(protocolloSelezionato,protocolliSupportati, 
  2083.                     tipoProprietario, nomeProprietario);
  2084.         } catch (Exception e) {
  2085.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2086.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2087.         }finally{
  2088.             ControlStationCore.dbM.releaseConnection(con);
  2089.         }
  2090.     }
  2091.     
  2092.     public Map<String, Properties> readGestorePolicyTokenPropertiesConfiguration(long idGenericProperties) throws DriverConfigurazioneException {
  2093.         Connection con = null;
  2094.         String nomeMetodo = "readGestorePolicyTokenPropertiesConfiguration";
  2095.         try {
  2096.             // prendo una connessione
  2097.             con = ControlStationCore.dbM.getConnection();
  2098.             Map<String, String> readProperties = DBPropertiesUtils.readProperties(con, this.tipoDB, CostantiDB.CONFIG_GENERIC_PROPERTY, CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_NOME, 
  2099.                     CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_VALORE, CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_ENC_VALUE, CostantiDB.CONFIG_GENERIC_PROPERTY_COLUMN_ID_PROPS, idGenericProperties,
  2100.                     this.getDriverBYOKUtilities().getDriverBYOKManagerNode(false, true));
  2101.             return DBPropertiesUtils.toMultiMap(readProperties);
  2102.         } catch (Exception e) {
  2103.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2104.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2105.         } finally {
  2106.             ControlStationCore.dbM.releaseConnection(con);
  2107.         }   
  2108.     }
  2109.     public List<GenericProperties> gestorePolicyTokenList(Integer idLista, String tipologia, ISearch ricerca) throws DriverConfigurazioneException {
  2110.         List<String> tipologiaList = new ArrayList<>();
  2111.         tipologiaList.add(tipologia);
  2112.         return gestorePolicyTokenList(idLista, tipologiaList, ricerca);
  2113.     }
  2114.     public List<GenericProperties> gestorePolicyTokenList(Integer idLista, List<String> tipologia, ISearch ricerca) throws DriverConfigurazioneException {
  2115.         Connection con = null;
  2116.         String nomeMetodo = "gestorePolicyTokenList";
  2117.         DriverControlStationDB driver = null;

  2119.         try {
  2120.             // prendo una connessione
  2121.             con = ControlStationCore.dbM.getConnection();
  2122.             // istanzio il driver
  2123.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2124.             return driver.getDriverConfigurazioneDB().getGenericProperties(tipologia, idLista, ricerca,false);
  2125.         } catch (Exception e) {
  2126.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2127.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2128.         } finally {
  2129.             ControlStationCore.dbM.releaseConnection(con);
  2130.         }
  2131.     }
  2132.     public GenericProperties getGenericProperties(long idGenericProperties) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2133.         Connection con = null;
  2134.         String nomeMetodo = "getGenericProperties";
  2135.         DriverControlStationDB driver = null;

  2137.         try {
  2138.             // prendo una connessione
  2139.             con = ControlStationCore.dbM.getConnection();
  2140.             // istanzio il driver
  2141.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2142.             return driver.getDriverConfigurazioneDB().getGenericProperties(idGenericProperties);
  2143.         }catch (DriverConfigurazioneNotFound e) {
  2144.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2145.             throw e;
  2146.         }catch (Exception e) {
  2147.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2148.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2149.         } finally {
  2150.             ControlStationCore.dbM.releaseConnection(con);
  2151.         }
  2152.     }
  2153.     
  2154.     public GenericProperties getGenericProperties(String nome, String tipologia, boolean logNotFoundError) throws DriverConfigurazioneException,DriverConfigurazioneNotFound{
  2155.         Connection con = null;
  2156.         String nomeMetodo = "getGenericProperties";
  2157.         DriverControlStationDB driver = null;

  2159.         try {
  2160.             // prendo una connessione
  2161.             con = ControlStationCore.dbM.getConnection();
  2162.             // istanzio il driver
  2163.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2164.             return driver.getDriverConfigurazioneDB().getGenericProperties(tipologia,nome);
  2165.         } catch (DriverConfigurazioneNotFound e) {
  2166.             if(logNotFoundError) {
  2167.                 ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2168.             }
  2169.             else {
  2170.                 ControlStationCore.logDebug(getPrefixError(nomeMetodo,  e), e);
  2171.             }
  2172.             throw e;
  2173.         } catch (Exception e) {
  2174.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2175.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2176.         } finally {
  2177.             ControlStationCore.dbM.releaseConnection(con);
  2178.         }
  2179.     }
  2180.     public List<PortaApplicativa> listaPorteApplicativeUtilizzateDaPolicyGestioneToken(String nome) throws DriverConfigurazioneException{
  2181.         Connection con = null;
  2182.         String nomeMetodo = "listaPorteApplicativeUtilizzateDaPolicyGestioneToken";
  2183.         DriverControlStationDB driver = null;

  2185.         try {
  2186.             // prendo una connessione
  2187.             con = ControlStationCore.dbM.getConnection();
  2188.             // istanzio il driver
  2189.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2190.             return driver.getDriverConfigurazioneDB().getPorteApplicativeByPolicyGestioneToken(nome);
  2191.         } catch (Exception e) {
  2192.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2193.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2194.         } finally {
  2195.             ControlStationCore.dbM.releaseConnection(con);
  2196.         }
  2197.     }
  2198.     public List<PortaDelegata> listaPorteDelegateUtilizzateDaPolicyGestioneToken(String nome) throws DriverConfigurazioneException{
  2199.         Connection con = null;
  2200.         String nomeMetodo = "listaPorteDelegateUtilizzateDaPolicyGestioneToken";
  2201.         DriverControlStationDB driver = null;

  2203.         try {
  2204.             // prendo una connessione
  2205.             con = ControlStationCore.dbM.getConnection();
  2206.             // istanzio il driver
  2207.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2208.             return driver.getDriverConfigurazioneDB().getPorteDelegateByPolicyGestioneToken(nome);
  2209.         } catch (Exception e) {
  2210.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2211.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2212.         } finally {
  2213.             ControlStationCore.dbM.releaseConnection(con);
  2214.         }
  2215.     }
  2216.     public boolean isPolicyNegoziazioneTokenUsedInConnettore(String nome) throws DriverConfigurazioneException{
  2217.         Connection con = null;
  2218.         String nomeMetodo = "listaPorteDelegateUtilizzateDaPolicyGestioneToken";
  2219.         DriverControlStationDB driver = null;

  2221.         try {
  2222.             // prendo una connessione
  2223.             con = ControlStationCore.dbM.getConnection();
  2224.             // istanzio il driver
  2225.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2226.             return driver.getDriverConfigurazioneDB().isPolicyNegoziazioneTokenUsedInConnettore(nome);
  2227.         } catch (Exception e) {
  2228.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2229.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2230.         } finally {
  2231.             ControlStationCore.dbM.releaseConnection(con);
  2232.         }
  2233.     }
  2234.     public List<CanaleConfigurazione> canaleConfigurazioneList(ISearch ricerca) throws DriverConfigurazioneException {
  2235.         Connection con = null;
  2236.         String nomeMetodo = "canaleConfigurazioneList";
  2237.         DriverControlStationDB driver = null;

  2239.         try {
  2240.             // prendo una connessione
  2241.             con = ControlStationCore.dbM.getConnection();
  2242.             // istanzio il driver
  2243.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2244.             return driver.getDriverConfigurazioneDB().canaleConfigurazioneList(ricerca); 
  2245.         } catch (Exception e) {
  2246.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2247.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2248.         } finally {
  2249.             ControlStationCore.dbM.releaseConnection(con);
  2250.         }
  2251.     }
  2252.     public boolean existsCanale(String nome) throws DriverConfigurazioneException{
  2253.         Connection con = null;
  2254.         String nomeMetodo = "existsCanale";
  2255.         DriverControlStationDB driver = null;

  2257.         try {
  2258.             // prendo una connessione
  2259.             con = ControlStationCore.dbM.getConnection();
  2260.             // istanzio il driver
  2261.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2262.             return driver.getDriverConfigurazioneDB().existsCanale(nome);
  2263.         } catch (Exception e) {
  2264.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2265.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2266.         } finally {
  2267.             ControlStationCore.dbM.releaseConnection(con);
  2268.         }
  2269.     }
  2270.     
  2271.     public List<CanaleConfigurazioneNodo> canaleNodoConfigurazioneList(ISearch ricerca) throws DriverConfigurazioneException{
  2272.         Connection con = null;
  2273.         String nomeMetodo = "canaleNodoConfigurazioneList";
  2274.         DriverControlStationDB driver = null;

  2276.         try {
  2277.             // prendo una connessione
  2278.             con = ControlStationCore.dbM.getConnection();
  2279.             // istanzio il driver
  2280.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2281.             return driver.getDriverConfigurazioneDB().canaleNodoConfigurazioneList(ricerca); 
  2282.         } catch (Exception e) {
  2283.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2284.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2285.         } finally {
  2286.             ControlStationCore.dbM.releaseConnection(con);
  2287.         }
  2288.     }
  2289.     
  2290.     public boolean existsCanaleNodo(String nome) throws DriverConfigurazioneException{
  2291.         Connection con = null;
  2292.         String nomeMetodo = "existsCanaleNodo";
  2293.         DriverControlStationDB driver = null;

  2295.         try {
  2296.             // prendo una connessione
  2297.             con = ControlStationCore.dbM.getConnection();
  2298.             // istanzio il driver
  2299.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2300.             return driver.getDriverConfigurazioneDB().existsCanaleNodo(nome); 
  2301.         } catch (Exception e) {
  2302.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2303.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2304.         } finally {
  2305.             ControlStationCore.dbM.releaseConnection(con);
  2306.         }
  2307.     }
  2308.     
  2309.     public boolean isCanaleInUso(CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  2310.         Connection con = null; 
  2311.         String nomeMetodo = "isCanaleInUso";
  2312.         
  2313.         try {
  2314.             // prendo una connessione
  2315.             con = ControlStationCore.dbM.getConnection();
  2316.     
  2317.             return DBOggettiInUsoUtils.isCanaleInUso(con, this.tipoDB, canale, whereIsInUso, normalizeObjectIds);
  2318.     
  2319.         } catch (Exception e) {
  2320.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2321.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2322.         } finally {
  2323.             ControlStationCore.dbM.releaseConnection(con);
  2324.         }
  2325.     }
  2326.     
  2327.     public boolean isCanaleInUsoRegistro(CanaleConfigurazione canale, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  2328.         Connection con = null; 
  2329.         String nomeMetodo = "isCanaleInUsoRegistro";
  2330.         
  2331.         try {
  2332.             // prendo una connessione
  2333.             con = ControlStationCore.dbM.getConnection();
  2334.     
  2335.             return DBOggettiInUsoUtils.isCanaleInUsoRegistro(con, this.tipoDB, canale, whereIsInUso, normalizeObjectIds);
  2336.     
  2337.         } catch (Exception e) {
  2338.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2339.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2340.         } finally {
  2341.             ControlStationCore.dbM.releaseConnection(con);
  2342.         }
  2343.     }
  2344.     
  2345.     public String getDettagliCanaleInUso(CanaleConfigurazione canale) throws DriverConfigurazioneException {
  2346.         EnumMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new EnumMap<>(ErrorsHandlerCostant.class);
  2347.         boolean normalizeObjectIds = true;
  2348.         boolean canaleInUso  = this.isCanaleInUso(canale, whereIsInUso, normalizeObjectIds);
  2349.         
  2350.         StringBuilder inUsoMessage = new StringBuilder();
  2351.         if(canaleInUso) {
  2352.             String s = DBOggettiInUsoUtils.toString(canale, whereIsInUso, false, "\n");
  2353.             if(s!=null && s.startsWith("\n") && s.length()>1) {
  2354.                 s = s.substring(1);
  2355.             }
  2356.             inUsoMessage.append(s);
  2357.             inUsoMessage.append("\n");
  2358.         } else {
  2359.             inUsoMessage.append(ConfigurazioneCostanti.LABEL_CANALE_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  2360.         }
  2361.         
  2362.         return inUsoMessage.toString();
  2363.     }
  2364.     
  2365.     public boolean isGenericPropertiesInUso(IDGenericProperties idGP, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  2366.         String nomeMetodo = "isGenericPropertiesInUso";
  2367.         Connection con = null; 
  2368.         
  2369.         try {
  2370.             // prendo una connessione
  2371.             con = ControlStationCore.dbM.getConnection();
  2372.     
  2373.             return DBOggettiInUsoUtils.isGenericPropertiesInUso(con, this.tipoDB, idGP, whereIsInUso, normalizeObjectIds);
  2374.     
  2375.         } catch (Exception e) {
  2376.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2377.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2378.         } finally {
  2379.             ControlStationCore.dbM.releaseConnection(con);
  2380.         }
  2381.     }
  2382.     
  2383.     public String getDettagliTokenPolicyInUso(IDGenericProperties idGP) throws DriverConfigurazioneException {
  2384.         EnumMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new EnumMap<>(ErrorsHandlerCostant.class);
  2385.         boolean normalizeObjectIds = true;
  2386.         boolean tokenPolicyInUso  = this.isGenericPropertiesInUso(idGP, whereIsInUso, normalizeObjectIds);
  2387.         
  2388.         StringBuilder inUsoMessage = new StringBuilder();
  2389.         if(tokenPolicyInUso) {
  2390.             String s = DBOggettiInUsoUtils.toString(idGP, whereIsInUso, false, "\n");
  2391.             if(s!=null && s.startsWith("\n") && s.length()>1) {
  2392.                 s = s.substring(1);
  2393.             }
  2394.             inUsoMessage.append(s);
  2395.             inUsoMessage.append("\n");
  2396.         } else {
  2397.             if(idGP!=null && CostantiConfigurazione.GENERIC_PROPERTIES_ATTRIBUTE_AUTHORITY.equals(idGP.getTipologia())) {
  2398.                 inUsoMessage.append(ConfigurazioneCostanti.LABEL_ATTRIBUTE_AUTHORITY_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  2399.             }
  2400.             else {
  2401.                 inUsoMessage.append(ConfigurazioneCostanti.LABEL_TOKEN_POLICY_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  2402.             }
  2403.         }
  2404.         
  2405.         return inUsoMessage.toString();
  2406.     }
  2407.     
  2408.     public boolean isRateLimitingPolicyInUso(IdPolicy idRP, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  2409.         String nomeMetodo = "isRateLimitingPolicyInUso";
  2410.         Connection con = null; 
  2411.         
  2412.         try {
  2413.             // prendo una connessione
  2414.             con = ControlStationCore.dbM.getConnection();
  2415.     
  2416.             return DBOggettiInUsoUtils.isRateLimitingPolicyInUso(con, this.tipoDB, idRP, whereIsInUso, normalizeObjectIds);
  2417.     
  2418.         } catch (Exception e) {
  2419.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2420.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2421.         } finally {
  2422.             ControlStationCore.dbM.releaseConnection(con);
  2423.         }
  2424.     }
  2425.     
  2426.     public String getDettagliRateLimitingPolicyInUso(IdPolicy idRP) throws DriverConfigurazioneException {
  2427.         EnumMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new EnumMap<>(ErrorsHandlerCostant.class);
  2428.         boolean normalizeObjectIds = true;
  2429.         boolean rateLimitingPolicyInUso  = this.isRateLimitingPolicyInUso(idRP, whereIsInUso, normalizeObjectIds);
  2430.         
  2431.         StringBuilder inUsoMessage = new StringBuilder();
  2432.         if(rateLimitingPolicyInUso) {
  2433.             String s = DBOggettiInUsoUtils.toString(idRP, whereIsInUso, false, "\n");
  2434.             if(s!=null && s.startsWith("\n") && s.length()>1) {
  2435.                 s = s.substring(1);
  2436.             }
  2437.             inUsoMessage.append(s);
  2438.             inUsoMessage.append("\n");
  2439.         } else {
  2440.             inUsoMessage.append(ConfigurazioneCostanti.LABEL_RATE_LIMITING_POLICY_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  2441.         }
  2442.         
  2443.         return inUsoMessage.toString();
  2444.     }
  2445.     
  2446.     public boolean isPluginClasseInUso(IdPlugin idPlugin, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverConfigurazioneException {
  2447.         String nomeMetodo = "isPluginClasseInUso";
  2448.         Connection con = null; 
  2449.         
  2450.         try {
  2451.             // prendo una connessione
  2452.             con = ControlStationCore.dbM.getConnection();
  2453.     
  2454.             return DBOggettiInUsoUtils.isPluginInUso(con, this.tipoDB, idPlugin.getClassName(), idPlugin.getLabel(), idPlugin.getTipoPlugin(), idPlugin.getTipo(), 
  2455.                     whereIsInUso, normalizeObjectIds);

  2457.         } catch (Exception e) {
  2458.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2459.             throw new DriverConfigurazioneException(getPrefixError(nomeMetodo,  e),e);
  2460.         } finally {
  2461.             ControlStationCore.dbM.releaseConnection(con);
  2462.         }
  2463.     }
  2464.     
  2465.     public String getDettagliPluginClasseInUso(IdPlugin idPlugin) throws DriverConfigurazioneException {
  2466.         EnumMap<ErrorsHandlerCostant, List<String>> whereIsInUso = new EnumMap<>(ErrorsHandlerCostant.class);
  2467.         boolean normalizeObjectIds = true;
  2468.         boolean pluginClasseInUso  = this.isPluginClasseInUso(idPlugin, whereIsInUso, normalizeObjectIds);
  2469.         
  2470.         StringBuilder inUsoMessage = new StringBuilder();
  2471.         if(pluginClasseInUso) {
  2472.             String s = DBOggettiInUsoUtils.toString(idPlugin.getClassName(), idPlugin.getLabel(), idPlugin.getTipoPlugin(), idPlugin.getTipo(), whereIsInUso, false, "\n");
  2473.             if(s!=null && s.startsWith("\n") && s.length()>1) {
  2474.                 s = s.substring(1);
  2475.             }
  2476.             inUsoMessage.append(s);
  2477.             inUsoMessage.append("\n");
  2478.         } else {
  2479.             inUsoMessage.append(ConfigurazioneCostanti.LABEL_PLUGIN_CLASSE_IN_USO_BODY_HEADER_NESSUN_RISULTATO);
  2480.         }
  2481.         
  2482.         return inUsoMessage.toString();
  2483.     }

  2485.     public List<ConfigurazioneAllarmeBean> allarmiList(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta) throws DriverControlStationException{ 
  2486.         String nomeMetodo = "allarmiList";
  2487.         Connection con = null;
  2488.         DriverControlStationDB driver = null;
  2489.         try {
  2490.             // prendo una connessione
  2491.             con = ControlStationCore.dbM.getConnection();
  2492.             
  2493.             // istanzio il driver
  2494.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2495.             
  2496.             return driver.allarmiList(ricerca, ruoloPorta, nomePorta);
  2497.         } catch (Exception e) {
  2498.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2499.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2500.         }finally{
  2501.             ControlStationCore.dbM.releaseConnection(con);
  2502.         }
  2503.     }
  2504.     
  2505.     public List<Allarme> allarmiSenzaPluginList(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta) throws DriverControlStationException{ 
  2506.         String nomeMetodo = "allarmiSenzaPluginList";
  2507.         Connection con = null;
  2508.         DriverControlStationDB driver = null;
  2509.         try {
  2510.             // prendo una connessione
  2511.             con = ControlStationCore.dbM.getConnection();
  2512.             
  2513.             // istanzio il driver
  2514.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2515.             
  2516.             return driver.allarmiSenzaPluginList(ricerca, ruoloPorta, nomePorta);
  2517.         } catch (Exception e) {
  2518.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2519.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2520.         }finally{
  2521.             ControlStationCore.dbM.releaseConnection(con);
  2522.         }
  2523.     }
  2524.     
  2525.     public boolean existsAllarmi(TipoAllarme tipoAllarme) throws DriverControlStationException{ 
  2526.         String nomeMetodo = "existsAllarmi";
  2527.         Connection con = null;
  2528.         DriverControlStationDB driver = null;
  2529.         try {
  2530.             // prendo una connessione
  2531.             con = ControlStationCore.dbM.getConnection();
  2532.             
  2533.             // istanzio il driver
  2534.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2535.             
  2536.             return driver.existsAllarmi(tipoAllarme);
  2537.         } catch (Exception e) {
  2538.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2539.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2540.         }finally{
  2541.             ControlStationCore.dbM.releaseConnection(con);
  2542.         }
  2543.     }
  2544.     
  2545.     public long countAllarmi(TipoAllarme tipoAllarme) throws DriverControlStationException{ 
  2546.         String nomeMetodo = "countAllarmi";
  2547.         Connection con = null;
  2548.         DriverControlStationDB driver = null;
  2549.         try {
  2550.             // prendo una connessione
  2551.             con = ControlStationCore.dbM.getConnection();
  2552.             
  2553.             // istanzio il driver
  2554.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2555.             
  2556.             return driver.countAllarmi(tipoAllarme);
  2557.         } catch (Exception e) {
  2558.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2559.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2560.         }finally{
  2561.             ControlStationCore.dbM.releaseConnection(con);
  2562.         }
  2563.     }
  2564.     
  2565.     public boolean existsAllarme(String nome) throws DriverControlStationException{
  2566.         Connection con = null;
  2567.         String nomeMetodo = "existsAllarme";
  2568.         DriverControlStationDB driver = null;

  2570.         try {
  2571.             // prendo una connessione
  2572.             con = ControlStationCore.dbM.getConnection();
  2573.             // istanzio il driver
  2574.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2575.             return driver.existsAllarme(nome); 
  2576.         } catch (Exception e) {
  2577.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2578.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2579.         } finally {
  2580.             ControlStationCore.dbM.releaseConnection(con);
  2581.         }
  2582.     }
  2583.     
  2584.     public Allarme getAllarmeSenzaPlugin(Long id) throws DriverControlStationException{ 
  2585.         String nomeMetodo = "getAllarmeSenzaPlugin";
  2586.         Connection con = null;
  2587.         DriverControlStationDB driver = null;
  2588.         try {
  2589.             // prendo una connessione
  2590.             con = ControlStationCore.dbM.getConnection();
  2591.             
  2592.             // istanzio il driver
  2593.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2594.             
  2595.             return driver.getAllarmeSenzaPlugin(id);
  2596.         } catch (Exception e) {
  2597.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2598.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2599.         }finally{
  2600.             ControlStationCore.dbM.releaseConnection(con);
  2601.         }
  2602.     }
  2603.     
  2604.     public Allarme getAllarmeSenzaPlugin(String nome) throws DriverControlStationException{ 
  2605.         String nomeMetodo = "getAllarmeSenzaPluginByNome";
  2606.         Connection con = null;
  2607.         DriverControlStationDB driver = null;
  2608.         try {
  2609.             // prendo una connessione
  2610.             con = ControlStationCore.dbM.getConnection();
  2611.             
  2612.             // istanzio il driver
  2613.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2614.             
  2615.             return driver.getAllarmeSenzaPlugin(nome);
  2616.         } catch (Exception e) {
  2617.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2618.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2619.         }finally{
  2620.             ControlStationCore.dbM.releaseConnection(con);
  2621.         }
  2622.     }
  2623.     
  2624.     public ConfigurazioneAllarmeBean getAllarme(Long id) throws DriverControlStationException{ 
  2625.         String nomeMetodo = "getAllarme";
  2626.         Connection con = null;
  2627.         DriverControlStationDB driver = null;
  2628.         try {
  2629.             // prendo una connessione
  2630.             con = ControlStationCore.dbM.getConnection();
  2631.             
  2632.             // istanzio il driver
  2633.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2634.             
  2635.             return driver.getAllarme(id);
  2636.         } catch (Exception e) {
  2637.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2638.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2639.         }finally{
  2640.             ControlStationCore.dbM.releaseConnection(con);
  2641.         }
  2642.     }
  2643.     
  2644.     public ConfigurazioneAllarmeBean getAllarme(String nome) throws DriverControlStationException{ 
  2645.         String nomeMetodo = "getAllarmeByNome";
  2646.         Connection con = null;
  2647.         DriverControlStationDB driver = null;
  2648.         try {
  2649.             // prendo una connessione
  2650.             con = ControlStationCore.dbM.getConnection();
  2651.             
  2652.             // istanzio il driver
  2653.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2654.             
  2655.             return driver.getAllarme(nome);
  2656.         } catch (Exception e) {
  2657.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2658.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2659.         }finally{
  2660.             ControlStationCore.dbM.releaseConnection(con);
  2661.         }
  2662.     }
  2663.     
  2664.     public ConfigurazioneAllarmeBean getAllarme(Allarme allarme) throws DriverControlStationException{ 
  2665.         String nomeMetodo = "convertAllarme";
  2666.         Connection con = null;
  2667.         DriverControlStationDB driver = null;
  2668.         try {
  2669.             // prendo una connessione
  2670.             con = ControlStationCore.dbM.getConnection();
  2671.             
  2672.             // istanzio il driver
  2673.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2674.             
  2675.             return driver.getAllarme(allarme);
  2676.         } catch (Exception e) {
  2677.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2678.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2679.         }finally{
  2680.             ControlStationCore.dbM.releaseConnection(con);
  2681.         }
  2682.     }
  2683.     
  2684.     public boolean isUsableFilter(ConfigurazioneAllarmeBean configurazioneAllarme, Context context) throws DriverControlStationException{
  2685.         return this.isUsableEngine(configurazioneAllarme, context, true);
  2686.     }
  2687.     
  2688.     public boolean isUsableGroupBy(ConfigurazioneAllarmeBean configurazioneAllarme, Context context) throws DriverControlStationException{
  2689.         return this.isUsableEngine(configurazioneAllarme, context, false);
  2690.     }
  2691.     
  2692.     private boolean isUsableEngine(ConfigurazioneAllarmeBean configurazioneAllarme, Context context, boolean filter) throws DriverControlStationException{
  2693.         String nomeMetodo = "isUsableEngine";
  2694.         Connection con = null;
  2695.         DriverControlStationDB driver = null;
  2696.         try {
  2697.             // prendo una connessione
  2698.             con = ControlStationCore.dbM.getConnection();
  2699.             
  2700.             // istanzio il driver
  2701.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2702.             
  2703.             Plugin plugin = driver.getPlugin(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), true);
  2704.             
  2705.             IDynamicLoader bl = DynamicFactory.getInstance().newDynamicLoader(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), plugin.getClassName(), ControlStationCore.log);
  2706.             IAlarmProcessing alarmProcessing = (IAlarmProcessing) bl.newInstance();
  2707.             return filter ? alarmProcessing.isUsableFilter(context) : alarmProcessing.isUsableGroupBy(context);
  2708.         } catch (Exception e) {
  2709.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2710.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2711.         }finally{
  2712.             ControlStationCore.dbM.releaseConnection(con);
  2713.         }
  2714.     }
  2715.     
  2716.     public FiltersConfiguration getFiltersConfiguration(ConfigurazioneAllarmeBean configurazioneAllarme, Context context) throws DriverControlStationException{
  2717.         return (FiltersConfiguration) this.getFilterGroupByConfigEngine(configurazioneAllarme, context, true);
  2718.     }
  2719.     
  2720.     public GroupByConfiguration getGroupByConfiguration(ConfigurazioneAllarmeBean configurazioneAllarme, Context context) throws DriverControlStationException{
  2721.         return (GroupByConfiguration) this.getFilterGroupByConfigEngine(configurazioneAllarme, context, false);
  2722.     }
  2723.     
  2724.     public Object getFilterGroupByConfigEngine(ConfigurazioneAllarmeBean configurazioneAllarme, Context context, boolean filter) throws DriverControlStationException{
  2725.         String nomeMetodo = "getFilterGroupByConfigEngine";
  2726.         Connection con = null;
  2727.         DriverControlStationDB driver = null;
  2728.         try {
  2729.             // prendo una connessione
  2730.             con = ControlStationCore.dbM.getConnection();
  2731.             
  2732.             // istanzio il driver
  2733.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2734.             
  2735.             Plugin plugin = driver.getPlugin(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), true);
  2736.             
  2737.             IDynamicLoader bl = DynamicFactory.getInstance().newDynamicLoader(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), plugin.getClassName(), ControlStationCore.log);
  2738.             IAlarmProcessing alarmProcessing = (IAlarmProcessing) bl.newInstance();
  2739.             
  2740.             if(filter) {
  2741.                 if(alarmProcessing.isUsableFilter(context)) {
  2742.                     return alarmProcessing.getFiltersConfiguration(context);
  2743.                 }
  2744.             }
  2745.             else {
  2746.                 if(alarmProcessing.isUsableGroupBy(context)) {
  2747.                     return alarmProcessing.getGroupByConfiguration(context);
  2748.                 }
  2749.             }
  2750.             return null;
  2751.         } catch (Exception e) {
  2752.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2753.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2754.         }finally{
  2755.             ControlStationCore.dbM.releaseConnection(con);
  2756.         }
  2757.     }
  2758.     
  2759.     public String getParameterSectionTitle(ConfigurazioneAllarmeBean configurazioneAllarme, boolean groupByAllarme) throws DriverControlStationException{
  2760.         String nomeMetodo = "getParameterSectionTitle";
  2761.         Connection con = null;
  2762.         DriverControlStationDB driver = null;
  2763.         try {
  2764.             // prendo una connessione
  2765.             con = ControlStationCore.dbM.getConnection();
  2766.             
  2767.             // istanzio il driver
  2768.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2769.             
  2770.             Plugin plugin = driver.getPlugin(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), true);
  2771.             
  2772.             IDynamicLoader bl = DynamicFactory.getInstance().newDynamicLoader(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), plugin.getClassName(), ControlStationCore.log);
  2773.             IAlarmProcessing alarmProcessing = (IAlarmProcessing) bl.newInstance();
  2774.             String s = alarmProcessing.getParameterSectionTitle();
  2775.             if(s==null || StringUtils.isEmpty(s)) {
  2776.                 if(groupByAllarme) {
  2777.                     s = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_VALORI_DI_SOGLIA;
  2778.                 }
  2779.                 else {
  2780.                     s = ConfigurazioneCostanti.LABEL_CONFIGURAZIONE_ALLARMI_PARAMETRI;
  2781.                 }
  2782.             }
  2783.             return s;
  2784.         } catch (Exception e) {
  2785.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2786.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2787.         }finally{
  2788.             ControlStationCore.dbM.releaseConnection(con);
  2789.         }
  2790.     }
  2791.     
  2792.     public List<Parameter<?>> instanceParameters(ConfigurazioneAllarmeBean configurazioneAllarme, Context context) throws Exception{
  2793.         String nomeMetodo = "instanceParameters";
  2794.         Connection con = null;
  2795.         DriverControlStationDB driver = null;
  2796.         try {
  2797.             // prendo una connessione
  2798.             con = ControlStationCore.dbM.getConnection();
  2799.             
  2800.             // istanzio il driver
  2801.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2802.             
  2803.             Plugin plugin = driver.getPlugin(TipoPlugin.ALLARME, configurazioneAllarme.getPlugin().getTipo(), true);
  2804.             
  2805.             List<Parameter<?>> res = null;
  2806.             
  2807.             IDynamicLoader bl = DynamicFactory.getInstance().newDynamicLoader(TipoPlugin.ALLARME, plugin.getTipo(), plugin.getClassName(), ControlStationCore.log);
  2808.             List<Parameter<?>> sdkParameters = bl.getParameters(context);
  2809.             
  2810.             if(sdkParameters!=null && !sdkParameters.isEmpty()){
  2811.                 
  2812.                 res = new ArrayList<>();
  2813.                 
  2814.                 for (Parameter<?> sdkParameter : sdkParameters) {
  2815.                     Parameter<?> par = DynamicComponentUtils.createDynamicComponentParameter(sdkParameter, bl);
  2816.                     
  2817.                     res.add(par);
  2818.                 }
  2819.             }
  2820.             
  2821.             if(res!=null && !res.isEmpty()) {
  2822.                 ((AlarmContext)context).setParameters(res);
  2823.                 for (Parameter<?> par : res) {
  2824.                     ((BaseComponent<?>)par).setContext(context);        
  2825.                 }
  2826.             }

  2828.             return res;
  2829.         } catch (Exception e) {
  2830.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2831.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2832.         }finally{
  2833.             ControlStationCore.dbM.releaseConnection(con);
  2834.         }
  2835.     }
  2836.     
  2837.     public List<Parameter<?>> getParameters(ConfigurazioneAllarmeBean configurazioneAllarme, Context context) throws Exception{
  2838.         List<Parameter<?>> parameters = this.instanceParameters(configurazioneAllarme, context);
  2839.         if(parameters!=null && !parameters.isEmpty()){
  2840.             for (AllarmeParametro parDB : configurazioneAllarme.getAllarmeParametroList()) {
  2841.                 for (Parameter<?> par : parameters) {
  2842.                     if(parDB.getIdParametro().equals(par.getId())){
  2843.                         
  2844.                         String value = parDB.getValore();
  2845.                         
  2846.                         if(ParameterType.CHECK_BOX.equals(par.getType())){
  2847.                             if(Costanti.CHECK_BOX_ENABLED.equals(value) || Costanti.CHECK_BOX_ENABLED_ABILITATO.equals(value) || Costanti.CHECK_BOX_ENABLED_TRUE.equals(value)) {
  2848.                                 value = Costanti.CHECK_BOX_ENABLED_TRUE;
  2849.                             }
  2850.                             else {
  2851.                                 value = Costanti.CHECK_BOX_DISABLED_FALSE;
  2852.                             }
  2853.                         }
  2854.                         par.setValueAsString(value);
  2855.                         
  2856.                         par.setValueAsString(value);
  2857.                         break;
  2858.                     }
  2859.                 }
  2860.             }
  2861.         }
  2862.         
  2863.         return parameters;
  2864.     }
  2865.     public List<ConfigurazioneAllarmeHistoryBean> allarmiHistoryList(ConsoleSearch ricerca, Long idAllarme) throws DriverControlStationException {
  2866.         String nomeMetodo = "allarmiHistoryList";
  2867.         Connection con = null;
  2868.         DriverControlStationDB driver = null;
  2869.         try {
  2870.             // prendo una connessione
  2871.             con = ControlStationCore.dbM.getConnection();
  2872.             
  2873.             // istanzio il driver
  2874.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2875.             
  2876.             return driver.allarmiHistoryList(ricerca, idAllarme); 
  2877.         } catch (Exception e) {
  2878.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2879.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2880.         }finally{
  2881.             ControlStationCore.dbM.releaseConnection(con);
  2882.         }
  2883.     }
  2884.     public String getNextAlarmInstanceSerialId(String tipoPlugin) throws DriverControlStationException{
  2885.         String nomeMetodo = "getNextAlarmInstanceSerialId";
  2886.         Connection con = null;
  2887.         DriverControlStationDB driver = null;
  2888.         try {
  2889.             // prendo una connessione
  2890.             con = ControlStationCore.dbM.getConnection();
  2891.             
  2892.             // istanzio il driver
  2893.             driver = new DriverControlStationDB(con, null, this.tipoDB);
  2894.             
  2895.             return driver.getNextAlarmInstanceSerialId(tipoPlugin);
  2896.         } catch (Exception e) {
  2897.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2898.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2899.         }finally{
  2900.             ControlStationCore.dbM.releaseConnection(con);
  2901.         }
  2902.     }
  2903.     
  2904.     public List<ConfigurazioneAllarmeBean> allarmiListByFilter(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta,
  2905.             IDSoggetto filtroSoggettoFruitore, IDServizioApplicativo filtroApplicativoFruitore,String filtroRuoloFruitore,
  2906.             IDSoggetto filtroSoggettoErogatore, String filtroRuoloErogatore,
  2907.             IDServizio filtroServizioAzione, String filtroRuolo)  throws DriverControlStationException{
  2908.         String nomeMetodo = "allarmiListByFilter";
  2909.         Connection con = null;
  2910.         DriverControlStationDB driver = null;
  2911.         try {
  2912.             // prendo una connessione
  2913.             con = ControlStationCore.dbM.getConnection();
  2914.             
  2915.             // istanzio il driver
  2916.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  2917.             
  2918.             return driver.configurazioneAllarmiListByFilter(ricerca, ruoloPorta, nomePorta,
  2919.                     filtroSoggettoFruitore, filtroApplicativoFruitore, filtroRuoloFruitore,
  2920.                     filtroSoggettoErogatore, filtroRuoloErogatore,
  2921.                     filtroServizioAzione, filtroRuolo);
  2922.         } catch (Exception e) {
  2923.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2924.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2925.         }finally{
  2926.             ControlStationCore.dbM.releaseConnection(con);
  2927.         }
  2928.     }
  2929.     
  2930.     public List<Allarme> allarmiForPolicyRateLimiting(String activeIdPolicy, RuoloPorta ruoloPorta, String nomePorta)  throws DriverControlStationException{
  2931.         String nomeMetodo = "allarmiForPolicyRateLimiting";
  2932.         Connection con = null;
  2933.         DriverControlStationDB driver = null;
  2934.         try {
  2935.             // prendo una connessione
  2936.             con = ControlStationCore.dbM.getConnection();
  2937.             
  2938.             // istanzio il driver
  2939.             driver = new DriverControlStationDB(con, null, this.tipoDB);    
  2940.             
  2941.             return driver.allarmiForPolicyRateLimiting(activeIdPolicy, ruoloPorta, nomePorta);
  2942.         } catch (Exception e) {
  2943.             ControlStationCore.logError(getPrefixError(nomeMetodo,  e), e);
  2944.             throw new DriverControlStationException(getPrefixError(nomeMetodo,  e),e);
  2945.         }finally{
  2946.             ControlStationCore.dbM.releaseConnection(con);
  2947.         }
  2948.     }
  2949. }
Created with JaCoCo 0.8.8.202204050719