DriverControlStationDB.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.  */


  22. package org.openspcoop2.web.ctrlstat.driver;

  24. import java.sql.Connection;
  25. import java.sql.Date;
  26. import java.sql.PreparedStatement;
  27. import java.sql.ResultSet;
  28. import java.sql.SQLException;
  29. import java.util.ArrayList;
  30. import java.util.List;
  31. import java.util.Map;
  32. import java.util.Properties;

  34. import javax.sql.DataSource;

  36. import org.openspcoop2.core.allarmi.Allarme;
  37. import org.openspcoop2.core.allarmi.AllarmeHistory;
  38. import org.openspcoop2.core.allarmi.constants.RuoloPorta;
  39. import org.openspcoop2.core.allarmi.constants.TipoAllarme;
  40. import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
  41. import org.openspcoop2.core.commons.DBUtils;
  42. import org.openspcoop2.core.commons.ErrorsHandlerCostant;
  43. import org.openspcoop2.core.commons.ISearch;
  44. import org.openspcoop2.core.commons.Liste;
  45. import org.openspcoop2.core.commons.search.utils.RegistroCore;
  46. import org.openspcoop2.core.config.Proprieta;
  47. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  48. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  49. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  50. import org.openspcoop2.core.constants.CostantiDB;
  51. import org.openspcoop2.core.constants.TipoPdD;
  52. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  53. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  54. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyRaggruppamento;
  55. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  56. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  57. import org.openspcoop2.core.controllo_traffico.beans.InfoPolicy;
  58. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  59. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  60. import org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager;
  61. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  62. import org.openspcoop2.core.id.IDAccordo;
  63. import org.openspcoop2.core.id.IDFruizione;
  64. import org.openspcoop2.core.id.IDGruppo;
  65. import org.openspcoop2.core.id.IDPortType;
  66. import org.openspcoop2.core.id.IDPortTypeAzione;
  67. import org.openspcoop2.core.id.IDPortaApplicativa;
  68. import org.openspcoop2.core.id.IDPortaDelegata;
  69. import org.openspcoop2.core.id.IDResource;
  70. import org.openspcoop2.core.id.IDRuolo;
  71. import org.openspcoop2.core.id.IDScope;
  72. import org.openspcoop2.core.id.IDServizio;
  73. import org.openspcoop2.core.id.IDServizioApplicativo;
  74. import org.openspcoop2.core.id.IDSoggetto;
  75. import org.openspcoop2.core.mapping.DBMappingUtils;
  76. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  77. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  78. import org.openspcoop2.core.plugins.Plugin;
  79. import org.openspcoop2.core.plugins.constants.TipoPlugin;
  80. import org.openspcoop2.core.plugins.utils.PluginsDriverUtils;
  81. import org.openspcoop2.core.plugins.utils.handlers.ConfigurazioneHandlerBean;
  82. import org.openspcoop2.core.plugins.utils.handlers.HandlersDriverUtils;
  83. import org.openspcoop2.core.registry.AccordoCooperazione;
  84. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  85. import org.openspcoop2.core.registry.Soggetto;
  86. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  87. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  88. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  89. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  90. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB_LIB;
  91. import org.openspcoop2.generic_project.exception.NotFoundException;
  92. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  93. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeBean;
  94. import org.openspcoop2.monitor.engine.alarm.wrapper.ConfigurazioneAllarmeHistoryBean;
  95. import org.openspcoop2.protocol.engine.archive.UtilitiesMappingFruizioneErogazione;
  96. import org.openspcoop2.protocol.engine.utils.DBOggettiInUsoUtils;
  97. import org.openspcoop2.utils.BooleanNullable;
  98. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  99. import org.openspcoop2.utils.sql.ISQLQueryObject;
  100. import org.openspcoop2.utils.sql.SQLObjectFactory;
  101. import org.openspcoop2.web.ctrlstat.config.ConsoleProperties;
  102. import org.openspcoop2.web.ctrlstat.core.ConsoleSearch;
  103. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  104. import org.openspcoop2.web.ctrlstat.core.ControlStationLogger;
  105. import org.openspcoop2.web.ctrlstat.dao.PdDControlStation;
  106. import org.openspcoop2.web.ctrlstat.dao.SoggettoCtrlStat;
  107. import org.openspcoop2.web.lib.audit.DriverAudit;
  108. import org.openspcoop2.web.lib.audit.DriverAuditDBAppender;
  109. import org.openspcoop2.web.lib.users.DriverUsersDB;
  110. import org.slf4j.Logger;

  112. /**
  113.  * DriverControlStationDB
  114.  * 
  115.  * @author Andrea Poli (apoli@link.it)
  116.  * @author Stefano Corallo (corallo@link.it)
  117.  * @author Sandra Giangrandi (sandra@link.it)
  118.  * @author $Author$
  119.  * @version $Rev$, $Date$
  120.  * 
  121.  */
  122. public class DriverControlStationDB  {

  124.     private static Logger checkLogger = null;
  125.     private static boolean checkIsClosed = true;
  126.     private static boolean checkAutocommit = true;
  127.     public static boolean isCheckIsClosed() {
  128.         return checkIsClosed;
  129.     }
  130.     public static void setCheckIsClosed(boolean checkIsClosed) {
  131.         DriverControlStationDB.checkIsClosed = checkIsClosed;
  132.     }
  133.     public static boolean isCheckAutocommit() {
  134.         return checkAutocommit;
  135.     }
  136.     public static void setCheckAutocommit(boolean checkAutocommit) {
  137.         DriverControlStationDB.checkAutocommit = checkAutocommit;
  138.     }
  139.     public static Logger getCheckLogger() {
  140.         return checkLogger;
  141.     }
  142.     public static void setCheckLogger(Logger checkLogger) {
  143.         DriverControlStationDB.checkLogger = checkLogger;
  144.     }
  145.     
  146.     /*  F I E L D S P R I V A T I */

  148.     /** Indicazione di una corretta creazione */
  149.     public boolean create = false;

  151.     // Datasource per la connessione al DB
  152.     public DataSource datasource = null;
  153.     public void setDatasource(DataSource datasource) {
  154.         this.datasource = datasource;
  155.     }

  157.     // Connection passata al momento della creazione dell'oggetto
  158.     private Connection globalConnection = null;
  159.     // Variabile di controllo del tipo di operazione da effettuare
  160.     // l'autoCommit viene gestito internamente a questa classe
  161.     private boolean atomica = true;

  163.     /** Logger utilizzato per debug. */
  164.     private org.slf4j.Logger log = null;
  165.     public void logDebug(String msg) {
  166.         if(this.log!=null) {
  167.             this.log.debug(msg);
  168.         }
  169.     }
  170.     public void logDebug(String msg, Exception e) {
  171.         if(this.log!=null) {
  172.             this.log.debug(msg,e);
  173.         }
  174.     }

  176.     // Tipo database passato al momento della creazione dell'oggetto
  177.     private String tipoDB = null;

  179.     /**
  180.      * Questo driver incapsula i driver DriverConfiguarazioneDB e
  181.      * DriverRegistroDB utilizza i loro metodi e ne implementa di nuovi
  182.      */

  184.     private DriverConfigurazioneDB configDB = null;
  185.     private DriverRegistroServiziDB regservDB = null;
  186.     private DriverUsersDB usersDB = null;
  187.     private DriverAudit auditDB = null;
  188.     private DriverAuditDBAppender auditDBappender = null;
  189.     private JDBCServiceManager jdbcServiceManagerControlloTraffico = null;
  190.     private org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager jdbcServiceManagerPlugins;
  191.     private org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager jdbcServiceManagerAllarmi;

  193.     private IDAccordoFactory idAccordoFactory = null;
  194. //  @SuppressWarnings("unused")
  195.     private IDAccordoCooperazioneFactory idAccordoCooperazioneFactory = null;
  196.     
  197.     public String getTipoDatabase() {
  198.         return this.tipoDB;
  199.     }

  201.     public DriverConfigurazioneDB getDriverConfigurazioneDB() {
  202.         return this.configDB;
  203.     }

  205.     public DriverRegistroServiziDB getDriverRegistroServiziDB() {
  206.         return this.regservDB;
  207.     }

  209.     public DriverUsersDB getDriverUsersDB() {
  210.         return this.usersDB;
  211.     }

  213.     public DriverAudit getDriverAuditDB() {
  214.         return this.auditDB;
  215.     }

  217.     public DriverAuditDBAppender getDriverAuditDBAppender() {
  218.         return this.auditDBappender;
  219.     }
  220.     
  221.     public JDBCServiceManager getJdbcServiceManagerControlloTraffico() {
  222.         return this.jdbcServiceManagerControlloTraffico;
  223.     }
  224.     
  225.     public org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager getJdbcServiceManagerPlugins() {
  226.         return this.jdbcServiceManagerPlugins;
  227.     }
  228.     
  229.     public org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager getJdbcServiceManagerAllarmi() {
  230.         return this.jdbcServiceManagerAllarmi;
  231.     }

  233.     public DriverControlStationDB(Connection connection, Properties context, String tipoDB) throws DriverControlStationException {
  234.         this.log = ControlStationLogger.getDriverDBPddConsoleLogger();

  236.         if (connection == null) {
  237.             this.create = false;
  238.             throw new DriverControlStationException("[DriverControlStationDB::DriverControlStation(Connection con, Properties context, String tipoDB) La connection non puo essere null.");
  239.         }

  241.         if (tipoDB == null) {
  242.             this.create = false;
  243.             throw new DriverControlStationException("[DriverControlStationDB::DriverControlStation(Connection con, Properties context, String tipoDB) Il tipoDatabase non puo essere null.");
  244.         }

  246.         // InitialContext initCtx = new InitialContext(context);
  247.         this.globalConnection = connection;
  248.         this.create = true;
  249.         this.atomica = false;
  250.         this.tipoDB = tipoDB;

  252.         try {
  253.             this.configDB = new DriverConfigurazioneDB(connection, this.tipoDB);
  254.             this.regservDB = new DriverRegistroServiziDB(connection, this.tipoDB);
  255.             boolean useSuperUser = false;
  256.             if(ControlStationCore.isAPIMode()==false) {
  257.                 useSuperUser = !ConsoleProperties.getInstance().isVisibilitaOggettiGlobale();
  258.             }
  259.             this.configDB.setUseSuperUser(useSuperUser);
  260.             this.regservDB.setUseSuperUser(useSuperUser);
  261.             this.usersDB = new DriverUsersDB(connection, this.tipoDB, this.log);
  262.             this.auditDB = new DriverAudit(connection, this.tipoDB);
  263.             this.auditDBappender = new DriverAuditDBAppender(connection, this.tipoDB);
  264.             ServiceManagerProperties properties = new ServiceManagerProperties();
  265.             properties.setDatabaseType(this.tipoDB);
  266.             properties.setShowSql(true);
  267.             this.jdbcServiceManagerControlloTraffico = new org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager(connection, properties, this.log);
  268.             this.jdbcServiceManagerPlugins = new org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager(connection, properties, this.log);
  269.             this.jdbcServiceManagerAllarmi = new org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager(connection, properties, this.log);
  270.             this.idAccordoFactory = IDAccordoFactory.getInstance();
  271.             this.idAccordoCooperazioneFactory = IDAccordoCooperazioneFactory.getInstance();
  272.         } catch (Exception e) {
  273.             throw new DriverControlStationException("[DriverControlStationDB::DriverControlStation(Connection con, Properties context, String tipoDB) Errore creando i driver ausiliari.");
  274.         }

  276.         // Setto il tipoDB anche in DriverControlStationDB_LIB
  277.         DriverControlStationDB_LIB.setTipoDB(tipoDB);

  279.         this.log.info("Creato DriverControlStationDB");
  280.     }

  282.     
  283.     private Connection getConnection(String nomeMetodo) throws DriverControlStationException {
  284.         Connection con = null;
  285.         if (this.atomica) {
  286.             try {
  287.                 con = this.datasource.getConnection();
  288.             } catch (SQLException e) {
  289.                 throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] SQLException accedendo al datasource :" + e.getMessage());
  290.             }

  292.         } else {
  293.             con = this.globalConnection;
  294.         }
  295.         return con;
  296.     }
  297.     private Connection getConnection(String nomeMetodo, BooleanNullable setAutoCommit) throws DriverControlStationException {
  298.         Connection con = getConnection(nomeMetodo);
  299.         if (this.atomica) {
  300.             if(setAutoCommit!=null && setAutoCommit.getValue()!=null) {
  301.                 try {
  302.                     con.setAutoCommit(setAutoCommit.getValue());
  303.                 } catch (SQLException e) {
  304.                     throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] SQLException accedendo al datasource :" + e.getMessage());
  305.                 }
  306.             }
  307.         }
  308.         return con;
  309.     }
  310.     private void releaseConnection(Connection con) {
  311.         try {
  312.             if (this.atomica) {
  313.                 this.logDebug("rilascio connessione al db...");
  314.                 JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  315.             }
  316.         } catch (Exception e) {
  317.             // ignore exception
  318.         }
  319.     }
  320.     
  321.     
  322.     
  323.     /* ***** PDD **** */
  324.     
  325.     public void createPdDControlStation(PdDControlStation pdd) throws DriverControlStationException {
  326.         String nomeMetodo = "createPdd";

  328.         Connection con = null;
  329.         
  330.         con = getConnection(nomeMetodo);

  332.         this.logDebug("operazione this.atomica = " + this.atomica);

  334.         try {

  336.             DriverControlStationDB_LIB.CRUDPdd(CostantiDB.CREATE, pdd, con);

  338.         } catch (Exception se) {
  339.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  340.         } finally {
  341.             releaseConnection(con);
  342.         }

  344.     }

  346.     public void deletePdDControlStation(PdDControlStation pdd) throws DriverControlStationException {
  347.         String nomeMetodo = "deletePdd";

  349.         Connection con = null;

  351.         con = getConnection(nomeMetodo);

  353.         this.logDebug("operazione this.atomica = " + this.atomica);

  355.         try {

  357.             DriverControlStationDB_LIB.CRUDPdd(CostantiDB.DELETE, pdd, con);

  359.         } catch (Exception se) {
  360.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  361.         } finally {

  363.             releaseConnection(con);
  364.         }

  366.     }

  368.     public void updatePdDControlStation(PdDControlStation pdd) throws DriverControlStationException {
  369.         String nomeMetodo = "updatePdd";

  371.         Connection con = null;

  373.         con = getConnection(nomeMetodo);

  375.         this.logDebug("operazione this.atomica = " + this.atomica);

  377.         try {

  379.             DriverControlStationDB_LIB.CRUDPdd(CostantiDB.UPDATE, pdd, con);

  381.         } catch (Exception se) {
  382.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  383.         } finally {
  384.             releaseConnection(con);
  385.         }

  387.     }
  388.     
  389.     public List<PdDControlStation> pddList(String superuser, ISearch ricerca) throws DriverControlStationException {
  390.         String nomeMetodo = "pddList";
  391.         int idLista = Liste.PDD;
  392.         int offset;
  393.         int limit;
  394.         String search;
  395.         String queryString;

  397.         limit = ricerca.getPageSize(idLista);
  398.         offset = ricerca.getIndexIniziale(idLista);
  399.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  400.         ricerca.getSearchString(idLista);

  402.         Connection con = null;
  403.         PreparedStatement stmt = null;
  404.         ResultSet risultato = null;

  406.         con = getConnection(nomeMetodo);

  408.         try {

  410.             if (!search.equals("")) {
  411.                 // query con search
  412.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  413.                 sqlQueryObject.addFromTable(CostantiDB.PDD);
  414.                 sqlQueryObject.addSelectCountField("*", "cont");
  415.                 if (superuser!=null && (!superuser.equals("")))
  416.                     sqlQueryObject.addWhereCondition("superuser = ?");
  417.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  418.                 sqlQueryObject.setANDLogicOperator(true);
  419.                 queryString = sqlQueryObject.createSQLQuery();
  420.             } else {
  421.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  422.                 sqlQueryObject.addFromTable(CostantiDB.PDD);
  423.                 sqlQueryObject.addSelectCountField("*", "cont");
  424.                 if (superuser!=null && (!superuser.equals("")))
  425.                     sqlQueryObject.addWhereCondition("superuser = ?");
  426.                 queryString = sqlQueryObject.createSQLQuery();
  427.             }
  428.             stmt = con.prepareStatement(queryString);
  429.             if (superuser!=null && (!superuser.equals("")))
  430.                 stmt.setString(1, superuser);
  431.             risultato = stmt.executeQuery();
  432.             if (risultato.next()) {
  433.                 ricerca.setNumEntries(idLista, risultato.getInt(1));
  434.             }
  435.             risultato.close();
  436.             stmt.close();

  438.             // ricavo le entries
  439.             if (limit == 0) {
  440.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  441.             }
  442.             if (!search.equals("")) {
  443.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  444.                 sqlQueryObject.addFromTable(CostantiDB.PDD);
  445.                 sqlQueryObject.addSelectField("id");
  446.                 sqlQueryObject.addSelectField("nome");
  447.                 if (superuser!=null && (!superuser.equals("")))
  448.                     sqlQueryObject.addWhereCondition("superuser = ?");
  449.                 sqlQueryObject.addWhereLikeCondition("nome", search, true, true);
  450.                 sqlQueryObject.setANDLogicOperator(true);
  451.                 sqlQueryObject.addOrderBy("nome");
  452.                 sqlQueryObject.setSortType(true);
  453.                 sqlQueryObject.setLimit(limit);
  454.                 sqlQueryObject.setOffset(offset);
  455.                 queryString = sqlQueryObject.createSQLQuery();
  456.             } else {
  457.                 // senza search
  458.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  459.                 sqlQueryObject.addFromTable(CostantiDB.PDD);
  460.                 sqlQueryObject.addSelectField("id");
  461.                 sqlQueryObject.addSelectField("nome");
  462.                 if (superuser!=null && (!superuser.equals("")))
  463.                     sqlQueryObject.addWhereCondition("superuser = ?");
  464.                 sqlQueryObject.addOrderBy("nome");
  465.                 sqlQueryObject.setSortType(true);
  466.                 sqlQueryObject.setLimit(limit);
  467.                 sqlQueryObject.setOffset(offset);
  468.                 queryString = sqlQueryObject.createSQLQuery();
  469.             }
  470.             stmt = con.prepareStatement(queryString);
  471.             if (superuser!=null && (!superuser.equals("")))
  472.                 stmt.setString(1, superuser);
  473.             risultato = stmt.executeQuery();

  475.             ArrayList<PdDControlStation> lista = new ArrayList<PdDControlStation>();
  476.             PdDControlStation pdd = null;
  477.             while (risultato.next()) {
  478.                 long id = risultato.getLong("id");
  479.                 pdd = this.getPdDControlStation(id);
  480.                 lista.add(pdd);
  481.             }
  482.             risultato.close();
  483.             stmt.close();

  485.             return lista;

  487.         } catch (Exception se) {

  489.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  490.         } finally {

  492.             // Chiudo statement and resultset
  493.             try {
  494.                 if (risultato != null) {
  495.                     risultato.close();
  496.                 }
  497.             } catch (Exception e) {
  498.                 // ignore
  499.             }
  500.             try {
  501.                 if (stmt != null) {
  502.                     stmt.close();
  503.                 }
  504.             } catch (Exception e) {
  505.                 // ignore
  506.             }

  508.             releaseConnection(con);
  509.         }

  511.     }

  513.     /**
  514.      * 
  515.      * @param idPdd
  516.      * @return Pdd
  517.      * @throws DriverControlStationException
  518.      */
  519.     public PdDControlStation getPdDControlStation(long idPdd) throws DriverControlStationException, DriverControlStationNotFound {
  520.         String nomeMetodo = "pddList(long idPdd)";

  522.         String queryString;

  524.         Connection con = null;
  525.         PreparedStatement stmt = null;
  526.         ResultSet risultato = null;

  528.         con = getConnection(nomeMetodo);

  530.         try {

  532.             PdDControlStation pdd = new PdDControlStation();

  534.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  535.             sqlQueryObject.addFromTable(CostantiDB.PDD);
  536.             sqlQueryObject.addSelectField("*");
  537.             sqlQueryObject.addWhereCondition("id = ?");
  538.             queryString = sqlQueryObject.createSQLQuery();
  539.             stmt = con.prepareStatement(queryString);
  540.             stmt.setLong(1, idPdd);
  541.             risultato = stmt.executeQuery();
  542.             if (risultato.next()) {
  543.                 pdd.setId(risultato.getLong("id"));
  544.                 pdd.setNome(risultato.getString("nome"));
  545.                 pdd.setDescrizione(risultato.getString("descrizione"));

  547.                 pdd.setIp(risultato.getString("ip"));
  548.                 pdd.setPorta(risultato.getInt("porta"));
  549.                 pdd.setIpGestione(risultato.getString("ip_gestione"));
  550.                 pdd.setPortaGestione(risultato.getInt("porta_gestione"));
  551.                 pdd.setProtocollo(risultato.getString("protocollo"));
  552.                 pdd.setProtocolloGestione(risultato.getString("protocollo_gestione"));

  554.                 pdd.setTipo(risultato.getString("tipo"));
  555.                 pdd.setImplementazione(risultato.getString("implementazione"));

  557.                 pdd.setPassword(risultato.getString("password"));
  558.                 pdd.setSubject(risultato.getString("subject"));
  559.                 pdd.setClientAuth(DriverRegistroServiziDB_LIB.getEnumStatoFunzionalita(risultato.getString("client_auth")));

  561.                 // Ora Registrazione
  562.                 if (risultato.getTimestamp("ora_registrazione") != null) {
  563.                     pdd.setOraRegistrazione(new Date(risultato.getTimestamp("ora_registrazione").getTime()));
  564.                 }

  566.                 pdd.setSuperUser(risultato.getString("superuser"));

  568.             } else {
  569.                 throw new DriverControlStationNotFound("Porta di dominio con id " + idPdd + " non trovata.");
  570.             }

  572.             risultato.close();
  573.             stmt.close();

  575.             return pdd;

  577.         } catch (DriverControlStationNotFound e) {
  578.             throw e;
  579.         } catch (Exception se) {

  581.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  582.         } finally {
  583.             // Chiudo statement and resultset
  584.             try {
  585.                 if (risultato != null) {
  586.                     risultato.close();
  587.                 }
  588.             } catch (Exception e) {
  589.                 // ignore
  590.             }
  591.             try {
  592.                 if (stmt != null) {
  593.                     stmt.close();
  594.                 }
  595.             } catch (Exception e) {
  596.                 // ignore
  597.             }
  598.             releaseConnection(con);
  599.         }

  601.     }

  603.     public List<org.openspcoop2.core.config.Soggetto> pddSoggettiList(long idPdd, ISearch ricerca) throws DriverControlStationException {
  604.         String nomeMetodo = "pddSoggettiList";
  605.         int idLista = Liste.PDD_SOGGETTI;
  606.         int offset;
  607.         int limit;
  608.         String search;
  609.         String queryString;

  611.         limit = ricerca.getPageSize(idLista);
  612.         offset = ricerca.getIndexIniziale(idLista);
  613.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));
  614.         ricerca.getSearchString(idLista);

  616.         Connection con = null;
  617.         PreparedStatement stmt = null;
  618.         ResultSet risultato = null;

  620.         con = getConnection(nomeMetodo);

  622.         ArrayList<org.openspcoop2.core.config.Soggetto> lista = null;

  624.         try {

  626.             // Prendo il nome del pdd
  627.             String nomePdd = "";
  628.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  629.             sqlQueryObject.addFromTable(CostantiDB.PDD);
  630.             sqlQueryObject.addSelectField("*");
  631.             sqlQueryObject.addWhereCondition("id = ?");
  632.             queryString = sqlQueryObject.createSQLQuery();
  633.             stmt = con.prepareStatement(queryString);
  634.             stmt.setLong(1, idPdd);
  635.             risultato = stmt.executeQuery();
  636.             if (risultato.next()) {
  637.                 nomePdd = risultato.getString("nome");
  638.             }
  639.             risultato.close();
  640.             stmt.close();

  642.             if (!search.equals("")) {
  643.                 // query con search
  644.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  645.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  646.                 sqlQueryObject.addSelectCountField("*", "cont");
  647.                 sqlQueryObject.addWhereCondition("server = ?");
  648.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("nome_soggetto", search, true, true), sqlQueryObject.getWhereLikeCondition("tipo_soggetto", search, true, true));
  649.                 sqlQueryObject.setANDLogicOperator(true);
  650.                 queryString = sqlQueryObject.createSQLQuery();
  651.             } else {
  652.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  653.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  654.                 sqlQueryObject.addSelectCountField("*", "cont");
  655.                 sqlQueryObject.addWhereCondition("server = ?");
  656.                 queryString = sqlQueryObject.createSQLQuery();
  657.             }
  658.             stmt = con.prepareStatement(queryString);
  659.             stmt.setString(1, nomePdd);
  660.             risultato = stmt.executeQuery();
  661.             if (risultato.next()) {
  662.                 ricerca.setNumEntries(idLista, risultato.getInt(1));
  663.             }
  664.             risultato.close();
  665.             stmt.close();

  667.             // ricavo le entries
  668.             if (limit == 0) {
  669.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  670.             }
  671.             if (!search.equals("")) {
  672.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  673.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  674.                 sqlQueryObject.addSelectField("server");
  675.                 sqlQueryObject.addSelectField("nome_soggetto");
  676.                 sqlQueryObject.addSelectField("tipo_soggetto");
  677.                 sqlQueryObject.addSelectField("id");
  678.                 sqlQueryObject.addSelectField("descrizione");
  679.                 sqlQueryObject.addSelectField("identificativo_porta");
  680.                 sqlQueryObject.addWhereCondition("server = ?");
  681.                 sqlQueryObject.addWhereCondition(false, sqlQueryObject.getWhereLikeCondition("nome_soggetto", search, true, true), sqlQueryObject.getWhereLikeCondition("tipo_soggetto", search, true, true));
  682.                 sqlQueryObject.setANDLogicOperator(true);
  683.                 sqlQueryObject.addOrderBy("tipo_soggetto");
  684.                 sqlQueryObject.addOrderBy("nome_soggetto");
  685.                 sqlQueryObject.setSortType(true);
  686.                 sqlQueryObject.setLimit(limit);
  687.                 sqlQueryObject.setOffset(offset);
  688.                 queryString = sqlQueryObject.createSQLQuery();
  689.             } else {
  690.                 // senza search
  691.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  692.                 sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  693.                 sqlQueryObject.addSelectField("server");
  694.                 sqlQueryObject.addSelectField("nome_soggetto");
  695.                 sqlQueryObject.addSelectField("tipo_soggetto");
  696.                 sqlQueryObject.addSelectField("id");
  697.                 sqlQueryObject.addSelectField("descrizione");
  698.                 sqlQueryObject.addSelectField("identificativo_porta");
  699.                 sqlQueryObject.addWhereCondition("server = ?");
  700.                 sqlQueryObject.addOrderBy("tipo_soggetto");
  701.                 sqlQueryObject.addOrderBy("nome_soggetto");
  702.                 sqlQueryObject.setSortType(true);
  703.                 sqlQueryObject.setLimit(limit);
  704.                 sqlQueryObject.setOffset(offset);
  705.                 queryString = sqlQueryObject.createSQLQuery();
  706.             }
  707.             stmt = con.prepareStatement(queryString);
  708.             stmt.setString(1, nomePdd);
  709.             risultato = stmt.executeQuery();

  711.             lista = new ArrayList<org.openspcoop2.core.config.Soggetto>();
  712.             org.openspcoop2.core.config.Soggetto sog = null;
  713.             while (risultato.next()) {
  714.                 sog = new org.openspcoop2.core.config.Soggetto();

  716.                 sog.setId(risultato.getLong("id"));
  717.                 sog.setNome(risultato.getString("nome_soggetto"));
  718.                 sog.setTipo(risultato.getString("tipo_soggetto"));
  719.                 sog.setDescrizione(risultato.getString("descrizione"));
  720.                 sog.setIdentificativoPorta(risultato.getString("identificativo_porta"));

  722.                 lista.add(sog);
  723.             }

  725.             return lista;

  727.         } catch (Exception se) {

  729.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  730.         } finally {
  731.             // Chiudo statement and resultset
  732.             try {
  733.                 if (risultato != null) {
  734.                     risultato.close();
  735.                 }
  736.             } catch (Exception e) {
  737.                 // ignore
  738.             }
  739.             try {
  740.                 if (stmt != null) {
  741.                     stmt.close();
  742.                 }
  743.             } catch (Exception e) {
  744.                 // ignore
  745.             }
  746.             releaseConnection(con);
  747.         }

  749.     }


  752.     /**
  753.      * Ritorna una Porta di Dominio tramite il parametro passato
  754.      * 
  755.      * @param nomePdd
  756.      * @return Pdd se esiste una Porta di Dominio con il nome passato, null
  757.      *         altrimenti
  758.      * @throws DriverControlStationException
  759.      */
  760.     public PdDControlStation getPdDControlStation(String nomePdd) throws DriverControlStationException, DriverControlStationNotFound {
  761.         String nomeMetodo = "pddList(String nomePdd)";

  763.         String queryString;

  765.         Connection con = null;
  766.         PreparedStatement stmt = null;
  767.         ResultSet risultato = null;

  769.         con = getConnection(nomeMetodo);

  771.         try {

  773.             PdDControlStation pdd = null;

  775.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  776.             sqlQueryObject.addFromTable(CostantiDB.PDD);
  777.             sqlQueryObject.addSelectField("*");
  778.             sqlQueryObject.addWhereCondition("nome = ?");
  779.             queryString = sqlQueryObject.createSQLQuery();
  780.             stmt = con.prepareStatement(queryString);
  781.             stmt.setString(1, nomePdd);
  782.             risultato = stmt.executeQuery();
  783.             if (risultato.next()) {
  784.                 long id = risultato.getLong("id");
  785.                 pdd = this.getPdDControlStation(id);
  786.             } else {
  787.                 throw new DriverControlStationNotFound("Porta di dominio con nome " + nomePdd + " non trovata.");
  788.             }

  790.             risultato.close();
  791.             stmt.close();

  793.             return pdd;

  795.         } catch (DriverControlStationNotFound e) {
  796.             throw e;
  797.         } catch (Exception se) {

  799.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  800.         } finally {
  801.             // Chiudo statement and resultset
  802.             try {
  803.                 if (risultato != null) {
  804.                     risultato.close();
  805.                 }
  806.             } catch (Exception e) {
  807.                 // ignore
  808.             }
  809.             try {
  810.                 if (stmt != null) {
  811.                     stmt.close();
  812.                 }
  813.             } catch (Exception e) {
  814.                 // ignore
  815.             }
  816.             releaseConnection(con);
  817.         }
  818.     }
  819.     
  820.     public List<SoggettoCtrlStat> soggettiWithServer(String nomePdD) throws DriverControlStationException {
  821.         Connection con = null;
  822.         PreparedStatement stmt = null;
  823.         ResultSet risultato = null;
  824.         String queryString = "";

  826.         String nomeMetodo = "soggettiWithServer";
  827.         con = getConnection(nomeMetodo);

  829.         this.logDebug("operazione this.atomica = " + this.atomica);

  831.         try {
  832.             SoggettoCtrlStat scs = null;
  833.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  834.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  835.             sqlQueryObject.addSelectField("*");
  836.             sqlQueryObject.addWhereCondition("server=?");
  837.             queryString = sqlQueryObject.createSQLQuery();
  838.             stmt = con.prepareStatement(queryString);
  839.             stmt.setString(1, nomePdD);
  840.             List<SoggettoCtrlStat> scsList = new ArrayList<SoggettoCtrlStat>();
  841.             risultato = stmt.executeQuery();
  842.             while (risultato.next()) {
  843.                 org.openspcoop2.core.config.Soggetto soggConf = this.getDriverConfigurazioneDB().getSoggetto(risultato.getLong("id"));
  844.                 org.openspcoop2.core.registry.Soggetto soggReg = this.getDriverRegistroServiziDB().getSoggetto(risultato.getLong("id"));
  845.                 scs = new SoggettoCtrlStat(soggReg, soggConf);
  846.                 scsList.add(scs);
  847.             }
  848.             risultato.close();
  849.             stmt.close();

  851.             return scsList;

  853.         } catch (Exception se) {
  854.             throw new DriverControlStationException(se);
  855.         } finally {
  856.             // Chiudo statement and resultset
  857.             try {
  858.                 if (risultato != null) {
  859.                     risultato.close();
  860.                 }
  861.             } catch (Exception e) {
  862.                 // ignore
  863.             }
  864.             try {
  865.                 if (stmt != null) {
  866.                     stmt.close();
  867.                 }
  868.             } catch (Exception e) {
  869.                 // ignore
  870.             }
  871.             releaseConnection(con);
  872.         }
  873.     }

  875.     
  876.     
  877.     
  878.     
  879.     
  880.     
  881.     
  882.     
  883.     /* ***** MAPPING **** */
  884.     
  885.     public void createMappingFruizionePortaDelegata(MappingFruizionePortaDelegata mapping) throws DriverControlStationException {
  886.         String nomeMetodo = "createMappingFruizionePortaDelegata";

  888.         Connection con = null;

  890.         con = getConnection(nomeMetodo);

  892.         this.logDebug("operazione this.atomica = " + this.atomica);

  894.         try {

  896.             DBMappingUtils.createMappingFruizione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata(), con, this.tipoDB);

  898.         } catch (Exception se) {
  899.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  900.         } finally {
  901.             releaseConnection(con);
  902.         }

  904.         mapping.setTableId(this.getTableIdMappingFruizionePortaDelegata(mapping));
  905.     }
  906.     
  907.     public void deleteMappingFruizionePortaDelegata(MappingFruizionePortaDelegata mapping) throws DriverControlStationException {
  908.         String nomeMetodo = "deleteMappingFruizionePortaDelegata";

  910.         Connection con = null;

  912.         con = getConnection(nomeMetodo);

  914.         this.logDebug("operazione this.atomica = " + this.atomica);

  916.         try {

  918.             DBMappingUtils.deleteMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata(), con, this.tipoDB);

  920.         } catch (Exception se) {
  921.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  922.         } finally {
  923.             releaseConnection(con);
  924.         }

  926.     }
  927.     
  928.     public IDPortaDelegata getIDPortaDelegataAssociataDefault(IDServizio idServizio,IDSoggetto idFruitore) throws DriverControlStationException {
  929.         String nomeMetodo = "getIDPortaDelegataAssociataDefault";

  931.         Connection con = null;

  933.         con = getConnection(nomeMetodo);

  935.         this.logDebug("operazione this.atomica = " + this.atomica);

  937.         try {

  939.             return DBMappingUtils.getIDPortaDelegataAssociataDefault(idServizio, idFruitore, con, this.tipoDB);

  941.         } catch (Exception se) {
  942.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  943.         } finally {
  944.             releaseConnection(con);
  945.         }

  947.     }
  948.     
  949.     public IDPortaDelegata getIDPortaDelegataAssociataAzione(IDServizio idServizio,IDSoggetto idFruitore) throws DriverControlStationException {
  950.         String nomeMetodo = "getIDPortaDelegataAssociataAzione";

  952.         Connection con = null;

  954.         con = getConnection(nomeMetodo);

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

  958.         try {

  960.             return DBMappingUtils.getIDPortaDelegataAssociataAzione(idServizio, idFruitore, con, this.tipoDB);

  962.         } catch (Exception se) {
  963.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  964.         } finally {
  965.             releaseConnection(con);
  966.         }

  968.     }
  969.     
  970.     public List<IDPortaDelegata> getIDPorteDelegateAssociate(IDServizio idServizio,IDSoggetto idFruitore) throws DriverControlStationException {
  971.         String nomeMetodo = "getIDPorteDelegateAssociate";

  973.         Connection con = null;

  975.         con = getConnection(nomeMetodo);

  977.         this.logDebug("operazione this.atomica = " + this.atomica);

  979.         try {

  981.             return DBMappingUtils.getIDPorteDelegateAssociate(idServizio, idFruitore, con, this.tipoDB);

  983.         } catch (Exception se) {
  984.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  985.         } finally {
  986.             releaseConnection(con);
  987.         }

  989.     }
  990.     
  991.     public long getTableIdMappingFruizionePortaDelegata(MappingFruizionePortaDelegata mapping) throws DriverControlStationException {
  992.         String nomeMetodo = "getTableIdMappingFruizionePortaDelegata";

  994.         Connection con = null;

  996.         con = getConnection(nomeMetodo);

  998.         this.logDebug("operazione this.atomica = " + this.atomica);

  1000.         try {

  1002.             return DBMappingUtils.getTableIdMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata(), con, this.tipoDB);

  1004.         } catch (Exception se) {
  1005.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1006.         } finally {
  1007.             releaseConnection(con);
  1008.         }

  1010.     }
  1011.     
  1012.     public boolean existsMappingFruizionePortaDelegata(MappingFruizionePortaDelegata mapping) throws DriverControlStationException {
  1013.         String nomeMetodo = "existsMappingFruizionePortaDelegata";

  1015.         Connection con = null;

  1017.         con = getConnection(nomeMetodo);

  1019.         this.logDebug("operazione this.atomica = " + this.atomica);

  1021.         try {

  1023.             return DBMappingUtils.existsMappingFruizione(mapping.getIdServizio(), mapping.getIdFruitore(), mapping.getIdPortaDelegata(), con, this.tipoDB);

  1025.         } catch (Exception se) {
  1026.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1027.         } finally {
  1028.             releaseConnection(con);
  1029.         }

  1031.     }
  1032.     
  1033.     
  1034.     public void createMappingErogazionePortaApplicativa(MappingErogazionePortaApplicativa mapping) throws DriverControlStationException {
  1035.         String nomeMetodo = "createMappingErogazionePortaApplicativa";

  1037.         Connection con = null;

  1039.         con = getConnection(nomeMetodo);

  1041.         this.logDebug("operazione this.atomica = " + this.atomica);

  1043.         try {

  1045.             DBMappingUtils.createMappingErogazione(mapping.getNome(), mapping.getDescrizione(), mapping.isDefault(), mapping.getIdServizio(), mapping.getIdPortaApplicativa(), con, this.tipoDB);

  1047.         } catch (Exception se) {
  1048.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1049.         } finally {
  1050.             releaseConnection(con);
  1051.         }

  1053.         mapping.setTableId(mapping.getTableId());
  1054.     }
  1055.     
  1056.     
  1057.     public void deleteMappingErogazionePortaApplicativa(MappingErogazionePortaApplicativa mapping) throws DriverControlStationException {
  1058.         String nomeMetodo = "deleteMappingErogazionePortaApplicativa";

  1060.         Connection con = null;

  1062.         con = getConnection(nomeMetodo);

  1064.         this.logDebug("operazione this.atomica = " + this.atomica);

  1066.         try {

  1068.             DBMappingUtils.deleteMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa(), con, this.tipoDB);

  1070.         } catch (Exception se) {
  1071.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1072.         } finally {
  1073.             releaseConnection(con);
  1074.         }

  1076.     }
  1077.     
  1078.     public IDPortaApplicativa getIDPortaApplicativaAssociataDefault(IDServizio idServizio) throws DriverControlStationException {
  1079.         String nomeMetodo = "getIDPortaApplicativaAssociataDefault";

  1081.         Connection con = null;

  1083.         con = getConnection(nomeMetodo);

  1085.         this.logDebug("operazione this.atomica = " + this.atomica);

  1087.         try {

  1089.             return DBMappingUtils.getIDPortaApplicativaAssociataDefault(idServizio, con, this.tipoDB);

  1091.         } catch (Exception se) {
  1092.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1093.         } finally {
  1094.             releaseConnection(con);
  1095.         }

  1097.     }
  1098.     
  1099.     public IDPortaApplicativa getIDPortaApplicativaAssociataAzione(IDServizio idServizio) throws DriverControlStationException {
  1100.         String nomeMetodo = "getIDPortaApplicativaAssociataAzione";

  1102.         Connection con = null;

  1104.         con = getConnection(nomeMetodo);

  1106.         this.logDebug("operazione this.atomica = " + this.atomica);

  1108.         try {

  1110.             return DBMappingUtils.getIDPortaApplicativaAssociataAzione(idServizio, con, this.tipoDB);

  1112.         } catch (Exception se) {
  1113.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1114.         } finally {
  1115.             releaseConnection(con);
  1116.         }

  1118.     }
  1119.     
  1120.     public List<IDPortaApplicativa> getIDPorteApplicativeAssociate(IDServizio idServizio) throws DriverControlStationException {
  1121.         String nomeMetodo = "getIDPorteApplicativeAssociate";

  1123.         Connection con = null;

  1125.         con = getConnection(nomeMetodo);

  1127.         this.logDebug("operazione this.atomica = " + this.atomica);

  1129.         try {

  1131.             return DBMappingUtils.getIDPorteApplicativeAssociate(idServizio, con, this.tipoDB);

  1133.         } catch (Exception se) {
  1134.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1135.         } finally {
  1136.             releaseConnection(con);
  1137.         }

  1139.     }
  1140.     
  1141.     public long getTableIdMappingErogazionePortaApplicativa(MappingErogazionePortaApplicativa mapping) throws DriverControlStationException {
  1142.         String nomeMetodo = "getTableIdMappingErogazionePortaApplicativa";

  1144.         Connection con = null;

  1146.         con = getConnection(nomeMetodo);

  1148.         this.logDebug("operazione this.atomica = " + this.atomica);

  1150.         try {

  1152.             return DBMappingUtils.getTableIdMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa(), con, this.tipoDB);

  1154.         } catch (Exception se) {
  1155.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1156.         } finally {
  1157.             releaseConnection(con);
  1158.         }

  1160.     }
  1161.     
  1162.     public boolean existsMappingErogazionePortaApplicativa(MappingErogazionePortaApplicativa mapping) throws DriverControlStationException {
  1163.         String nomeMetodo = "existsMappingErogazionePortaApplicativa";

  1165.         Connection con = null;

  1167.         con = getConnection(nomeMetodo);

  1169.         this.logDebug("operazione this.atomica = " + this.atomica);

  1171.         try {

  1173.             return DBMappingUtils.existsMappingErogazione(mapping.getIdServizio(), mapping.getIdPortaApplicativa(), con, this.tipoDB);

  1175.         } catch (Exception se) {
  1176.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1177.         } finally {
  1178.             releaseConnection(con);
  1179.         }

  1181.     }
  1182.     
  1183.     private void initMappingErogazione_releaseConnectionGestioneErrore(boolean error, Connection con) {
  1184.         try {
  1185.             if (error && this.atomica) {
  1186.                 this.logDebug("eseguo rollback a causa di errori e rilascio connessioni...");
  1187.                 if(con!=null) {
  1188.                     con.rollback();
  1189.                     con.setAutoCommit(true);
  1190.                     JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  1191.                 }

  1193.             } else if (!error && this.atomica) {
  1194.                 this.logDebug("eseguo commit e rilascio connessioni...");
  1195.                 if(con!=null) {
  1196.                     con.commit();
  1197.                     con.setAutoCommit(true);
  1198.                     JDBCUtilities.closeConnection(checkLogger, con, checkAutocommit, checkIsClosed);
  1199.                 }
  1200.             }
  1201.         } catch (Exception e) {
  1202.             // ignore exception
  1203.         }
  1204.     }
  1205.     
  1206.     public void initMappingErogazione(Logger log) throws DriverControlStationException {
  1207.         this._initMapping(true,false,log);
  1208.     }   
  1209.     public void initMappingErogazione(boolean forceMapping, Logger log) throws DriverControlStationException {
  1210.         this._initMapping(true,forceMapping,log);
  1211.     }
  1212.     public void initMappingFruizione(Logger log) throws DriverControlStationException {
  1213.         this._initMapping(false,false,log);
  1214.     }   
  1215.     public void initMappingFruizione(boolean forceMapping, Logger log) throws DriverControlStationException {
  1216.         this._initMapping(false,forceMapping,log);
  1217.     }   
  1218.     private void _initMapping(boolean erogazione, boolean forceMapping, Logger log) throws DriverControlStationException {
  1219.         String nomeMetodo = "initMappingErogazione";
  1220.         if(!erogazione){
  1221.             nomeMetodo = "initMappingFruizione";
  1222.         }

  1224.         Connection con = null;
  1225.         boolean error = false;

  1227.         con = getConnection(nomeMetodo, BooleanNullable.FALSE());

  1229.         log.debug("operazione this.atomica = " + this.atomica);

  1231.         try {

  1233.             int countMapping = -1;
  1234.             if(erogazione){
  1235.                 countMapping = DBMappingUtils.countMappingErogazione(con, this.tipoDB);
  1236.             }
  1237.             else{
  1238.                 countMapping = DBMappingUtils.countMappingFruizione(con, this.tipoDB);
  1239.             }
  1240.             log.debug("Count ["+nomeMetodo+"]: "+countMapping);
  1241.             if(countMapping<=0 || forceMapping){
  1242.                 
  1243.                 log.debug("Controllo Consistenza Dati ["+nomeMetodo+"] ...");
  1244.                 
  1245.                 DriverRegistroServiziDB driverRegistry = new DriverRegistroServiziDB(con, this.tipoDB);
  1246.                 DriverConfigurazioneDB driverConfig = new DriverConfigurazioneDB(con, this.tipoDB);
  1247.                 
  1248.                 UtilitiesMappingFruizioneErogazione utilities = new UtilitiesMappingFruizioneErogazione(driverConfig, driverRegistry, log);
  1249.                 if(erogazione){
  1250.                     utilities.initMappingErogazione();
  1251.                 }else{
  1252.                     utilities.initMappingFruizione();
  1253.                 }
  1254.     
  1255.                 log.debug("Controllo Consistenza Dati ["+nomeMetodo+"] terminato");
  1256.             }           
  1257.             
  1258.         } catch (Throwable se) {
  1259.             log.error("Controllo Consistenza Dati ["+nomeMetodo+"] terminato con errore: "+se.getMessage(),se);
  1260.             error = true;
  1261.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1262.         } finally {
  1263.             initMappingErogazione_releaseConnectionGestioneErrore(error, con);
  1264.         }

  1266.     }
  1267.     
  1268.     
  1269.     
  1270.     
  1271.     
  1272.     
  1273.     
  1274.     
  1275.     
  1276.     
  1277.     
  1278.     
  1279.     
  1280.     /* *********** DB UTILS ****************** */
  1281.     
  1282.     public long getTableIdSoggetto(IDSoggetto idSoggetto) throws DriverControlStationException {
  1283.         String nomeMetodo = "getTableIdSoggetto";

  1285.         Connection con = null;

  1287.         con = getConnection(nomeMetodo);

  1289.         this.logDebug("operazione this.atomica = " + this.atomica);

  1291.         try {

  1293.             return DBUtils.getIdSoggetto(idSoggetto.getNome(), idSoggetto.getTipo(), con, this.tipoDB);

  1295.         } catch (Exception se) {
  1296.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1297.         } finally {
  1298.             releaseConnection(con);
  1299.         }

  1301.     }
  1302.     
  1303.     public long getTableIdAccordoServizioParteSpecifica(IDServizio idAccordoServizioParteSpecifica) throws DriverControlStationException {
  1304.         String nomeMetodo = "getTableIdAccordoServizioParteSpecifica";

  1306.         Connection con = null;

  1308.         con = getConnection(nomeMetodo);

  1310.         this.logDebug("operazione this.atomica = " + this.atomica);

  1312.         try {

  1314.             return DBUtils.getIdAccordoServizioParteSpecifica(idAccordoServizioParteSpecifica, con, this.tipoDB);

  1316.         } catch (Exception se) {
  1317.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1318.         } finally {
  1319.             releaseConnection(con);
  1320.         }

  1322.     }
  1323.     
  1324.     public long getTableIdPortaDelegata(IDPortaDelegata idPD) throws DriverControlStationException {
  1325.         String nomeMetodo = "getTableIdPortaDelegata";

  1327.         Connection con = null;

  1329.         con = getConnection(nomeMetodo);

  1331.         this.logDebug("operazione this.atomica = " + this.atomica);

  1333.         try {

  1335.             return DBUtils.getIdPortaDelegata(idPD.getNome(), con, this.tipoDB);

  1337.         } catch (Exception se) {
  1338.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1339.         } finally {
  1340.             releaseConnection(con);
  1341.         }
  1342.         
  1343.     }
  1344.     
  1345.     public long getTableIdPortaApplicativa(IDPortaApplicativa idPA) throws DriverControlStationException {
  1346.         String nomeMetodo = "getTableIdPortaApplicativa";

  1348.         Connection con = null;

  1350.         con = getConnection(nomeMetodo);

  1352.         this.logDebug("operazione this.atomica = " + this.atomica);

  1354.         try {

  1356.             return DBUtils.getIdPortaApplicativa(idPA.getNome(), con, this.tipoDB);

  1358.         } catch (Exception se) {
  1359.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1360.         } finally {
  1361.             releaseConnection(con);
  1362.         }

  1364.     }
  1365.     
  1366.     
  1367.     
  1368.     
  1369.     
  1370.     
  1371.     
  1372.     
  1373.     
  1374.     
  1375.     
  1376.     
  1377.     
  1378.     
  1379.     
  1380.     
  1381.     
  1382.     
  1383.     
  1384.     
  1385.     
  1386.     /* *********** METODI IS IN USO ****************** */

  1388.     public boolean isAccordoInUso(IDAccordo idAccordo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1389.         String nomeMetodo = "isAccordoInUso";

  1391.         Connection con = null;

  1393.         con = getConnection(nomeMetodo);

  1395.         try {
  1396.             return DBOggettiInUsoUtils.isAccordoServizioParteComuneInUso(con, this.tipoDB, idAccordo, whereIsInUso, normalizeObjectIds);

  1398.         } catch (Exception se) {
  1399.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1400.         } finally {
  1401.             releaseConnection(con);
  1402.         }
  1403.         
  1404.     }
  1405.     
  1406.     public boolean isAccordoInUso(AccordoServizioParteComune as, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1407.         String nomeMetodo = "isAccordoInUso";

  1409.         Connection con = null;

  1411.         con = getConnection(nomeMetodo);

  1413.         try {
  1414.             return DBOggettiInUsoUtils.isAccordoServizioParteComuneInUso(con, this.tipoDB, this.idAccordoFactory.getIDAccordoFromAccordo(as), whereIsInUso, normalizeObjectIds);

  1416.         } catch (Exception se) {
  1417.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1418.         } finally {
  1419.             releaseConnection(con);
  1420.         }
  1421.         
  1422.     }
  1423.     
  1424.     public boolean isAccordoCooperazioneInUso(AccordoCooperazione as, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1425.         String nomeMetodo = "isAccordoCooperazioneInUso";

  1427.         Connection con = null;

  1429.         con = getConnection(nomeMetodo);

  1431.         try {
  1432.             return DBOggettiInUsoUtils.isAccordoCooperazioneInUso(con, this.tipoDB, this.idAccordoCooperazioneFactory.getIDAccordoFromAccordo(as), whereIsInUso, normalizeObjectIds);

  1434.         } catch (Exception se) {
  1435.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1436.         } finally {
  1437.             releaseConnection(con);
  1438.         }
  1439.         
  1440.     }

  1442.     public boolean isPddInUso(PdDControlStation pdd, List<String> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1443.         String nomeMetodo = "pddInUso";

  1445.         Connection con = null;
  1446.         
  1447.         con = getConnection(nomeMetodo);

  1449.         try {

  1451.             return DBOggettiInUsoUtils.isPddInUso(con, this.tipoDB, pdd.getNome(), whereIsInUso, normalizeObjectIds);

  1453.         } catch (Exception se) {
  1454.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1455.         } finally {
  1456.             releaseConnection(con);
  1457.         }
  1458.     }

  1460.     public boolean isSoggettoInUso(org.openspcoop2.core.config.Soggetto soggettoConfig, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, 
  1461.             boolean normalizeObjectIds, boolean verificaRuoli) throws DriverControlStationException {
  1462.         return isSoggettoInUso(soggettoConfig,null,whereIsInUso, normalizeObjectIds, verificaRuoli);
  1463.     }
  1464.     public boolean isSoggettoInUso(Soggetto soggettoRegistro, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, 
  1465.             boolean normalizeObjectIds, boolean verificaRuoli) throws DriverControlStationException {
  1466.         return isSoggettoInUso(null,soggettoRegistro,whereIsInUso, normalizeObjectIds, verificaRuoli);
  1467.     }
  1468.     private boolean isSoggettoInUso(org.openspcoop2.core.config.Soggetto soggettoConfig, Soggetto soggettoRegistro, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, 
  1469.             boolean normalizeObjectIds, boolean verificaRuoli) throws DriverControlStationException {
  1470.         String nomeMetodo = "isSoggettoInUso";

  1472.         Connection con = null;
  1473.         con = getConnection(nomeMetodo);

  1475.         this.logDebug("operazione this.atomica = " + this.atomica);

  1477.         try {

  1479.             String tipoSoggetto = null;
  1480.             String nomeSoggetto = null;
  1481.             if(soggettoRegistro!=null){
  1482.                 tipoSoggetto = soggettoRegistro.getTipo();
  1483.                 nomeSoggetto = soggettoRegistro.getNome();
  1484.             }else{
  1485.                 tipoSoggetto = soggettoConfig.getTipo();
  1486.                 nomeSoggetto = soggettoConfig.getNome();
  1487.             }
  1488.             IDSoggetto idSoggetto = new IDSoggetto(tipoSoggetto, nomeSoggetto);
  1489.             
  1490.             if(soggettoRegistro!=null){
  1491.                 
  1492.                 return DBOggettiInUsoUtils.isSoggettoRegistryInUso(con, this.tipoDB, idSoggetto, true, whereIsInUso, normalizeObjectIds, verificaRuoli);
  1493.             
  1494.             }
  1495.             else{
  1496.                 
  1497.                 return DBOggettiInUsoUtils.isSoggettoConfigInUso(con, this.tipoDB, idSoggetto, true, whereIsInUso, normalizeObjectIds, verificaRuoli);
  1498.                 
  1499.             }

  1501.         } catch (Exception se) {
  1502.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1503.         } finally {
  1504.             releaseConnection(con);
  1505.         }
  1506.     }
  1507.     
  1508.     public boolean isRuoloInUso(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1509.         String nomeMetodo = "isRuoloInUso";

  1511.         Connection con = null;
  1512.         con = getConnection(nomeMetodo);

  1514.         this.logDebug("operazione this.atomica = " + this.atomica);

  1516.         try {

  1518.             return DBOggettiInUsoUtils.isRuoloInUso(con, this.tipoDB, idRuolo, whereIsInUso, normalizeObjectIds);
  1519.             
  1520.         } catch (Exception se) {
  1521.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1522.         } finally {
  1523.             releaseConnection(con);
  1524.         }
  1525.     }
  1526.     
  1527.     public boolean isRuoloConfigInUso(IDRuolo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1528.         String nomeMetodo = "isRuoloConfigInUso";

  1530.         Connection con = null;
  1531.         con = getConnection(nomeMetodo);

  1533.         this.logDebug("operazione this.atomica = " + this.atomica);

  1535.         try {

  1537.             return DBOggettiInUsoUtils.isRuoloConfigInUso(con, this.tipoDB, idRuolo, whereIsInUso, normalizeObjectIds);
  1538.             
  1539.         } catch (Exception se) {
  1540.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1541.         } finally {
  1542.             releaseConnection(con);
  1543.         }
  1544.     }

  1546.     
  1547.     public boolean isScopeInUso(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1548.         String nomeMetodo = "isScopeInUso";

  1550.         Connection con = null;
  1551.         con = getConnection(nomeMetodo);

  1553.         this.logDebug("operazione this.atomica = " + this.atomica);

  1555.         try {

  1557.             return DBOggettiInUsoUtils.isScopeInUso(con, this.tipoDB, idScope, whereIsInUso, normalizeObjectIds);
  1558.             
  1559.         } catch (Exception se) {
  1560.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1561.         } finally {
  1562.             releaseConnection(con);
  1563.         }
  1564.     }
  1565.     
  1566.     public boolean isScopeConfigInUso(IDScope idScope, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  1567.         String nomeMetodo = "isScopeConfigInUso";

  1569.         Connection con = null;
  1570.         con = getConnection(nomeMetodo);

  1572.         this.logDebug("operazione this.atomica = " + this.atomica);

  1574.         try {

  1576.             return DBOggettiInUsoUtils.isScopeConfigInUso(con, this.tipoDB, idScope, whereIsInUso, normalizeObjectIds);
  1577.             
  1578.         } catch (Exception se) {
  1579.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1580.         } finally {
  1581.             releaseConnection(con);
  1582.         }
  1583.     }
  1584.     
  1585.     
  1586.     
  1587.     
  1588.     
  1589.     
  1590.     
  1591.     
  1592.     
  1593.     
  1594.     
  1595.     
  1596.     /* *********** METODI EXISTS ****************** */
  1597.     
  1598.     public long existServizio(String nomeServizio, String tipoServizio, int versioneServizio, long idSoggettoErogatore) throws DriverControlStationException {
  1599.         String nomeMetodo = "existServizio";
  1600.         
  1601.         Connection con = null;
  1602.         PreparedStatement stmt = null;
  1603.         ResultSet risultato = null;
  1604.         String queryString;
  1605.         
  1606.         con = getConnection(nomeMetodo);        
  1607.         try {
  1608.         
  1609.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  1610.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1611.             sqlQueryObject.addSelectField("*");
  1612.             sqlQueryObject.addWhereCondition("id_soggetto = ?");
  1613.             sqlQueryObject.addWhereCondition("nome_servizio = ?");
  1614.             sqlQueryObject.addWhereCondition("tipo_servizio = ?");
  1615.             sqlQueryObject.addWhereCondition("versione_servizio = ?");
  1616.             sqlQueryObject.setANDLogicOperator(true);
  1617.             queryString = sqlQueryObject.createSQLQuery();
  1618.         
  1619.             stmt = con.prepareStatement(queryString);
  1620.             stmt.setLong(1, idSoggettoErogatore);
  1621.             stmt.setString(2, nomeServizio);
  1622.             stmt.setString(3, tipoServizio);
  1623.             stmt.setInt(4, versioneServizio);
  1624.         
  1625.             risultato = stmt.executeQuery();
  1626.             if (risultato.next()) {
  1627.                 return risultato.getLong("id");
  1628.             }
  1629.         
  1630.             return 0;
  1631.         } catch (Exception se) {
  1632.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1633.         } finally {
  1634.             // Chiudo statement and resultset
  1635.             try {
  1636.                 if (risultato != null) {
  1637.                     risultato.close();
  1638.                 }
  1639.             } catch (Exception e) {
  1640.                 // ignore
  1641.             }
  1642.             try {
  1643.                 if (stmt != null) {
  1644.                     stmt.close();
  1645.                 }
  1646.             } catch (Exception e) {
  1647.                 // ignore
  1648.             }
  1649.             releaseConnection(con);
  1650.         }
  1651.     }

  1653.     
  1654.     public long existPdd(String nomePdd) throws DriverControlStationException {
  1655.         String nomeMetodo = "existPdd";

  1657.         Connection con = null;
  1658.         PreparedStatement stmt = null;
  1659.         ResultSet risultato = null;
  1660.         String queryString = "";

  1662.         con = getConnection(nomeMetodo);

  1664.         try {

  1666.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDB);
  1667.             sqlQueryObject.addFromTable(CostantiDB.PDD);
  1668.             sqlQueryObject.addSelectField("*");
  1669.             sqlQueryObject.addWhereCondition("nome = ?");
  1670.             queryString = sqlQueryObject.createSQLQuery();

  1672.             stmt = con.prepareStatement(queryString);
  1673.             stmt.setString(1, nomePdd);
  1674.             risultato = stmt.executeQuery();
  1675.             if (risultato.next()) {
  1676.                 return risultato.getLong("id");
  1677.             }

  1679.             return 0;
  1680.         } catch (Exception se) {
  1681.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1682.         } finally {
  1683.             // Chiudo statement and resultset
  1684.             try {
  1685.                 if (risultato != null) {
  1686.                     risultato.close();
  1687.                 }
  1688.             } catch (Exception e) {
  1689.                 // ignore
  1690.             }
  1691.             try {
  1692.                 if (stmt != null) {
  1693.                     stmt.close();
  1694.                 }
  1695.             } catch (Exception e) {
  1696.                 // ignore
  1697.             }
  1698.             releaseConnection(con);
  1699.         }
  1700.     }
  1701.     

  1703.     // Controllo Traffico
  1704.         
  1705.     /**
  1706.      * Restituisce la configurazione generale
  1707.      * 
  1708.      * @return Configurazione
  1709.      * 
  1710.      */
  1711.     public ConfigurazioneGenerale getConfigurazioneControlloTraffico() throws DriverControlStationException,DriverControlStationNotFound {
  1712.         String nomeMetodo = "getConfigurazioneControlloTraffico";
  1713.         // ritorna la configurazione controllo del traffico della PdD
  1714.         Connection con = null;

  1716.         con = getConnection(nomeMetodo);

  1718.         this.logDebug("operazione this.atomica = " + this.atomica);
  1719.         ConfigurazioneGenerale config = null;
  1720.         try {
  1721.             config = ControlloTrafficoDriverUtils.getConfigurazioneControlloTraffico(con, this.log, this.tipoDB);
  1722.         }catch (Exception se) {
  1723.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1724.         } finally {
  1725.             releaseConnection(con);
  1726.         }

  1728.         return config;
  1729.     }

  1731.     /***
  1732.      * Aggiorna la configurazione del controllo del traffico
  1733.      * 
  1734.      * @param configurazioneControlloTraffico
  1735.      * @throws DriverControlStationException
  1736.      */
  1737.     public void updateConfigurazioneControlloTraffico(ConfigurazioneGenerale configurazioneControlloTraffico) throws DriverControlStationException {
  1738.         String nomeMetodo = "updateConfigurazioneControlloTraffico";
  1739.         Connection con = null;
  1740.         con = getConnection(nomeMetodo);

  1742.         this.logDebug("operazione this.atomica = " + this.atomica);

  1744.         try {
  1745.             ControlloTrafficoDriverUtils.updateConfigurazioneControlloTraffico(configurazioneControlloTraffico, con, this.log, this.tipoDB);
  1746.         } catch (Exception se) {
  1747.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1748.         } finally {
  1749.             releaseConnection(con);
  1750.         }
  1751.     }
  1752.     
  1753.     public List<Proprieta> getProprietaRateLimiting() throws DriverControlStationException,DriverControlStationNotFound {
  1754.         String nomeMetodo = "getProprietaRateLimiting";
  1755.         // ritorna la configurazione controllo del traffico della PdD
  1756.         Connection con = null;

  1758.         con = getConnection(nomeMetodo);

  1760.         this.logDebug("operazione this.atomica = " + this.atomica);
  1761.         List<Proprieta> l = null;
  1762.         try {
  1763.             l = ControlloTrafficoDriverUtils.getProprietaRateLimiting(con, this.log, this.tipoDB);
  1764.         }catch (Exception se) {
  1765.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1766.         } finally {
  1767.             releaseConnection(con);
  1768.         }

  1770.         return l;
  1771.     }
  1772.     
  1773.     /**
  1774.      * Restituisce il numero di Configurazione Policy
  1775.      * 
  1776.      * @return Configurazione
  1777.      * 
  1778.      */
  1779.     public long countConfigurazioneControlloTrafficoConfigurazionePolicy(ISearch ricerca) throws DriverControlStationException {
  1780.         String nomeMetodo = "countConfigurazioneControlloTrafficoConfigurazionePolicy";
  1781.         Connection con = null;
  1782.         
  1783.         con = getConnection(nomeMetodo);

  1785.         this.logDebug("operazione this.atomica = " + this.atomica);
  1786.         long count = 0;
  1787.         try {
  1788.             count = ControlloTrafficoDriverUtils.countConfigurazioneControlloTrafficoConfigurazionePolicy(ricerca, con, this.log, this.tipoDB);
  1789.         }catch (Exception se) {
  1790.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1791.         } finally {
  1792.             releaseConnection(con);
  1793.         }

  1795.         return count;
  1796.     }
  1797.     
  1798.     /**
  1799.      * Restituisce il numero di Attivazione Policy
  1800.      * 
  1801.      * @return Configurazione
  1802.      * 
  1803.      */
  1804.     public long countConfigurazioneControlloTrafficoAttivazionePolicy(ISearch ricerca, RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException {
  1805.         String nomeMetodo = "countConfigurazioneControlloTrafficoAttivazionePolicy";
  1806.         // ritorna la configurazione controllo del traffico della PdD
  1807.         Connection con = null;
  1808.         
  1809.         con = getConnection(nomeMetodo);

  1811.         this.logDebug("operazione this.atomica = " + this.atomica);
  1812.         long count = 0;
  1813.         try {
  1814.             count = ControlloTrafficoDriverUtils.countConfigurazioneControlloTrafficoAttivazionePolicy(ricerca, ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  1815.         }catch (Exception se) {
  1816.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  1817.         } finally {
  1818.             releaseConnection(con);
  1819.         }

  1821.         return count;
  1822.     }

  1824.     public List<ConfigurazionePolicy> configurazioneControlloTrafficoConfigurazionePolicyList(ConsoleSearch ricerca) throws DriverControlStationException{
  1825.         String nomeMetodo = "configurazioneControlloTrafficoConfigurazionePolicyList";
  1826.         // ritorna la configurazione controllo del traffico della PdD
  1827.         Connection con = null;
  1828.         
  1829.         con = getConnection(nomeMetodo);

  1831.         this.logDebug("operazione this.atomica = " + this.atomica);
  1832.         List<ConfigurazionePolicy> listaPolicy = new ArrayList<ConfigurazionePolicy>();
  1833.         
  1834.         try {
  1835.             listaPolicy = ControlloTrafficoDriverUtils.configurazioneControlloTrafficoConfigurazionePolicyList(ricerca, con, this.log, this.tipoDB);                
  1836.         } catch (Exception qe) {
  1837.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  1838.         } finally {
  1839.             releaseConnection(con);
  1840.         }
  1841.         
  1842.         return listaPolicy;
  1843.     }
  1844.     
  1845.     public List<ConfigurazionePolicy> configurazioneControlloTrafficoConfigurazionePolicyList_conApplicabilitaAllarme(String idAllarme) throws DriverControlStationException{
  1846.         
  1847.         String nomeMetodo = "configurazioneControlloTrafficoConfigurazionePolicyList_conApplicabilitaAllarme";
  1848.         // ritorna la configurazione controllo del traffico della PdD
  1849.         Connection con = null;
  1850.         
  1851.         con = getConnection(nomeMetodo);

  1853.         this.logDebug("operazione this.atomica = " + this.atomica);
  1854.         List<ConfigurazionePolicy> listaPolicy = new ArrayList<ConfigurazionePolicy>();
  1855.         
  1856.         try {
  1857.             listaPolicy = ControlloTrafficoDriverUtils.configurazioneControlloTrafficoConfigurazionePolicyList_conApplicabilitaAllarme(idAllarme, con, this.log, this.tipoDB);              
  1858.         } catch (Exception qe) {
  1859.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  1860.         } finally {
  1861.             releaseConnection(con);
  1862.         }
  1863.         
  1864.         return listaPolicy;
  1865.     }

  1867.     public void updatePosizioneAttivazionePolicy(InfoPolicy infoPolicy, AttivazionePolicy policy,
  1868.             RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException{
  1869.         String nomeMetodo = "updatePosizioneAttivazionePolicy";
  1870.         // ritorna la configurazione controllo del traffico della PdD
  1871.         Connection con = null;
  1872.         
  1873.         con = getConnection(nomeMetodo);

  1875.         this.logDebug("operazione this.atomica = " + this.atomica);
  1876.         
  1877.         try {
  1878.             ControlloTrafficoDriverUtils.updatePosizioneAttivazionePolicy(infoPolicy, policy,
  1879.                     ruoloPorta, nomePorta, 
  1880.                     con, this.log, this.tipoDB);    
  1881.         } catch (Exception qe) {
  1882.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  1883.         } finally {
  1884.             releaseConnection(con);
  1885.         }
  1886.         
  1887.     }
  1888.     
  1889.     @SuppressWarnings("unchecked")
  1890.     public List<AttivazionePolicy> configurazioneControlloTrafficoAttivazionePolicyList(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException{
  1891.         return (List<AttivazionePolicy>) this._configurazioneControlloTrafficoAttivazionePolicyList(ricerca, ruoloPorta, nomePorta, 
  1892.                 false, "configurazioneControlloTrafficoAttivazionePolicyList",
  1893.                 null, null, null,
  1894.                 null, null,
  1895.                 null, null);
  1896.     }
  1897.     @SuppressWarnings("unchecked")
  1898.     public List<AttivazionePolicy> configurazioneControlloTrafficoAttivazionePolicyListByFilter(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta,
  1899.             IDSoggetto filtroSoggettoFruitore, IDServizioApplicativo filtroApplicativoFruitore,String filtroRuoloFruitore,
  1900.             IDSoggetto filtroSoggettoErogatore, String filtroRuoloErogatore,
  1901.             IDServizio filtroServizioAzione, String filtroRuolo) throws DriverControlStationException{
  1902.         return (List<AttivazionePolicy>) this._configurazioneControlloTrafficoAttivazionePolicyList(ricerca, ruoloPorta, nomePorta, 
  1903.                 false, "configurazioneControlloTrafficoAttivazionePolicyListByFilter",
  1904.                 filtroSoggettoFruitore, filtroApplicativoFruitore, filtroRuoloFruitore,
  1905.                 filtroSoggettoErogatore, filtroRuoloErogatore,
  1906.                 filtroServizioAzione, filtroRuolo);
  1907.     }
  1908.     @SuppressWarnings("unchecked")
  1909.     public List<TipoRisorsaPolicyAttiva> configurazioneControlloTrafficoAttivazionePolicyTipoRisorsaList(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException{
  1910.         return (List<TipoRisorsaPolicyAttiva>) this._configurazioneControlloTrafficoAttivazionePolicyList(ricerca, ruoloPorta, nomePorta, 
  1911.                 true, "configurazioneControlloTrafficoAttivazionePolicyTipoRisorsaList",
  1912.                 null, null, null,
  1913.                 null, null,
  1914.                 null, null);
  1915.     }
  1916.     @SuppressWarnings("unchecked")
  1917.     private Object _configurazioneControlloTrafficoAttivazionePolicyList(ConsoleSearch ricerca, RuoloPolicy ruoloPorta, String nomePorta, boolean tipoRisorsa, String nomeMetodo,
  1918.             IDSoggetto filtroSoggettoFruitore, IDServizioApplicativo filtroApplicativoFruitore,String filtroRuoloFruitore,
  1919.             IDSoggetto filtroSoggettoErogatore, String filtroRuoloErogatore,
  1920.             IDServizio filtroServizioAzione, String filtroRuolo) throws DriverControlStationException{
  1921.         // ritorna la configurazione controllo del traffico della PdD
  1922.         Connection con = null;
  1923.         
  1924.         con = getConnection(nomeMetodo);

  1926.         this.logDebug("operazione this.atomica = " + this.atomica);
  1927.         List<AttivazionePolicy> listaPolicy = null;
  1928.         List<TipoRisorsaPolicyAttiva> listaTipoRisorsa = null;
  1929.         
  1930.         try {
  1931.         
  1932.             Object o = ControlloTrafficoDriverUtils._configurazioneControlloTrafficoAttivazionePolicyList(ricerca, ruoloPorta, nomePorta, 
  1933.                     con, this.log, this.tipoDB,
  1934.                     tipoRisorsa, nomeMetodo, 
  1935.                     filtroSoggettoFruitore, filtroApplicativoFruitore, filtroRuoloFruitore,
  1936.                     filtroSoggettoErogatore, filtroRuoloErogatore,
  1937.                     filtroServizioAzione, filtroRuolo);
  1938.             
  1939.             if(tipoRisorsa) {
  1940.                 listaTipoRisorsa = (List<TipoRisorsaPolicyAttiva>) o;
  1941.             }
  1942.             else {
  1943.                 listaPolicy = (List<AttivazionePolicy>) o;
  1944.             }
  1945.                         
  1946.         } catch (Exception qe) {
  1947.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  1948.         } finally {
  1949.             releaseConnection(con);
  1950.         }
  1951.         
  1952.         if(tipoRisorsa) {
  1953.             return listaTipoRisorsa;
  1954.         }
  1955.         else {
  1956.             return listaPolicy;
  1957.         }
  1958.     }
  1959.     
  1960.     public AttivazionePolicy getAttivazionePolicy(String alias, RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException, NotFoundException{
  1961.         String nomeMetodo = "configurazioneControlloTrafficoAttivazionePolicyList";
  1962.         // ritorna la configurazione controllo del traffico della PdD
  1963.         Connection con = null;

  1965.         con = getConnection(nomeMetodo);

  1967.         this.logDebug("operazione this.atomica = " + this.atomica);
  1968.         AttivazionePolicy policy = null;
  1969.         
  1970.         try {
  1971.             policy = ControlloTrafficoDriverUtils.getAttivazionePolicy(alias, ruoloPorta, nomePorta, con, this.log, this.tipoDB);           
  1972.         } catch(NotFoundException notFound) {
  1973.             throw notFound;
  1974.         } 
  1975.         catch (Exception qe) {
  1976.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  1977.         } finally {
  1978.             releaseConnection(con);
  1979.         }
  1980.         
  1981.         return policy;
  1982.     }
  1983.     
  1984.     
  1985.     public List<InfoPolicy> getInfoPolicyList(Boolean builtIn, String idPolicyParam) throws DriverControlStationException{
  1986.         String nomeMetodo = "getInfoPolicyList";
  1987.         // ritorna la configurazione controllo del traffico della PdD
  1988.         Connection con = null;
  1989.         
  1990.         con = getConnection(nomeMetodo);

  1992.         this.logDebug("operazione this.atomica = " + this.atomica);
  1993.         List<InfoPolicy> listaPolicy = new ArrayList<InfoPolicy>();
  1994.         
  1995.         try {
  1996.             listaPolicy = ControlloTrafficoDriverUtils.getInfoPolicyList(builtIn, idPolicyParam, con, this.log, this.tipoDB);           
  1997.         } catch (Exception qe) {
  1998.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  1999.         } finally {
  2000.             releaseConnection(con);
  2001.         }
  2002.         
  2003.         return listaPolicy;
  2004.     }
  2005.     
  2006.     public List<AttivazionePolicy> findInUseAttivazioni(String idPolicy, boolean escludiDisabilitate) throws DriverControlStationException{
  2007.         String nomeMetodo = "findInUseAttivazioni";
  2008.         // ritorna la configurazione controllo del traffico della PdD
  2009.         Connection con = null;
  2010.         
  2011.         con = getConnection(nomeMetodo);

  2013.         this.logDebug("operazione this.atomica = " + this.atomica);
  2014.         List<AttivazionePolicy> listaPolicy = new ArrayList<AttivazionePolicy>();
  2015.         
  2016.         try {
  2017.             listaPolicy = ControlloTrafficoDriverUtils.findInUseAttivazioni(idPolicy, escludiDisabilitate, con, this.log, this.tipoDB);
  2018.         } catch (Exception qe) {
  2019.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2020.         } finally {
  2021.             releaseConnection(con);
  2022.         }
  2023.         
  2024.         return listaPolicy;
  2025.     }
  2026.     
  2027.     public long countInUseAttivazioni(String idPolicy, boolean escludiDisabilitate) throws DriverControlStationException{
  2028.         String nomeMetodo = "countInUseAttivazioni";
  2029.         // ritorna la configurazione controllo del traffico della PdD
  2030.         Connection con = null;

  2032.         con = getConnection(nomeMetodo);

  2034.         this.logDebug("operazione this.atomica = " + this.atomica);
  2035.         try {
  2036.             return ControlloTrafficoDriverUtils.countInUseAttivazioni(idPolicy, escludiDisabilitate, con, this.log, this.tipoDB);
  2037.         } catch (Exception qe) {
  2038.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2039.         } finally {
  2040.             releaseConnection(con);
  2041.         }
  2042.     }
  2043.     
  2044.     public ConfigurazionePolicy getConfigurazionePolicy(long id) throws DriverControlStationException,DriverControlStationNotFound{
  2045.         String nomeMetodo = "getConfigurazionePolicy";
  2046.         Connection con = null;
  2047.         con = getConnection(nomeMetodo);

  2049.         this.logDebug("operazione this.atomica = " + this.atomica);
  2050.         ConfigurazionePolicy policy = null;
  2051.         
  2052.         try {
  2053.             policy = ControlloTrafficoDriverUtils.getConfigurazionePolicy(id, con, this.log, this.tipoDB);
  2054.         }catch (NotFoundException e) {
  2055.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Configurazione Policy non presente.");
  2056.         } catch (Exception qe) {
  2057.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2058.         } finally {
  2059.             releaseConnection(con);
  2060.         }
  2061.         
  2062.         return policy;
  2063.     }
  2064.     
  2065.     public ConfigurazionePolicy getConfigurazionePolicy(String nomePolicy) throws DriverControlStationException,DriverControlStationNotFound{
  2066.         String nomeMetodo = "getConfigurazionePolicy";
  2067.         Connection con = null;
  2068.         con = getConnection(nomeMetodo);

  2070.         this.logDebug("operazione this.atomica = " + this.atomica);
  2071.         ConfigurazionePolicy policy = null;
  2072.         
  2073.         try {
  2074.             policy = ControlloTrafficoDriverUtils.getConfigurazionePolicy(nomePolicy, con, this.log, this.tipoDB);
  2075.         }catch (NotFoundException e) {
  2076.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Configurazione Policy non presente.");
  2077.         } catch (Exception qe) {
  2078.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2079.         } finally {
  2080.             releaseConnection(con);
  2081.         }
  2082.         
  2083.         return policy;
  2084.     }

  2086.     public void createConfigurazionePolicy(ConfigurazionePolicy policy) throws DriverControlStationException{
  2087.         String nomeMetodo = "createConfigurazionePolicy";
  2088.         Connection con = null;
  2089.         con = getConnection(nomeMetodo);

  2091.         this.logDebug("operazione this.atomica = " + this.atomica);
  2092.         try {
  2093.             ControlloTrafficoDriverUtils.createConfigurazionePolicy(policy, con, this.log, this.tipoDB);
  2094.         } catch (Exception qe) {
  2095.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2096.         } finally {
  2097.             releaseConnection(con);
  2098.         }   
  2099.     }

  2101.     public void createAttivazionePolicy(AttivazionePolicy policy) throws DriverControlStationException {
  2102.         String nomeMetodo = "createAttivazionePolicy";
  2103.         Connection con = null;
  2104.         con = getConnection(nomeMetodo);

  2106.         this.logDebug("operazione this.atomica = " + this.atomica);
  2107.         try {
  2108.             ControlloTrafficoDriverUtils.createAttivazionePolicy(policy, con, this.log, this.tipoDB);       
  2109.         } catch (Exception qe) {
  2110.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2111.         } finally {
  2112.             releaseConnection(con);
  2113.         }   
  2114.     }

  2116.     public void updateConfigurazionePolicy(ConfigurazionePolicy policy)throws DriverControlStationException,DriverControlStationNotFound{
  2117.         String nomeMetodo = "updateConfigurazionePolicy";
  2118.         Connection con = null;
  2119.         con = getConnection(nomeMetodo);

  2121.         this.logDebug("operazione this.atomica = " + this.atomica);
  2122.         try {
  2123.             ControlloTrafficoDriverUtils.updateConfigurazionePolicy(policy, con, this.log, this.tipoDB);
  2124.         }catch (NotFoundException e) {
  2125.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Configurazione Policy non presente.");
  2126.         } catch (Exception qe) {
  2127.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2128.         } finally {
  2129.             releaseConnection(con);
  2130.         }   
  2131.     }

  2133.     public void updateAttivazionePolicy(AttivazionePolicy policy) throws DriverControlStationException,DriverControlStationNotFound{
  2134.         String nomeMetodo = "updateAttivazionePolicy";
  2135.         Connection con = null;
  2136.         con = getConnection(nomeMetodo);

  2138.         this.logDebug("operazione this.atomica = " + this.atomica);
  2139.         try {
  2140.             ControlloTrafficoDriverUtils.updateAttivazionePolicy(policy, con, this.log, this.tipoDB);
  2141.         }catch (NotFoundException e) {
  2142.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Configurazione Policy non presente.");
  2143.         } catch (Exception qe) {
  2144.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2145.         } finally {
  2146.             releaseConnection(con);
  2147.         }   
  2148.     }

  2150.     public void deleteConfigurazionePolicy(ConfigurazionePolicy policy) throws DriverControlStationException {
  2151.         String nomeMetodo = "deleteConfigurazionePolicy";
  2152.         Connection con = null;
  2153.         con = getConnection(nomeMetodo);

  2155.         this.logDebug("operazione this.atomica = " + this.atomica);
  2156.         try {
  2157.             ControlloTrafficoDriverUtils.deleteConfigurazionePolicy(policy, con, this.log, this.tipoDB);            
  2158.         } catch (Exception qe) {
  2159.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2160.         } finally {
  2161.             releaseConnection(con);
  2162.         }
  2163.     }

  2165.     public void deleteAttivazionePolicy(AttivazionePolicy policy) throws DriverControlStationException,DriverControlStationNotFound{
  2166.         String nomeMetodo = "deleteAttivazionePolicy";
  2167.         Connection con = null;
  2168.         con = getConnection(nomeMetodo);

  2170.         this.logDebug("operazione this.atomica = " + this.atomica);
  2171.         try {
  2172.             ControlloTrafficoDriverUtils.deleteAttivazionePolicy(policy, con, this.log, this.tipoDB);
  2173.         } catch (Exception qe) {
  2174.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2175.         } finally {
  2176.             releaseConnection(con);
  2177.         }
  2178.     }
  2179.     
  2180.     public AttivazionePolicy getAttivazionePolicy(long id) throws DriverControlStationException,DriverControlStationNotFound{
  2181.         String nomeMetodo = "getAttivazionePolicy"; 
  2182.         Connection con = null;
  2183.         con = getConnection(nomeMetodo);

  2185.         this.logDebug("operazione this.atomica = " + this.atomica);
  2186.         AttivazionePolicy policy = null;
  2187.         
  2188.         try {
  2189.             policy = ControlloTrafficoDriverUtils.getAttivazionePolicy(id, con, this.log, this.tipoDB);
  2190.         }catch (NotFoundException e) {
  2191.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Configurazione Policy non presente.");
  2192.         } catch (Exception qe) {
  2193.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2194.         } finally {
  2195.             releaseConnection(con);
  2196.         }
  2197.         
  2198.         return policy;
  2199.     }
  2200.     
  2201.     public AttivazionePolicy getAttivazionePolicy(String nomePolicy) throws DriverControlStationException,DriverControlStationNotFound{
  2202.         String nomeMetodo = "getAttivazionePolicy"; 
  2203.         Connection con = null;
  2204.         con = getConnection(nomeMetodo);

  2206.         this.logDebug("operazione this.atomica = " + this.atomica);
  2207.         AttivazionePolicy policy = null;
  2208.         
  2209.         try {
  2210.             policy = ControlloTrafficoDriverUtils.getAttivazionePolicy(nomePolicy, con, this.log, this.tipoDB);
  2211.         }catch (NotFoundException e) {
  2212.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Configurazione Policy non presente.");
  2213.         } catch (Exception qe) {
  2214.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2215.         } finally {
  2216.             releaseConnection(con);
  2217.         }
  2218.         
  2219.         return policy;
  2220.     }
  2221.     
  2222.     public String getNextPolicyInstanceSerialId(String policyId) throws DriverControlStationException{
  2223.         String nomeMetodo = "getNextPolicyInstanceSerialId"; 
  2224.         Connection con = null;
  2225.         con = getConnection(nomeMetodo);

  2227.         this.logDebug("operazione this.atomica = " + this.atomica);
  2228.         
  2229.         try{
  2230.             return ControlloTrafficoDriverUtils.getNextPolicyInstanceSerialId(policyId, con, this.log, this.tipoDB);        
  2231.         } catch (Exception qe) {
  2232.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2233.         } finally {
  2234.             releaseConnection(con);
  2235.         }
  2236.     }
  2237.     
  2238.     public AttivazionePolicy getPolicy(String policyId, AttivazionePolicyFiltro filtroParam, AttivazionePolicyRaggruppamento groupBy,
  2239.             RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException,DriverControlStationNotFound{
  2240.         String nomeMetodo = "getPolicy"; 
  2241.         Connection con = null;
  2242.         con = getConnection(nomeMetodo);

  2244.         this.logDebug("operazione this.atomica = " + this.atomica);
  2245.         try{
  2246.             return ControlloTrafficoDriverUtils.getPolicy(policyId, filtroParam, groupBy,
  2247.                     ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  2248.         }catch (NotFoundException e) {
  2249.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Attivazione Policy non presente.");    
  2250.         } catch (Exception qe) {
  2251.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2252.         } finally {
  2253.             releaseConnection(con);
  2254.         }
  2255.     }
  2256.     
  2257.     public AttivazionePolicy getPolicyByAlias(String alias,
  2258.             RuoloPolicy ruoloPorta, String nomePorta) throws DriverControlStationException,DriverControlStationNotFound{
  2259.         String nomeMetodo = "getPolicyByAlias"; 
  2260.         Connection con = null;
  2261.         con = getConnection(nomeMetodo);

  2263.         this.logDebug("operazione this.atomica = " + this.atomica);
  2264.         try{
  2265.             return ControlloTrafficoDriverUtils.getPolicyByAlias(alias,
  2266.                     ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  2267.         }catch (NotFoundException e) {
  2268.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Attivazione Policy non presente.");
  2269.         } catch (Exception qe) {
  2270.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2271.         } finally {
  2272.             releaseConnection(con);
  2273.         }
  2274.     }
  2275.     
  2276.     public List<AttivazionePolicy> getPolicyByServizioApplicativo(IDServizioApplicativo idServizioApplicativo) throws DriverControlStationException,DriverControlStationNotFound{
  2277.         String nomeMetodo = "getPolicyByServizioApplicativo"; 
  2278.         Connection con = null;
  2279.         con = getConnection(nomeMetodo);

  2281.         this.logDebug("operazione this.atomica = " + this.atomica);
  2282.         try{
  2283.             return ControlloTrafficoDriverUtils.getPolicyByServizioApplicativo(idServizioApplicativo, con, this.log, this.tipoDB);
  2284.         }catch (NotFoundException e) {
  2285.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Attivazione Policy non presente.");
  2286.         } catch (Exception qe) {
  2287.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2288.         } finally {
  2289.             releaseConnection(con);
  2290.         }
  2291.     }
  2292.     
  2293.     public boolean usedInConfigurazioneControlloTrafficoAttivazionePolicy(RuoloPolicy ruoloPorta, String nomePorta, String azione) throws DriverControlStationException{
  2294.         String nomeMetodo = "usedInConfigurazioneControlloTrafficoAttivazionePolicy";
  2295.         // ritorna la configurazione controllo del traffico della PdD
  2296.         Connection con = null;
  2297.         
  2298.         con = getConnection(nomeMetodo);

  2300.         this.logDebug("operazione this.atomica = " + this.atomica);
  2301.         
  2302.         try {
  2303.             return ControlloTrafficoDriverUtils.usedInConfigurazioneControlloTrafficoAttivazionePolicy(ruoloPorta, nomePorta, azione, con, this.log, this.tipoDB);          
  2304.         } catch (Exception qe) {
  2305.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2306.         } finally {
  2307.             releaseConnection(con);
  2308.         }
  2309.         
  2310.     }
  2311.     
  2312.     public List<IDSoggetto> getSoggettiErogatori(String protocolloSelezionato,List<String> protocolliSupportati) throws DriverControlStationException{
  2313.         String nomeMetodo = "getSoggettiErogatori"; 
  2314.         Connection con = null;
  2315.         con = getConnection(nomeMetodo);

  2317.         this.logDebug("operazione this.atomica = " + this.atomica);
  2318.         
  2319.         try{
  2320.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con); 
  2321.             
  2322.             if(protocolloSelezionato!=null) {
  2323.                 return RegistroCore.getSoggettiErogatori(serviceManager, protocolloSelezionato);
  2324.             }
  2325.             else {
  2326.                 return RegistroCore.getSoggettiErogatori(serviceManager, protocolliSupportati);
  2327.             }
  2328.         }catch (Exception qe) {
  2329.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2330.         } finally {
  2331.             releaseConnection(con);
  2332.         }
  2333.     }
  2334.     public List<IDServizio> getServizi(String protocolloSelezionato,List<String> protocolliSupportati, 
  2335.             String tipoErogatore, String nomeErogatore, String tag) throws DriverControlStationException{
  2336.         String nomeMetodo = "getServizi"; 
  2337.         Connection con = null;
  2338.         con = getConnection(nomeMetodo);

  2340.         this.logDebug("operazione this.atomica = " + this.atomica);
  2341.         try{
  2342.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2343.             if(protocolloSelezionato!=null) {
  2344.                 return RegistroCore.getServizi(serviceManager, protocolloSelezionato, tipoErogatore, nomeErogatore, tag);
  2345.             }
  2346.             else{
  2347.                 return RegistroCore.getServizi(serviceManager, protocolliSupportati, tipoErogatore, nomeErogatore, tag);
  2348.             }
  2349.         }catch (Exception qe) {
  2350.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2351.         } finally {
  2352.             releaseConnection(con);
  2353.         }
  2354.     }
  2355.     public List<IDServizio> getServizi(String protocolloSelezionato,List<String> protocolliSupportati, 
  2356.             String tipoServizio, String nomeServizio, Integer versioneServizio, String tag) throws DriverControlStationException{
  2357.         String nomeMetodo = "getServizi"; 
  2358.         Connection con = null;
  2359.         con = getConnection(nomeMetodo);

  2361.         this.logDebug("operazione this.atomica = " + this.atomica);
  2362.         try{
  2363.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2364.             if(protocolloSelezionato!=null) {
  2365.                 return RegistroCore.getServizi(serviceManager, protocolloSelezionato, tipoServizio, nomeServizio, versioneServizio, tag);
  2366.             }
  2367.             else{
  2368.                 return RegistroCore.getServizi(serviceManager, protocolliSupportati, tipoServizio, nomeServizio, versioneServizio, tag);
  2369.             }
  2370.         }catch (Exception qe) {
  2371.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2372.         } finally {
  2373.             releaseConnection(con);
  2374.         }
  2375.     }
  2376.     public List<String> getAzioni(String protocolloSelezionato,List<String> protocolliSupportati, 
  2377.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverControlStationException{
  2378.         String nomeMetodo = "getAzioni"; 
  2379.         Connection con = null;
  2380.         con = getConnection(nomeMetodo);

  2382.         this.logDebug("operazione this.atomica = " + this.atomica);
  2383.         try{
  2384.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2385.             if(protocolloSelezionato!=null) {
  2386.                 return RegistroCore.getAzioni(serviceManager, protocolloSelezionato, 
  2387.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio);
  2388.             }
  2389.             else {
  2390.                 return RegistroCore.getAzioni(serviceManager, protocolliSupportati, 
  2391.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio);
  2392.             }
  2393.         }catch (Exception qe) {
  2394.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2395.         } finally {
  2396.             releaseConnection(con);
  2397.         }
  2398.     }
  2399.     public List<IDServizioApplicativo> getServiziApplicativiErogatori(String protocolloSelezionato,List<String> protocolliSupportati, 
  2400.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio, 
  2401.             String azione) throws DriverControlStationException {
  2402.         String nomeMetodo = "getServiziApplicativiErogatori"; 
  2403.         Connection con = null;
  2404.         con = getConnection(nomeMetodo);

  2406.         this.logDebug("operazione this.atomica = " + this.atomica);
  2407.         try{
  2408.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2409.             if(protocolloSelezionato!=null) {
  2410.                 return RegistroCore.getServiziApplicativiErogatori(serviceManager, protocolloSelezionato, 
  2411.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, 
  2412.                         azione);
  2413.             }
  2414.             else {
  2415.                 return RegistroCore.getServiziApplicativiErogatori(serviceManager, protocolliSupportati, 
  2416.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, 
  2417.                         azione);
  2418.             }
  2419.         }catch (Exception qe) {
  2420.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2421.         } finally {
  2422.             releaseConnection(con);
  2423.         }
  2424.     }
  2425.     public List<IDSoggetto> getSoggetti(String protocolloSelezionato,List<String> protocolliSupportati) throws DriverControlStationException{
  2426.         String nomeMetodo = "getSoggetti"; 
  2427.         Connection con = null;
  2428.         con = getConnection(nomeMetodo);

  2430.         this.logDebug("operazione this.atomica = " + this.atomica);
  2431.         try{
  2432.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2433.             if(protocolloSelezionato!=null) {
  2434.                 return RegistroCore.getSoggetti(serviceManager, protocolloSelezionato);
  2435.             }
  2436.             else {
  2437.                 return RegistroCore.getSoggetti(serviceManager, protocolliSupportati);
  2438.             }
  2439.         }catch (Exception qe) {
  2440.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2441.         } finally {
  2442.             releaseConnection(con);
  2443.         }
  2444.     }
  2445.     public List<IDSoggetto> getSoggettiFruitori(String protocolloSelezionato,List<String> protocolliSupportati, 
  2446.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio) throws DriverControlStationException{
  2447.         String nomeMetodo = "getSoggettiFruitori"; 
  2448.         Connection con = null;
  2449.         con = getConnection(nomeMetodo);

  2451.         this.logDebug("operazione this.atomica = " + this.atomica);
  2452.         try{
  2453.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2454.             if(protocolloSelezionato!=null) {
  2455.                 return RegistroCore.getSoggettiFruitori(serviceManager, protocolloSelezionato, 
  2456.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio);
  2457.             }
  2458.             else {
  2459.                 return RegistroCore.getSoggettiFruitori(serviceManager, protocolliSupportati, 
  2460.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio);
  2461.             }
  2462.         }catch (Exception qe) {
  2463.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2464.         } finally {
  2465.             releaseConnection(con);
  2466.         }
  2467.     }
  2468.     public List<IDServizioApplicativo> getServiziApplicativiFruitore(String protocolloSelezionato,List<String> protocolliSupportati, 
  2469.             String tipoFruitore, String nomeFruitore,   
  2470.             String tipoErogatore, String nomeErogatore, String tipoServizio, String nomeServizio, Integer versioneServizio,
  2471.             String azione) throws DriverControlStationException{
  2472.         String nomeMetodo = "getServiziApplicativiFruitore"; 
  2473.         Connection con = null;
  2474.         con = getConnection(nomeMetodo);

  2476.         this.logDebug("operazione this.atomica = " + this.atomica);
  2477.         try{
  2478.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2479.             if(protocolloSelezionato!=null) {
  2480.                 return RegistroCore.getServiziApplicativiFruitore(serviceManager, protocolloSelezionato, 
  2481.                         tipoFruitore, nomeFruitore, 
  2482.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, 
  2483.                         azione);
  2484.             }
  2485.             else {
  2486.                 return RegistroCore.getServiziApplicativiFruitore(serviceManager, protocolliSupportati, 
  2487.                         tipoFruitore, nomeFruitore, 
  2488.                         tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, 
  2489.                         azione);
  2490.             }
  2491.         }catch (Exception qe) {
  2492.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2493.         } finally {
  2494.             releaseConnection(con);
  2495.         }
  2496.     }
  2497.     public List<IDServizioApplicativo> getServiziApplicativiFruitore(String protocolloSelezionato,List<String> protocolliSupportati, 
  2498.             String tipoFruitore, String nomeFruitore) throws DriverControlStationException{
  2499.         String nomeMetodo = "getServiziApplicativiFruitore"; 
  2500.         Connection con = null;
  2501.         con = getConnection(nomeMetodo);

  2503.         this.logDebug("operazione this.atomica = " + this.atomica);
  2504.         try{
  2505.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2506.             if(protocolloSelezionato!=null) {
  2507.                 return RegistroCore.getServiziApplicativiFruitore(serviceManager, protocolloSelezionato, 
  2508.                         tipoFruitore, nomeFruitore);
  2509.             }
  2510.             else {
  2511.                 return RegistroCore.getServiziApplicativiFruitore(serviceManager, protocolliSupportati, 
  2512.                         tipoFruitore, nomeFruitore);
  2513.             }
  2514.         }catch (Exception qe) {
  2515.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2516.         } finally {
  2517.             releaseConnection(con);
  2518.         }
  2519.     }
  2520.     public List<IDServizioApplicativo> getServiziApplicativi(String protocolloSelezionato,List<String> protocolliSupportati, 
  2521.             String tipoProprietario, String nomeProprietario) throws DriverControlStationException{
  2522.         String nomeMetodo = "getServiziApplicativi"; 
  2523.         Connection con = null;
  2524.         con = getConnection(nomeMetodo);

  2526.         this.logDebug("operazione this.atomica = " + this.atomica);
  2527.         try{
  2528.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2529.             if(protocolloSelezionato!=null) {
  2530.                 return RegistroCore.getServiziApplicativi(serviceManager, protocolloSelezionato, 
  2531.                         tipoProprietario, nomeProprietario);
  2532.             }
  2533.             else {
  2534.                 return RegistroCore.getServiziApplicativi(serviceManager, protocolliSupportati, 
  2535.                         tipoProprietario, nomeProprietario);
  2536.             }
  2537.         }catch (Exception qe) {
  2538.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2539.         } finally {
  2540.             releaseConnection(con);
  2541.         }
  2542.     }
  2543.     
  2544.     public List<IDServizio> getErogazioni(List<String> protocolli, 
  2545.             String gruppo,
  2546.             String tipoSoggetto, String nomeSoggetto) throws Exception {
  2547.         return  getErogazioni(protocolli, 
  2548.                 gruppo,
  2549.                 tipoSoggetto, nomeSoggetto,
  2550.                 null, null, null,
  2551.                 null);
  2552.     }
  2553.     public List<IDServizio> getErogazioni(List<String> protocolli, 
  2554.             String gruppo,
  2555.             String tipoSoggetto, String nomeSoggetto,
  2556.             String tipoServizio, String nomeServizio, Integer versioneServizio,
  2557.             String nomeAzione) throws DriverControlStationException{
  2558.         String nomeMetodo = "getErogazioni"; 
  2559.         Connection con = null;
  2560.         con = getConnection(nomeMetodo);

  2562.         this.logDebug("operazione this.atomica = " + this.atomica);
  2563.         try{
  2564.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2565.             return RegistroCore.getErogazioni(serviceManager, protocolli, gruppo, tipoSoggetto, nomeSoggetto, tipoServizio, nomeServizio, versioneServizio, nomeAzione);
  2566.         }catch (Exception qe) {
  2567.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2568.         } finally {
  2569.             releaseConnection(con);
  2570.         }
  2571.     }
  2572.     
  2573.     public List<IDFruizione> getFruizioni(List<String> protocolli, 
  2574.             String gruppo,
  2575.             String tipoSoggetto, String nomeSoggetto) throws Exception {
  2576.         return getFruizioni(protocolli, 
  2577.                 gruppo,
  2578.                 tipoSoggetto, nomeSoggetto, 
  2579.                 null, null,
  2580.                 null ,null, null, 
  2581.                 null);
  2582.     }
  2583.     public List<IDFruizione> getFruizioni(List<String> protocolli, 
  2584.             String gruppo,
  2585.             String tipoSoggetto, String nomeSoggetto, 
  2586.             String tipoErogatore, String nomeErogatore,
  2587.             String tipoServizio ,String nomeServizio, Integer versioneServizio, 
  2588.             String nomeAzione) throws DriverControlStationException{
  2589.         String nomeMetodo = "getFruizioni"; 
  2590.         Connection con = null;
  2591.         con = getConnection(nomeMetodo);

  2593.         this.logDebug("operazione this.atomica = " + this.atomica);
  2594.         try{
  2595.             org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager serviceManager = RegistroCore.getServiceManager(this.log, this.tipoDB, con);
  2596.             return RegistroCore.getFruizioni(serviceManager, protocolli, gruppo, tipoSoggetto, nomeSoggetto, tipoErogatore, nomeErogatore, tipoServizio, nomeServizio, versioneServizio, nomeAzione);
  2597.         }catch (Exception qe) {
  2598.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  2599.         } finally {
  2600.             releaseConnection(con);
  2601.         }
  2602.     }
  2603.     
  2604.     public boolean isGruppoInUso(IDGruppo idGruppo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  2605.         String nomeMetodo = "isGruppoInUso";

  2607.         Connection con = null;
  2608.         con = getConnection(nomeMetodo);

  2610.         this.logDebug("operazione this.atomica = " + this.atomica);

  2612.         try {

  2614.             return DBOggettiInUsoUtils.isGruppoInUso(con, this.tipoDB, idGruppo, whereIsInUso, normalizeObjectIds);
  2615.             
  2616.         } catch (Exception se) {
  2617.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  2618.         } finally {
  2619.             releaseConnection(con);
  2620.         }
  2621.     }
  2622.     
  2623.     public boolean isGruppoConfigInUso(IDGruppo idRuolo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  2624.         String nomeMetodo = "isGruppoConfigInUso";

  2626.         Connection con = null;
  2627.         con = getConnection(nomeMetodo);

  2629.         this.logDebug("operazione this.atomica = " + this.atomica);

  2631.         try {

  2633.             return DBOggettiInUsoUtils.isGruppoConfigInUso(con, this.tipoDB, idRuolo, whereIsInUso, normalizeObjectIds);
  2634.             
  2635.         } catch (Exception se) {
  2636.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  2637.         } finally {
  2638.             releaseConnection(con);
  2639.         }
  2640.     }
  2641.     
  2642.     public boolean isRisorsaInUso(IDResource idRisorsa, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  2643.         String nomeMetodo = "isRisorsaInUso";

  2645.         Connection con = null;
  2646.         con = getConnection(nomeMetodo);

  2648.         this.logDebug("operazione this.atomica = " + this.atomica);

  2650.         try {

  2652.             return DBOggettiInUsoUtils.isRisorsaInUso(con, this.tipoDB, idRisorsa, whereIsInUso, normalizeObjectIds);
  2653.             
  2654.         } catch (Exception se) {
  2655.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  2656.         } finally {
  2657.             releaseConnection(con);
  2658.         }
  2659.     }
  2660.     
  2661.     public boolean isPortTypeInUso(IDPortType idPT, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  2662.         String nomeMetodo = "isPortTypeInUso";

  2664.         Connection con = null;
  2665.         con = getConnection(nomeMetodo);

  2667.         this.logDebug("operazione this.atomica = " + this.atomica);

  2669.         try {

  2671.             return DBOggettiInUsoUtils.isPortTypeInUso(con, this.tipoDB, idPT, whereIsInUso, normalizeObjectIds);
  2672.             
  2673.         } catch (Exception se) {
  2674.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  2675.         } finally {
  2676.             releaseConnection(con);
  2677.         }
  2678.     }
  2679.     
  2680.     public boolean isOperazioneInUso(IDPortTypeAzione idOperazione, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  2681.         String nomeMetodo = "isOperazioneInUso";

  2683.         Connection con = null;
  2684.         con = getConnection(nomeMetodo);

  2686.         this.logDebug("operazione this.atomica = " + this.atomica);

  2688.         try {

  2690.             return DBOggettiInUsoUtils.isOperazioneInUso(con, this.tipoDB, idOperazione, whereIsInUso, normalizeObjectIds);
  2691.             
  2692.         } catch (Exception se) {
  2693.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  2694.         } finally {
  2695.             releaseConnection(con);
  2696.         }
  2697.     }


  2700.     public int numeroPluginsClassiList() throws DriverConfigurazioneException {
  2701.         String nomeMetodo = "numeroPluginsClassiList";
  2702.         Connection con = null;
  2703.         
  2704.         if (this.atomica) {
  2705.             try {
  2706.                 con = this.datasource.getConnection();
  2707.             } catch (Exception e) {
  2708.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2710.             }

  2712.         } else {
  2713.             con = this.globalConnection;
  2714.         }

  2716.         this.logDebug("operazione this.atomica = " + this.atomica);

  2718.         try {
  2719.             return PluginsDriverUtils.numeroPluginsClassiList(con, this.log, this.tipoDB);
  2720.         } catch (Exception qe) {
  2721.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2722.         } finally {
  2723.             releaseConnection(con);
  2724.         }
  2725.     }
  2726.     
  2727.     public List<Plugin> pluginsClassiList(ISearch ricerca) throws DriverConfigurazioneException {
  2728.         String nomeMetodo = "pluginsClassiList";
  2729.         
  2730.         Connection con = null;
  2731.         
  2732.         if (this.atomica) {
  2733.             try {
  2734.                 con = this.datasource.getConnection();
  2735.             } catch (Exception e) {
  2736.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2738.             }

  2740.         } else {
  2741.             con = this.globalConnection;
  2742.         }

  2744.         this.logDebug("operazione this.atomica = " + this.atomica);
  2745.         
  2746.         try {
  2747.             return PluginsDriverUtils.pluginsClassiList(ricerca, con, this.log, this.tipoDB);
  2748.         } catch (Exception qe) {
  2749.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2750.         } finally {
  2751.             releaseConnection(con);
  2752.         }
  2753.     }
  2754.     
  2755.     public void createPluginClassi(Plugin plugin) throws DriverConfigurazioneException {
  2756.         String nomeMetodo = "createPluginClassi";

  2758.         Connection con = null;

  2760.         if (this.atomica) {
  2761.             try {
  2762.                 con = this.datasource.getConnection();
  2763.             } catch (Exception e) {
  2764.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2766.             }

  2768.         } else {
  2769.             con = this.globalConnection;
  2770.         }

  2772.         this.logDebug("operazione this.atomica = " + this.atomica);

  2774.         try {
  2775.             PluginsDriverUtils.createPluginClassi(plugin, con, this.log, this.tipoDB);
  2776.         } catch (Exception qe) {
  2777.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2778.         } finally {
  2779.             releaseConnection(con);
  2780.         }
  2781.     }
  2782.     
  2783.     public void updatePluginClassi(Plugin plugin) throws DriverConfigurazioneException {
  2784.         String nomeMetodo = "updatePluginClassi";

  2786.         Connection con = null;

  2788.         if (this.atomica) {
  2789.             try {
  2790.                 con = this.datasource.getConnection();
  2791.             } catch (Exception e) {
  2792.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2794.             }

  2796.         } else {
  2797.             con = this.globalConnection;
  2798.         }

  2800.         this.logDebug("operazione this.atomica = " + this.atomica);

  2802.         try {
  2803.             PluginsDriverUtils.updatePluginClassi(plugin, con, this.log, this.tipoDB);      
  2804.         } catch (Exception qe) {
  2805.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2806.         } finally {
  2807.             releaseConnection(con);
  2808.         }
  2809.     }
  2810.     
  2811.     public void deletePluginClassi(Plugin plugin) throws DriverConfigurazioneException {
  2812.         String nomeMetodo = "deletePluginClassi";

  2814.         Connection con = null;

  2816.         if (this.atomica) {
  2817.             try {
  2818.                 con = this.datasource.getConnection();
  2819.             } catch (Exception e) {
  2820.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2822.             }

  2824.         } else {
  2825.             con = this.globalConnection;
  2826.         }

  2828.         this.logDebug("operazione this.atomica = " + this.atomica);

  2830.         try {
  2831.             PluginsDriverUtils.deletePluginClassi(plugin, con, this.log, this.tipoDB);      
  2832.         } catch (Exception qe) {
  2833.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2834.         } finally {
  2835.             releaseConnection(con);
  2836.         }
  2837.     }

  2839.     public boolean existsPlugin(TipoPlugin tipoPlugin, String tipo, String label, String className) throws DriverConfigurazioneException {
  2840.         String nomeMetodo = "existsPlugin";
  2841.         Connection con = null;

  2843.         if (this.atomica) {
  2844.             try {
  2845.                 con = this.datasource.getConnection();
  2846.             } catch (Exception e) {
  2847.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2849.             }

  2851.         } else {
  2852.             con = this.globalConnection;
  2853.         }

  2855.         this.logDebug("operazione this.atomica = " + this.atomica);

  2857.         try {
  2858.             return PluginsDriverUtils.existsPlugin(tipoPlugin, tipo, label, className, con, this.log, this.tipoDB);
  2859.         } catch (Exception qe) {
  2860.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2861.         } finally {
  2862.             releaseConnection(con);
  2863.         }
  2864.     }
  2865.     
  2866.     public boolean existsPluginConTipo(TipoPlugin tipoPlugin, String tipo) throws DriverConfigurazioneException {
  2867.         String nomeMetodo = "existsPluginConTipo";
  2868.         Connection con = null;

  2870.         if (this.atomica) {
  2871.             try {
  2872.                 con = this.datasource.getConnection();
  2873.             } catch (Exception e) {
  2874.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2876.             }

  2878.         } else {
  2879.             con = this.globalConnection;
  2880.         }

  2882.         this.logDebug("operazione this.atomica = " + this.atomica);

  2884.         try {
  2885.             return PluginsDriverUtils.existsPluginConTipo(tipoPlugin, tipo, con, this.log, this.tipoDB);
  2886.         } catch (Exception qe) {
  2887.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2888.         } finally {
  2889.             releaseConnection(con);
  2890.         }
  2891.     }
  2892.     
  2893.     public boolean existsPluginConLabel(TipoPlugin tipoPlugin,String label) throws DriverConfigurazioneException {
  2894.         String nomeMetodo = "existsPluginConLabel";
  2895.         Connection con = null;

  2897.         if (this.atomica) {
  2898.             try {
  2899.                 con = this.datasource.getConnection();
  2900.             } catch (Exception e) {
  2901.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2903.             }

  2905.         } else {
  2906.             con = this.globalConnection;
  2907.         }

  2909.         this.logDebug("operazione this.atomica = " + this.atomica);

  2911.         try {
  2912.             return PluginsDriverUtils.existsPluginConLabel(tipoPlugin, label, con, this.log, this.tipoDB);
  2913.         } catch (Exception qe) {
  2914.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2915.         } finally {
  2916.             releaseConnection(con);
  2917.         }
  2918.     }
  2919.     
  2920.     public boolean existsPluginConClassName(TipoPlugin tipoPlugin, String className) throws DriverConfigurazioneException {
  2921.         String nomeMetodo = "existsPluginConClassName";
  2922.         Connection con = null;

  2924.         if (this.atomica) {
  2925.             try {
  2926.                 con = this.datasource.getConnection();
  2927.             } catch (Exception e) {
  2928.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2930.             }

  2932.         } else {
  2933.             con = this.globalConnection;
  2934.         }

  2936.         this.logDebug("operazione this.atomica = " + this.atomica);

  2938.         try {
  2939.             return PluginsDriverUtils.existsPluginConClassName(tipoPlugin, className, con, this.log, this.tipoDB);
  2940.         } catch (Exception qe) {
  2941.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2942.         } finally {
  2943.             releaseConnection(con);
  2944.         }
  2945.     }

  2947.     public Plugin getPlugin(long idPlugin) throws DriverConfigurazioneException {
  2948.         String nomeMetodo = "getPlugin";
  2949.         Connection con = null;

  2951.         if (this.atomica) {
  2952.             try {
  2953.                 con = this.datasource.getConnection();
  2954.             } catch (Exception e) {
  2955.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2957.             }

  2959.         } else {
  2960.             con = this.globalConnection;
  2961.         }

  2963.         this.logDebug("operazione this.atomica = " + this.atomica);

  2965.         try {
  2966.             return PluginsDriverUtils.getPlugin(idPlugin, con, this.log, this.tipoDB);
  2967.         } catch (Exception qe) {
  2968.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  2969.         } finally {
  2970.             releaseConnection(con);
  2971.         }
  2972.     }
  2973.     
  2974.     public Plugin getPlugin(TipoPlugin tipoPlugin, String tipo, boolean throwNotFound) throws DriverConfigurazioneException,DriverConfigurazioneNotFound {
  2975.         String nomeMetodo = "getPlugin";
  2976.         Connection con = null;

  2978.         if (this.atomica) {
  2979.             try {
  2980.                 con = this.datasource.getConnection();
  2981.             } catch (Exception e) {
  2982.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  2984.             }

  2986.         } else {
  2987.             con = this.globalConnection;
  2988.         }

  2990.         this.logDebug("operazione this.atomica = " + this.atomica);

  2992.         try {
  2993.             return PluginsDriverUtils.getPlugin(tipoPlugin, tipo, throwNotFound, con, this.log, this.tipoDB);
  2994.         } 
  2995.         catch(NotFoundException notFound) {
  2996.             throw new DriverConfigurazioneNotFound("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + notFound.getMessage(),notFound);
  2997.         }
  2998.         catch (Exception qe) {
  2999.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3000.         } finally {
  3001.             releaseConnection(con);
  3002.         }
  3003.     }
  3004.     
  3005.     public boolean isPluginInUso(String className, String label, String tipoPlugin, String tipo, Map<ErrorsHandlerCostant, List<String>> whereIsInUso, boolean normalizeObjectIds) throws DriverControlStationException {
  3006.         String nomeMetodo = "isPluginInUso";

  3008.         Connection con = null;
  3009.         con = getConnection(nomeMetodo);

  3011.         this.logDebug("operazione this.atomica = " + this.atomica);

  3013.         try {
  3014.             return DBOggettiInUsoUtils.isPluginInUso(con, this.tipoDB, className, label, tipoPlugin, tipo, whereIsInUso, normalizeObjectIds);
  3015.         } catch (Exception se) {
  3016.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo + "] Exception: " + se.getMessage(),se);
  3017.         } finally {
  3018.             releaseConnection(con);
  3019.         }
  3020.     }
  3021.     
  3022.     public List<ConfigurazioneAllarmeBean> allarmiList(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta) throws DriverConfigurazioneException {
  3023.         String nomeMetodo = "allarmiList";
  3024.         
  3025.         Connection con = null;
  3026.         
  3027.         if (this.atomica) {
  3028.             try {
  3029.                 con = this.datasource.getConnection();
  3030.             } catch (Exception e) {
  3031.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3033.             }

  3035.         } else {
  3036.             con = this.globalConnection;
  3037.         }

  3039.         this.logDebug("operazione this.atomica = " + this.atomica);
  3040.         
  3041.         try {
  3042.             return org.openspcoop2.monitor.engine.alarm.utils.AllarmiDriverUtils.allarmiList(ricerca, ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  3043.         } catch (Exception qe) {
  3044.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3045.         } finally {
  3046.             releaseConnection(con);
  3047.         }
  3048.     }
  3049.     
  3050.     public List<Allarme> allarmiSenzaPluginList(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta) throws DriverConfigurazioneException {
  3051.         String nomeMetodo = "allarmiSenzaPluginList";
  3052.         
  3053.         Connection con = null;
  3054.         
  3055.         if (this.atomica) {
  3056.             try {
  3057.                 con = this.datasource.getConnection();
  3058.             } catch (Exception e) {
  3059.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3061.             }

  3063.         } else {
  3064.             con = this.globalConnection;
  3065.         }

  3067.         this.logDebug("operazione this.atomica = " + this.atomica);
  3068.         
  3069.         try {
  3070.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.allarmiList(ricerca, ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  3071.         } catch (Exception qe) {
  3072.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3073.         } finally {
  3074.             releaseConnection(con);
  3075.         }
  3076.     }
  3077.     
  3078.     public boolean existsAllarmi(TipoAllarme tipoAllarme) throws DriverConfigurazioneException {
  3079.         String nomeMetodo = "existsAllarmi";
  3080.         
  3081.         Connection con = null;
  3082.         
  3083.         if (this.atomica) {
  3084.             try {
  3085.                 con = this.datasource.getConnection();
  3086.             } catch (Exception e) {
  3087.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3089.             }

  3091.         } else {
  3092.             con = this.globalConnection;
  3093.         }

  3095.         this.logDebug("operazione this.atomica = " + this.atomica);
  3096.         
  3097.         try {
  3098.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.existsAllarmi(tipoAllarme, con, this.log, this.tipoDB);
  3099.         } catch (Exception qe) {
  3100.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3101.         } finally {
  3102.             releaseConnection(con);
  3103.         }
  3104.     }
  3105.     
  3106.     public long countAllarmi(TipoAllarme tipoAllarme) throws DriverConfigurazioneException {
  3107.         String nomeMetodo = "countAllarmi";
  3108.         
  3109.         Connection con = null;
  3110.         
  3111.         if (this.atomica) {
  3112.             try {
  3113.                 con = this.datasource.getConnection();
  3114.             } catch (Exception e) {
  3115.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3117.             }

  3119.         } else {
  3120.             con = this.globalConnection;
  3121.         }

  3123.         this.logDebug("operazione this.atomica = " + this.atomica);
  3124.         
  3125.         try {
  3126.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.countAllarmi(tipoAllarme, con, this.log, this.tipoDB);
  3127.         } catch (Exception qe) {
  3128.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3129.         } finally {
  3130.             releaseConnection(con);
  3131.         }
  3132.     }
  3133.     
  3134.     public void createAllarme(Allarme allarme) throws DriverConfigurazioneException {
  3135.         String nomeMetodo = "createAllarme";

  3137.         Connection con = null;

  3139.         if (this.atomica) {
  3140.             try {
  3141.                 con = this.datasource.getConnection();
  3142.             } catch (Exception e) {
  3143.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3145.             }

  3147.         } else {
  3148.             con = this.globalConnection;
  3149.         }

  3151.         this.logDebug("operazione this.atomica = " + this.atomica);

  3153.         try {
  3154.             org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.createAllarme(allarme, con, this.log, this.tipoDB);           
  3155.         } catch (Exception qe) {
  3156.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3157.         } finally {
  3158.             releaseConnection(con);
  3159.         }
  3160.     }
  3161.     
  3162.     public void updateAllarme(Allarme allarme) throws DriverConfigurazioneException {
  3163.         String nomeMetodo = "updateAllarme";

  3165.         Connection con = null;

  3167.         if (this.atomica) {
  3168.             try {
  3169.                 con = this.datasource.getConnection();
  3170.             } catch (Exception e) {
  3171.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3173.             }

  3175.         } else {
  3176.             con = this.globalConnection;
  3177.         }

  3179.         this.logDebug("operazione this.atomica = " + this.atomica);

  3181.         try {
  3182.             org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.updateAllarme(allarme, con, this.log, this.tipoDB);
  3183.         } catch (Exception qe) {
  3184.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3185.         } finally {
  3186.             releaseConnection(con);
  3187.         }
  3188.     }
  3189.     
  3190.     public void deleteAllarme(Allarme allarme) throws DriverConfigurazioneException {
  3191.         String nomeMetodo = "deleteAllarme";

  3193.         Connection con = null;

  3195.         if (this.atomica) {
  3196.             try {
  3197.                 con = this.datasource.getConnection();
  3198.             } catch (Exception e) {
  3199.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3201.             }

  3203.         } else {
  3204.             con = this.globalConnection;
  3205.         }

  3207.         this.logDebug("operazione this.atomica = " + this.atomica);

  3209.         try {
  3210.             org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.deleteAllarme(allarme, con,  this.log, this.tipoDB);
  3211.         } catch (Exception qe) {
  3212.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3213.         } finally {
  3214.             releaseConnection(con);
  3215.         }
  3216.     }

  3218.     public boolean existsAllarme(String nome) throws DriverConfigurazioneException {
  3219.         String nomeMetodo = "existsAllarme";
  3220.         Connection con = null;

  3222.         if (this.atomica) {
  3223.             try {
  3224.                 con = this.datasource.getConnection();
  3225.             } catch (Exception e) {
  3226.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3228.             }

  3230.         } else {
  3231.             con = this.globalConnection;
  3232.         }

  3234.         this.logDebug("operazione this.atomica = " + this.atomica);

  3236.         try {
  3237.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.existsAllarme(nome, con, this.log, this.tipoDB);
  3238.         } catch (Exception qe) {
  3239.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3240.         } finally {
  3241.             releaseConnection(con);
  3242.         }
  3243.     }
  3244.     
  3245.     public void createHistoryAllarme(AllarmeHistory allarme) throws DriverConfigurazioneException {
  3246.         String nomeMetodo = "createHistoryAllarme";

  3248.         Connection con = null;

  3250.         if (this.atomica) {
  3251.             try {
  3252.                 con = this.datasource.getConnection();
  3253.             } catch (Exception e) {
  3254.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3256.             }

  3258.         } else {
  3259.             con = this.globalConnection;
  3260.         }

  3262.         this.logDebug("operazione this.atomica = " + this.atomica);

  3264.         try {
  3265.             org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.createHistoryAllarme(allarme, con, this.log, this.tipoDB);
  3266.         } catch (Exception qe) {
  3267.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3268.         } finally {
  3269.             releaseConnection(con);
  3270.         }
  3271.     }

  3273.     
  3274.     public Allarme getAllarmeSenzaPlugin(Long id) throws DriverConfigurazioneException {
  3275.         String nomeMetodo = "getAllarmeSenzaPlugin";
  3276.         Connection con = null;

  3278.         if (this.atomica) {
  3279.             try {
  3280.                 con = this.datasource.getConnection();
  3281.             } catch (Exception e) {
  3282.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3284.             }

  3286.         } else {
  3287.             con = this.globalConnection;
  3288.         }

  3290.         this.logDebug("operazione this.atomica = " + this.atomica);

  3292.         try {
  3293.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.getAllarme(id, con, this.log, this.tipoDB);
  3294.         } catch (Exception qe) {
  3295.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3296.         } finally {
  3297.             releaseConnection(con);
  3298.         }
  3299.     }
  3300.     
  3301.     public Allarme getAllarmeSenzaPlugin(String nome) throws DriverConfigurazioneException {
  3302.         String nomeMetodo = "getAllarmeSenzaPluginByNome";
  3303.         Connection con = null;

  3305.         if (this.atomica) {
  3306.             try {
  3307.                 con = this.datasource.getConnection();
  3308.             } catch (Exception e) {
  3309.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3311.             }

  3313.         } else {
  3314.             con = this.globalConnection;
  3315.         }

  3317.         this.logDebug("operazione this.atomica = " + this.atomica);

  3319.         try {
  3320.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.getAllarme(nome, con, this.log, this.tipoDB);
  3321.         } catch (Exception qe) {
  3322.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3323.         } finally {
  3324.             releaseConnection(con);
  3325.         }
  3326.     }
  3327.     
  3328.     public ConfigurazioneAllarmeBean getAllarme(Long id) throws DriverConfigurazioneException {
  3329.         String nomeMetodo = "getAllarme";
  3330.         Connection con = null;

  3332.         if (this.atomica) {
  3333.             try {
  3334.                 con = this.datasource.getConnection();
  3335.             } catch (Exception e) {
  3336.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3338.             }

  3340.         } else {
  3341.             con = this.globalConnection;
  3342.         }

  3344.         this.logDebug("operazione this.atomica = " + this.atomica);

  3346.         try {
  3347.             return org.openspcoop2.monitor.engine.alarm.utils.AllarmiDriverUtils.getAllarme(id, con, this.log, this.tipoDB);
  3348.         } catch (Exception qe) {
  3349.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3350.         } finally {
  3351.             releaseConnection(con);
  3352.         }
  3353.     }
  3354.     
  3355.     public ConfigurazioneAllarmeBean getAllarme(String nome) throws DriverConfigurazioneException {
  3356.         String nomeMetodo = "getAllarmeByNome";
  3357.         Connection con = null;

  3359.         if (this.atomica) {
  3360.             try {
  3361.                 con = this.datasource.getConnection();
  3362.             } catch (Exception e) {
  3363.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3365.             }

  3367.         } else {
  3368.             con = this.globalConnection;
  3369.         }

  3371.         this.logDebug("operazione this.atomica = " + this.atomica);

  3373.         try {
  3374.             return org.openspcoop2.monitor.engine.alarm.utils.AllarmiDriverUtils.getAllarme(nome, con, this.log, this.tipoDB);
  3375.         } catch (Exception qe) {
  3376.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3377.         } finally {
  3378.             releaseConnection(con);
  3379.         }
  3380.     }

  3382.     public ConfigurazioneAllarmeBean getAllarme(Allarme allarme) throws DriverConfigurazioneException {
  3383.         String nomeMetodo = "convertAllarme";
  3384.         Connection con = null;

  3386.         if (this.atomica) {
  3387.             try {
  3388.                 con = this.datasource.getConnection();
  3389.             } catch (Exception e) {
  3390.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3392.             }

  3394.         } else {
  3395.             con = this.globalConnection;
  3396.         }

  3398.         this.logDebug("operazione this.atomica = " + this.atomica);

  3400.         try {
  3401.             return org.openspcoop2.monitor.engine.alarm.utils.AllarmiDriverUtils.getAllarme(allarme, con, this.log, this.tipoDB);
  3402.         } catch (Exception qe) {
  3403.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3404.         } finally {
  3405.             releaseConnection(con);
  3406.         }
  3407.     }
  3408.     
  3409.     public Allarme getAllarmeByAlias(String alias,
  3410.             RuoloPorta ruoloPorta, String nomePorta) throws DriverControlStationNotFound, DriverConfigurazioneException {
  3411.         String nomeMetodo = "getAllarmeByAlias";
  3412.         Connection con = null;

  3414.         if (this.atomica) {
  3415.             try {
  3416.                 con = this.datasource.getConnection();
  3417.             } catch (Exception e) {
  3418.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3420.             }

  3422.         } else {
  3423.             con = this.globalConnection;
  3424.         }

  3426.         this.logDebug("operazione this.atomica = " + this.atomica);

  3428.         try {
  3429.             return AllarmiDriverUtils.getAllarmeByAlias(alias,
  3430.                     ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  3431.         }catch (NotFoundException e) {
  3432.             throw new DriverControlStationNotFound("[DriverControlStationDB::" + nomeMetodo + "] Allarme non presente.");
  3433.         }  catch (Exception qe) {
  3434.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3435.         } finally {
  3436.             releaseConnection(con);
  3437.         }
  3438.     }
  3439.     
  3440.     public List<ConfigurazioneAllarmeHistoryBean> allarmiHistoryList(ConsoleSearch ricerca, Long idAllarme) throws DriverConfigurazioneException {
  3441.         String nomeMetodo = "allarmiHistoryList";
  3442.                 
  3443.         Connection con = null;
  3444.         
  3445.         if (this.atomica) {
  3446.             try {
  3447.                 con = this.datasource.getConnection();
  3448.             } catch (Exception e) {
  3449.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3451.             }

  3453.         } else {
  3454.             con = this.globalConnection;
  3455.         }

  3457.         this.logDebug("operazione this.atomica = " + this.atomica);
  3458.         
  3459.         try {
  3460.             return org.openspcoop2.monitor.engine.alarm.utils.AllarmiDriverUtils.allarmiHistoryList(ricerca, idAllarme, con, this.log, this.tipoDB);

  3462.         } catch (Exception qe) {
  3463.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3464.         } finally {
  3465.             releaseConnection(con);
  3466.         }
  3467.     }
  3468.     
  3469.     public String getNextAlarmInstanceSerialId(String tipoPlugin) throws DriverControlStationException{
  3470.         String nomeMetodo = "getNextAlarmInstanceSerialId"; 
  3471.         Connection con = null;
  3472.         con = getConnection(nomeMetodo);

  3474.         this.logDebug("operazione this.atomica = " + this.atomica);
  3475.         
  3476.         try{
  3477.             return AllarmiDriverUtils.getNextAlarmInstanceSerialId(tipoPlugin, con, this.log, this.tipoDB);     
  3478.         } catch (Exception qe) {
  3479.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  3480.         } finally {
  3481.             releaseConnection(con);
  3482.         }
  3483.     }
  3484.     
  3485.     public List<ConfigurazioneAllarmeBean> configurazioneAllarmiList(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta) throws DriverControlStationException{
  3486.         return this._configurazioneAllarmiList(ricerca, ruoloPorta, nomePorta, 
  3487.                 "configurazioneControlloTrafficoAttivazionePolicyList",
  3488.                 null, null, null,
  3489.                 null, null,
  3490.                 null, null);
  3491.     }
  3492.     public List<ConfigurazioneAllarmeBean> configurazioneAllarmiListByFilter(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta,
  3493.             IDSoggetto filtroSoggettoFruitore, IDServizioApplicativo filtroApplicativoFruitore,String filtroRuoloFruitore,
  3494.             IDSoggetto filtroSoggettoErogatore, String filtroRuoloErogatore,
  3495.             IDServizio filtroServizioAzione, String filtroRuolo) throws DriverControlStationException{
  3496.         return this._configurazioneAllarmiList(ricerca, ruoloPorta, nomePorta, 
  3497.                 "configurazioneControlloTrafficoAttivazionePolicyListByFilter",
  3498.                 filtroSoggettoFruitore, filtroApplicativoFruitore, filtroRuoloFruitore,
  3499.                 filtroSoggettoErogatore, filtroRuoloErogatore,
  3500.                 filtroServizioAzione, filtroRuolo);
  3501.     }
  3502.     private List<ConfigurazioneAllarmeBean> _configurazioneAllarmiList(ConsoleSearch ricerca, RuoloPorta ruoloPorta, String nomePorta, String nomeMetodo,
  3503.             IDSoggetto filtroSoggettoFruitore, IDServizioApplicativo filtroApplicativoFruitore,String filtroRuoloFruitore,
  3504.             IDSoggetto filtroSoggettoErogatore, String filtroRuoloErogatore,
  3505.             IDServizio filtroServizioAzione, String filtroRuolo) throws DriverControlStationException{
  3506.         // ritorna la configurazione controllo del traffico della PdD
  3507.         Connection con = null;
  3508.         
  3509.         con = getConnection(nomeMetodo);

  3511.         this.logDebug("operazione this.atomica = " + this.atomica);
  3512.         List<ConfigurazioneAllarmeBean> listaAllarmi = null;
  3513.         
  3514.         try {
  3515.         
  3516.             listaAllarmi = org.openspcoop2.monitor.engine.alarm.utils.AllarmiDriverUtils.configurazioneAllarmiList(ricerca, ruoloPorta, nomePorta, 
  3517.                     con, this.log, this.tipoDB,
  3518.                     nomeMetodo, 
  3519.                     filtroSoggettoFruitore, filtroApplicativoFruitore, filtroRuoloFruitore,
  3520.                     filtroSoggettoErogatore, filtroRuoloErogatore,
  3521.                     filtroServizioAzione, filtroRuolo);
  3522.                         
  3523.         } catch (Exception qe) {
  3524.             throw new DriverControlStationException("[DriverControlStationDB::" + nomeMetodo +"] Errore : " + qe.getMessage(),qe);
  3525.         } finally {
  3526.             releaseConnection(con);
  3527.         }
  3528.         
  3529.         return listaAllarmi;
  3530.         
  3531.     }
  3532.     
  3533.     public List<Allarme> allarmiForPolicyRateLimiting(String activeIdPolicy, RuoloPorta ruoloPorta, String nomePorta) throws DriverConfigurazioneException {
  3534.         String nomeMetodo = "allarmiForPolicyRateLimiting";
  3535.         
  3536.         Connection con = null;
  3537.         
  3538.         if (this.atomica) {
  3539.             try {
  3540.                 con = this.datasource.getConnection();
  3541.             } catch (Exception e) {
  3542.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3544.             }

  3546.         } else {
  3547.             con = this.globalConnection;
  3548.         }

  3550.         this.logDebug("operazione this.atomica = " + this.atomica);
  3551.         
  3552.         try {
  3553.             return org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils.allarmiForPolicyRateLimiting(activeIdPolicy, ruoloPorta, nomePorta, con, this.log, this.tipoDB);
  3554.         } catch (Exception qe) {
  3555.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3556.         } finally {
  3557.             releaseConnection(con);
  3558.         }
  3559.     }

  3561.     public int numeroHandlersRichiestaList(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3562.         String nomeMetodo = "numeroHandlersRichiestaList";
  3563.         return numeroHandlersList(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.MESSAGE_HANDLER);
  3564.     }
  3565.     
  3566.     public int numeroHandlersRispostaList(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3567.         String nomeMetodo = "numeroHandlersRispostaList";
  3568.         return numeroHandlersList(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.MESSAGE_HANDLER);
  3569.     }
  3570.     
  3571.     public int numeroHandlersServizioList(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3572.         String nomeMetodo = "numeroHandlersServizioList";
  3573.         return numeroHandlersList(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.SERVICE_HANDLER);
  3574.     }
  3575.     
  3576.     private int numeroHandlersList(String tipologia, TipoPdD ruoloPorta, Long idPorta, String nomeMetodo, TipoPlugin tipoPlugin) throws DriverConfigurazioneException {
  3577.         Connection con = null;
  3578.         
  3579.         if (this.atomica) {
  3580.             try {
  3581.                 con = this.datasource.getConnection();
  3582.             } catch (Exception e) {
  3583.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3585.             }

  3587.         } else {
  3588.             con = this.globalConnection;
  3589.         }

  3591.         this.logDebug("operazione this.atomica = " + this.atomica);

  3593.         try {
  3594.             return HandlersDriverUtils.numeroHandlerList(tipologia, ruoloPorta, idPorta, tipoPlugin, nomeMetodo, con, this.log, this.tipoDB); 
  3595.         } catch (Exception qe) {
  3596.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3597.         } finally {
  3598.             releaseConnection(con);
  3599.         }
  3600.     }
  3601.     
  3602.     public List<ConfigurazioneHandlerBean> handlersRichiestaList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3603.         String nomeMetodo = "handlersRichiestaList";
  3604.         int idLista = Liste.CONFIGURAZIONE_HANDLERS_RICHIESTA;
  3605.         return handlersList(ricerca, tipologia, ruoloPorta, idPorta, nomeMetodo, idLista, TipoPlugin.MESSAGE_HANDLER);
  3606.     }
  3607.     
  3608.     public List<ConfigurazioneHandlerBean> handlersRispostaList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3609.         String nomeMetodo = "handlersRispostaList";
  3610.         int idLista = Liste.CONFIGURAZIONE_HANDLERS_RISPOSTA;
  3611.         return handlersList(ricerca, tipologia, ruoloPorta, idPorta, nomeMetodo, idLista, TipoPlugin.MESSAGE_HANDLER);
  3612.     }
  3613.     
  3614.     public List<ConfigurazioneHandlerBean> handlersServizioList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3615.         String nomeMetodo = "handlersServizioList";
  3616.         int idLista = Liste.CONFIGURAZIONE_HANDLERS_SERVIZIO;
  3617.         return handlersList(ricerca, tipologia, ruoloPorta, idPorta, nomeMetodo, idLista, TipoPlugin.SERVICE_HANDLER);
  3618.     }
  3619.     
  3620.     private List<ConfigurazioneHandlerBean> handlersList(ISearch ricerca, String tipologia, TipoPdD ruoloPorta, Long idPorta, String nomeMetodo, int idLista, TipoPlugin tipoPlugin) throws DriverConfigurazioneException {
  3621.         
  3622.         Connection con = null;
  3623.         
  3624.         if (this.atomica) {
  3625.             try {
  3626.                 con = this.datasource.getConnection();
  3627.             } catch (Exception e) {
  3628.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3630.             }

  3632.         } else {
  3633.             con = this.globalConnection;
  3634.         }

  3636.         this.logDebug("operazione this.atomica = " + this.atomica);
  3637.         
  3638.         try {
  3639.             return HandlersDriverUtils.handlerList(ricerca, tipologia, ruoloPorta, idPorta, nomeMetodo, idLista, tipoPlugin, con, this.log, this.tipoDB);
  3640.         } catch (Exception qe) {
  3641.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3642.         } finally {
  3643.             releaseConnection(con);
  3644.         }
  3645.     }
  3646.     
  3647.     public int getMaxPosizioneHandlersRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3648.         String nomeMetodo = "getMaxPosizioneHandlersRichiesta";
  3649.         return getMaxPosizioneHandlers(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.MESSAGE_HANDLER);
  3650.     }
  3651.     
  3652.     public int getMaxPosizioneHandlersRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3653.         String nomeMetodo = "getMaxPosizioneHandlersRisposta";
  3654.         return getMaxPosizioneHandlers(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.MESSAGE_HANDLER);
  3655.     }
  3656.     
  3657.     public int getMaxPosizioneHandlersServizio(String tipologia, TipoPdD ruoloPorta, Long idPorta) throws DriverConfigurazioneException {
  3658.         String nomeMetodo = "getMaxPosizioneHandlersServizio";
  3659.         return getMaxPosizioneHandlers(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.SERVICE_HANDLER);
  3660.     }
  3661.     
  3662.     private int getMaxPosizioneHandlers(String tipologia, TipoPdD ruoloPorta, Long idPorta, String nomeMetodo, TipoPlugin tipoPlugin) throws DriverConfigurazioneException {
  3663.         
  3664.         Connection con = null;
  3665.         
  3666.         if (this.atomica) {
  3667.             try {
  3668.                 con = this.datasource.getConnection();
  3669.             } catch (Exception e) {
  3670.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3672.             }

  3674.         } else {
  3675.             con = this.globalConnection;
  3676.         }

  3678.         this.logDebug("operazione this.atomica = " + this.atomica);
  3679.         
  3680.         try {
  3681.             return HandlersDriverUtils.getMaxPosizioneHandlers(tipologia, ruoloPorta, idPorta, nomeMetodo, tipoPlugin, con, this.log, this.tipoDB);
  3682.         } catch (Exception qe) {
  3683.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3684.         } finally {
  3685.             releaseConnection(con);
  3686.         }
  3687.     }
  3688.     
  3689.     public boolean existsHandlerRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta, String tipo) throws DriverConfigurazioneException {
  3690.         String nomeMetodo = "existsHandlerRichiesta";
  3691.         return existsHandler(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.MESSAGE_HANDLER, tipo);
  3692.     }
  3693.     
  3694.     public boolean existsHandlerRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta, String tipo) throws DriverConfigurazioneException {
  3695.         String nomeMetodo = "existsHandlerRisposta";
  3696.         return existsHandler(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.MESSAGE_HANDLER, tipo);
  3697.     }
  3698.     
  3699.     public boolean existsHandlerServizio(String tipologia, TipoPdD ruoloPorta, Long idPorta, String tipo) throws DriverConfigurazioneException {
  3700.         String nomeMetodo = "existsHandlerServizio";
  3701.         return existsHandler(tipologia, ruoloPorta, idPorta, nomeMetodo, TipoPlugin.SERVICE_HANDLER, tipo);
  3702.     }
  3703.     
  3704.     private boolean existsHandler(String tipologia, TipoPdD ruoloPorta, Long idPorta, String nomeMetodo, TipoPlugin tipoPlugin, String tipo) throws DriverConfigurazioneException {
  3705.         
  3706.         Connection con = null;
  3707.         
  3708.         if (this.atomica) {
  3709.             try {
  3710.                 con = this.datasource.getConnection();
  3711.             } catch (Exception e) {
  3712.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3714.             }

  3716.         } else {
  3717.             con = this.globalConnection;
  3718.         }

  3720.         this.logDebug("operazione this.atomica = " + this.atomica);
  3721.         
  3722.         try {
  3723.             return HandlersDriverUtils.existsHandler(tipologia, ruoloPorta, idPorta, nomeMetodo, tipoPlugin, tipo, con, this.log, this.tipoDB);
  3724.         } catch (Exception qe) {
  3725.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3726.         } finally {
  3727.             releaseConnection(con);
  3728.         }
  3729.     }
  3730.     
  3731.     public ConfigurazioneHandlerBean getHandlerRichiesta(String tipologia, TipoPdD ruoloPorta, Long idPorta, Long idHandler) throws DriverConfigurazioneException {
  3732.         String nomeMetodo = "getHandlerRichiesta";
  3733.         return getHandler(tipologia, ruoloPorta, idPorta, idHandler, nomeMetodo, TipoPlugin.MESSAGE_HANDLER);
  3734.     }
  3735.     
  3736.     public ConfigurazioneHandlerBean getHandlerRisposta(String tipologia, TipoPdD ruoloPorta, Long idPorta, Long idHandler) throws DriverConfigurazioneException {
  3737.         String nomeMetodo = "getHandlerRisposta";
  3738.         return getHandler(tipologia, ruoloPorta, idPorta, idHandler, nomeMetodo, TipoPlugin.MESSAGE_HANDLER);
  3739.     }
  3740.     
  3741.     public ConfigurazioneHandlerBean getHandlerServizio(String tipologia, TipoPdD ruoloPorta, Long idPorta, Long idHandler) throws DriverConfigurazioneException {
  3742.         String nomeMetodo = "getHandlerServizio";
  3743.         return getHandler(tipologia, ruoloPorta, idPorta, idHandler, nomeMetodo, TipoPlugin.SERVICE_HANDLER);
  3744.     }
  3745.     
  3746.     private ConfigurazioneHandlerBean getHandler(String tipologia, TipoPdD ruoloPorta, Long idPorta, Long idHandler, String nomeMetodo, TipoPlugin tipoPlugin) throws DriverConfigurazioneException {
  3747.         
  3748.         Connection con = null;
  3749.         
  3750.         if (this.atomica) {
  3751.             try {
  3752.                 con = this.datasource.getConnection();
  3753.             } catch (Exception e) {
  3754.                 throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3756.             }

  3758.         } else {
  3759.             con = this.globalConnection;
  3760.         }

  3762.         this.logDebug("operazione this.atomica = " + this.atomica);
  3763.         
  3764.         try {
  3765.             return HandlersDriverUtils.getHandler(tipologia, ruoloPorta, idPorta, idHandler, nomeMetodo, tipoPlugin, con, this.log, this.tipoDB);
  3766.         } catch (Exception qe) {
  3767.             throw new DriverConfigurazioneException("[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  3768.         } finally {
  3769.             releaseConnection(con);
  3770.         }
  3771.     }
  3772.     
  3773.     public void updateProprietaOggettoErogazione(IDServizio idServizio, String user, boolean throwException) throws DriverRegistroServiziException{
  3774.         Connection con = null;
  3775.         String nomeMetodo = "updateProprietaOggettoErogazione";
  3776.         DriverRegistroServiziDB driver = null;

  3778.         if (this.atomica) {
  3779.             try {
  3780.                 con = this.datasource.getConnection();
  3781.             } catch (Exception e) {
  3782.                 throw new DriverRegistroServiziException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3784.             }

  3786.         } else {
  3787.             con = this.globalConnection;
  3788.         }
  3789.         
  3790.         try {

  3792.             this.logDebug("operazione this.atomica = " + this.atomica);
  3793.             
  3794.             // istanzio il driver
  3795.             driver = new DriverRegistroServiziDB(con, this.log, this.tipoDB);

  3797.             driver.updateProprietaOggettoErogazione(idServizio,user);
  3798.             
  3799.         } catch (Exception e) {
  3800.             String msgError = "[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + e.getMessage();
  3801.             ControlStationCore.logError(msgError, e);
  3802.             if(throwException) {
  3803.                 throw new DriverRegistroServiziException(msgError, e);
  3804.             }
  3805.         } finally {
  3806.             releaseConnection(con);
  3807.         }
  3808.     }
  3809.     public void updateProprietaOggettoErogazione(long idServizio, String user, boolean throwException) throws DriverRegistroServiziException{
  3810.         Connection con = null;
  3811.         String nomeMetodo = "updateProprietaOggettoErogazione";
  3812.         DriverRegistroServiziDB driver = null;

  3814.         if (this.atomica) {
  3815.             try {
  3816.                 con = this.datasource.getConnection();
  3817.             } catch (Exception e) {
  3818.                 throw new DriverRegistroServiziException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3820.             }

  3822.         } else {
  3823.             con = this.globalConnection;
  3824.         }
  3825.         
  3826.         try {

  3828.             this.logDebug("operazione this.atomica = " + this.atomica);
  3829.             
  3830.             // istanzio il driver
  3831.             driver = new DriverRegistroServiziDB(con, this.log, this.tipoDB);

  3833.             driver.updateProprietaOggettoErogazione(idServizio,user);
  3834.             
  3835.         } catch (Exception e) {
  3836.             String msgError = "[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + e.getMessage();
  3837.             ControlStationCore.logError(msgError, e);
  3838.             if(throwException) {
  3839.                 throw new DriverRegistroServiziException(msgError, e);
  3840.             }
  3841.         } finally {
  3842.             releaseConnection(con);
  3843.         }
  3844.     }
  3845.     public void updateProprietaOggettoFruizione(IDServizio idServizio, IDSoggetto idFruitore, String user, boolean throwException) throws DriverRegistroServiziException{
  3846.         Connection con = null;
  3847.         String nomeMetodo = "updateProprietaOggettoFruizione";
  3848.         DriverRegistroServiziDB driver = null;

  3850.         if (this.atomica) {
  3851.             try {
  3852.                 con = this.datasource.getConnection();
  3853.             } catch (Exception e) {
  3854.                 throw new DriverRegistroServiziException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3856.             }

  3858.         } else {
  3859.             con = this.globalConnection;
  3860.         }
  3861.         
  3862.         try {

  3864.             this.logDebug("operazione this.atomica = " + this.atomica);
  3865.             
  3866.             // istanzio il driver
  3867.             driver = new DriverRegistroServiziDB(con, this.log, this.tipoDB);

  3869.             driver.updateProprietaOggettoFruizione(idServizio,idFruitore,user);
  3870.             
  3871.         } catch (Exception e) {
  3872.             String msgError = "[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + e.getMessage();
  3873.             ControlStationCore.logError(msgError, e);
  3874.             if(throwException) {
  3875.                 throw new DriverRegistroServiziException(msgError, e);
  3876.             }
  3877.         } finally {
  3878.             releaseConnection(con);
  3879.         }
  3880.     }
  3881.     public void updateProprietaOggettoFruizione(long idFruizione, String user, boolean throwException) throws DriverRegistroServiziException{
  3882.         Connection con = null;
  3883.         String nomeMetodo = "updateProprietaOggettoFruizione";
  3884.         DriverRegistroServiziDB driver = null;

  3886.         if (this.atomica) {
  3887.             try {
  3888.                 con = this.datasource.getConnection();
  3889.             } catch (Exception e) {
  3890.                 throw new DriverRegistroServiziException("[DriverConfigurazioneDB::" + nomeMetodo + "] Exception accedendo al datasource :" + e.getMessage(),e);

  3892.             }

  3894.         } else {
  3895.             con = this.globalConnection;
  3896.         }
  3897.         
  3898.         try {

  3900.             this.logDebug("operazione this.atomica = " + this.atomica);
  3901.             
  3902.             // istanzio il driver
  3903.             driver = new DriverRegistroServiziDB(con, this.log, this.tipoDB);

  3905.             driver.updateProprietaOggettoFruizione(idFruizione,user);
  3906.             
  3907.         } catch (Exception e) {
  3908.             String msgError = "[DriverConfigurazioneDB::" + nomeMetodo + "] Errore : " + e.getMessage();
  3909.             ControlStationCore.logError(msgError, e);
  3910.             if(throwException) {
  3911.                 throw new DriverRegistroServiziException(msgError, e);
  3912.             }
  3913.         } finally {
  3914.             releaseConnection(con);
  3915.         }
  3916.     }
  3917. }
Created with JaCoCo 0.8.8.202204050719