DriverUsersDB.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.lib.users;

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

  35. import javax.sql.DataSource;

  37. import org.openspcoop2.core.commons.DBUtils;
  38. import org.openspcoop2.core.commons.Filtri;
  39. import org.openspcoop2.core.commons.ISearch;
  40. import org.openspcoop2.core.commons.Liste;
  41. import org.openspcoop2.core.commons.SearchUtils;
  42. import org.openspcoop2.core.commons.search.AccordoServizioParteSpecifica;
  43. import org.openspcoop2.core.commons.search.Soggetto;
  44. import org.openspcoop2.core.commons.search.dao.IDBAccordoServizioParteSpecificaServiceSearch;
  45. import org.openspcoop2.core.commons.search.dao.IDBSoggettoServiceSearch;
  46. import org.openspcoop2.core.commons.search.dao.jdbc.JDBCServiceManager;
  47. import org.openspcoop2.core.constants.CostantiDB;
  48. import org.openspcoop2.core.id.IDServizio;
  49. import org.openspcoop2.core.id.IDSoggetto;
  50. import org.openspcoop2.core.registry.constants.PddTipologia;
  51. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  52. import org.openspcoop2.generic_project.dao.jdbc.JDBCServiceManagerProperties;
  53. import org.openspcoop2.protocol.sdk.tracciamento.DriverTracciamentoException;
  54. import org.openspcoop2.utils.LoggerWrapperFactory;
  55. import org.openspcoop2.utils.TipiDatabase;
  56. import org.openspcoop2.utils.date.DateManager;
  57. import org.openspcoop2.utils.resources.GestoreJNDI;
  58. import org.openspcoop2.utils.sql.ISQLQueryObject;
  59. import org.openspcoop2.utils.sql.SQLObjectFactory;
  60. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  61. import org.openspcoop2.web.lib.users.dao.PermessiUtente;
  62. import org.openspcoop2.web.lib.users.dao.Stato;
  63. import org.openspcoop2.web.lib.users.dao.UserObjects;
  64. import org.openspcoop2.web.lib.users.dao.User;
  65. import org.openspcoop2.web.lib.users.dao.UserPassword;
  66. import org.slf4j.Logger;

  68. /**
  69.  * Sono forniti metodi per la lettura dei dati di Users
  70.  * 
  71.  * 
  72.  * @author Andrea Poli (apoli@link.it)
  73.  * @author Stefano Corallo (corallo@link.it)
  74.  * @author Sandra Giangrandi (sandra@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  * 
  78.  */

  80. public class DriverUsersDB {

  82.      private static final String LOG_DRIVER_DB_USER = "DRIVER_DB_USER";
  83.     
  84.     /** 
  85.      * DataSource
  86.      */
  87.     private DataSource datasource = null;
  88.     /** 
  89.      * Connessione
  90.      */
  91.     private Connection connection = null;
  92.     private boolean connectionOpenViaJDBCInCostructor = false;
  93.     /**
  94.      * SQLQueryObject
  95.      */
  96.     String tipoDatabase = null;
  97.     /** 
  98.      * Logger
  99.      */
  100.     private Logger log;

  102.     
  103.     public void close() throws DriverTracciamentoException {
  104.         try{
  105.             if(this.connectionOpenViaJDBCInCostructor){
  106.                 if(this.connection!=null && this.connection.isClosed()==false){
  107.                     this.connection.close();
  108.                 }
  109.             }
  110.         }catch(Exception e){
  111.             throw new DriverTracciamentoException(e.getMessage(),e);
  112.         }
  113.     }
  114.     
  115.     
  116.     
  117.     public DriverUsersDB(String nomeDataSource, String tipoDatabase, Properties jndiContext) throws DriverUsersDBException {
  118.         this(nomeDataSource, tipoDatabase, jndiContext, null);
  119.     }
  120.     public DriverUsersDB(String nomeDataSource, String tipoDatabase, Properties jndiContext, Logger log) throws DriverUsersDBException {
  121.         
  122.         // Logger
  123.         try {
  124.             if(log==null)
  125.                 this.log = LoggerWrapperFactory.getLogger(LOG_DRIVER_DB_USER);
  126.             else
  127.                 this.log = log;
  128.         } catch (Exception e) {
  129.             throw new DriverUsersDBException("Errore durante l'inizializzazione del logger...",e);
  130.         }

  132.         // Datasource
  133.         try {
  134.             this.log.info("Inizializzo DriverUsersDB...");
  135.             GestoreJNDI gestoreJNDI = new GestoreJNDI(jndiContext);
  136.             this.datasource = (DataSource) gestoreJNDI.lookup(nomeDataSource);
  137.             if (this.datasource == null)
  138.                 throw new Exception ("datasource is null");

  140.             this.log.info("Inizializzo DriverUsersDB terminata.");
  141.         } catch (Exception e) {
  142.             this.log.error("Errore durante la ricerca del datasource...",e);
  143.             throw new DriverUsersDBException("Errore durante la ricerca del datasource...",e);
  144.         }

  146.         // ISQLQueryObject
  147.         try {
  148.             this.log.info("Inizializzo ISQLQueryObject...");
  149.             if (TipiDatabase.isAMember(tipoDatabase)) {
  150.                 this.tipoDatabase = tipoDatabase;               
  151.             } else {
  152.                 throw new Exception("Tipo database non gestito");
  153.             }
  154.             this.log.info("Inizializzo ISQLQueryObject terminata.");

  156.         } catch (Exception e) {
  157.             this.log.error("Errore durante la ricerca del SQLQueryObject...",e);
  158.             throw new DriverUsersDBException("Errore durante la ricerca del SQLQueryObject...",e);
  159.         }
  160.         
  161.     }
  162.     
  163.     public DriverUsersDB(DataSource dataSourceObject, String tipoDatabase) throws DriverUsersDBException {
  164.         this(dataSourceObject, tipoDatabase, null);
  165.     }
  166.     public DriverUsersDB(DataSource dataSourceObject, String tipoDatabase, Logger log) throws DriverUsersDBException {
  167.         
  168.         // Logger
  169.         try {
  170.             if(log==null)
  171.                 this.log = LoggerWrapperFactory.getLogger(LOG_DRIVER_DB_USER);
  172.             else
  173.                 this.log = log;
  174.         } catch (Exception e) {
  175.             throw new DriverUsersDBException("Errore durante l'inizializzazione del logger...",e);
  176.         }

  178.         // Datasource
  179.         try {
  180.             this.datasource = dataSourceObject;
  181.             if (this.datasource == null)
  182.                 throw new Exception ("datasource is null");
  183.         } catch (Exception e) {
  184.             this.log.error("Errore durante la ricerca del datasource...",e);
  185.             throw new DriverUsersDBException("Errore durante la ricerca del datasource...",e);
  186.         }

  188.         // ISQLQueryObject
  189.         try {
  190.             this.log.info("Inizializzo ISQLQueryObject...");
  191.             if (TipiDatabase.isAMember(tipoDatabase)) {
  192.                 this.tipoDatabase = tipoDatabase;               
  193.             } else {
  194.                 throw new Exception("Tipo database non gestito");
  195.             }
  196.             this.log.info("Inizializzo ISQLQueryObject terminata.");

  198.         } catch (Exception e) {
  199.             this.log.error("Errore durante la ricerca del SQLQueryObject...",e);
  200.             throw new DriverUsersDBException("Errore durante la ricerca del SQLQueryObject...",e);
  201.         }
  202.     }
  203.     
  204.     public DriverUsersDB(Connection connection, String tipoDatabase) throws DriverUsersDBException {
  205.         this(connection, tipoDatabase, null);
  206.     }
  207.     public DriverUsersDB(Connection connection, String tipoDatabase, Logger log) throws DriverUsersDBException {
  208.         
  209.         // Logger
  210.         try {
  211.             if(log==null)
  212.                 this.log = LoggerWrapperFactory.getLogger(LOG_DRIVER_DB_USER);
  213.             else
  214.                 this.log = log;
  215.         } catch (Exception e) {
  216.             throw new DriverUsersDBException("Errore durante l'inizializzazione del logger...",e);
  217.         }

  219.         // connection
  220.         this.connection = connection;
  221.         
  222.         // ISQLQueryObject
  223.         try {
  224.             this.log.info("Inizializzo ISQLQueryObject...");
  225.             if (TipiDatabase.isAMember(tipoDatabase)) {
  226.                 this.tipoDatabase = tipoDatabase;               
  227.             } else {
  228.                 throw new Exception("Tipo database non gestito");
  229.             }
  230.             this.log.info("Inizializzo ISQLQueryObject terminata.");

  232.         } catch (Exception e) {
  233.             this.log.error("Errore durante la ricerca del SQLQueryObject...",e);
  234.             throw new DriverUsersDBException("Errore durante la ricerca del SQLQueryObject...",e);
  235.         }
  236.     }
  237.     
  238.     public DriverUsersDB(String urlJDBC,String driverJDBC,
  239.             String username,String password, 
  240.             String tipoDatabase) throws DriverUsersDBException {
  241.         this(urlJDBC, driverJDBC, username, password, tipoDatabase, null);
  242.     }
  243.     public DriverUsersDB(String urlJDBC,String driverJDBC,
  244.             String username,String password, 
  245.             String tipoDatabase, Logger log) throws DriverUsersDBException {
  246.         
  247.         // Logger
  248.         try {
  249.             if(log==null)
  250.                 this.log = LoggerWrapperFactory.getLogger(LOG_DRIVER_DB_USER);
  251.             else
  252.                 this.log = log;
  253.         } catch (Exception e) {
  254.             throw new DriverUsersDBException("Errore durante l'inizializzazione del logger...",e);
  255.         }

  257.         // connection
  258.         try {
  259.             Class.forName(driverJDBC);
  260.             
  261.             if(username!=null){
  262.                 this.connection = DriverManager.getConnection(urlJDBC,username,password);
  263.             }else{
  264.                 this.connection = DriverManager.getConnection(urlJDBC);
  265.             }
  266.             this.connectionOpenViaJDBCInCostructor = true;
  267.             
  268.         } catch (Exception e) {
  269.             this.log.error("Errore durante l'inizializzazione della connessione...",e);
  270.             throw new DriverUsersDBException("Errore durante l'inizializzazione della connessione...",e);
  271.         }
  272.         
  273.         // ISQLQueryObject
  274.         try {
  275.             this.log.info("Inizializzo ISQLQueryObject...");
  276.             if (TipiDatabase.isAMember(tipoDatabase)) {
  277.                 this.tipoDatabase = tipoDatabase;               
  278.             } else {
  279.                 throw new Exception("Tipo database non gestito");
  280.             }
  281.             this.log.info("Inizializzo ISQLQueryObject terminata.");

  283.         } catch (Exception e) {
  284.             this.log.error("Errore durante la ricerca del SQLQueryObject...",e);
  285.             throw new DriverUsersDBException("Errore durante la ricerca del SQLQueryObject...",e);
  286.         }
  287.         
  288.     }
  289.     
  290.     
  291.     private Connection getConnection() throws Exception {
  292.         Connection connectionDB = null;
  293.         if(this.connection!=null)
  294.             connectionDB = this.connection;
  295.         else{
  296.             connectionDB = this.datasource.getConnection();
  297.         }
  298.         checkConnection(connectionDB);
  299.         return connectionDB;
  300.     }
  301.     private void checkConnection(Connection connectionDB) throws Exception {
  302.         if(connectionDB==null)
  303.             throw new Exception("Connection non ottenuta dal datasource["+this.datasource+"]");
  304.     }
  305.     private void releaseConnection(Connection connectionDB) {
  306.         try{
  307.             if(this.connection==null) {
  308.                 if(connectionDB!=null) {
  309.                     connectionDB.close();
  310.                 }
  311.             }
  312.         }catch(Exception eClose){
  313.             // close
  314.         }
  315.     }


  318.     /**
  319.      * Restituisce l'utente identificato da <var>login</var>
  320.      * 
  321.      * @param login
  322.      *                Identificatore di un utente
  323.      * @return L'utente identificato dal parametro.
  324.      */
  325.     public User getUser(String login) throws DriverUsersDBException {
  326.         if (login == null)
  327.             throw new DriverUsersDBException("[getUser] Parametri Non Validi");

  329.         Connection connectionDB = null;
  330.         try {
  331.             // Get Connection
  332.             connectionDB = getConnection();
  333.             
  334.             return getUser(connectionDB, login);
  335.             
  336.         } catch (SQLException se) {
  337.             throw new DriverUsersDBException("[DriverUsersDB::getUser] SqlException: " + se.getMessage(),se);
  338.         } catch (Exception ex) {
  339.             throw new DriverUsersDBException("[DriverUsersDB::getUser] Exception: " + ex.getMessage(),ex);
  340.         } finally {
  341.             releaseConnection(connectionDB);
  342.         }
  343.     }
  344.     
  345.     public User getUser(Connection conParam, String login) throws DriverUsersDBException {
  346.         if (login == null)
  347.             throw new DriverUsersDBException("[getUser] Parametri Non Validi");

  349.         User user = null;
  350.         PreparedStatement stm = null;
  351.         ResultSet rs = null;

  353.         try {
  354.             
  355.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  356.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  357.             sqlQueryObject.addSelectField("*");
  358.             sqlQueryObject.addWhereCondition("login = ?");
  359.             String sqlQuery = sqlQueryObject.createSQLQuery();
  360.             stm = conParam.prepareStatement(sqlQuery);
  361.             stm.setString(1, login);
  362.             rs = stm.executeQuery();
  363.             if (rs.next()) {
  364.                 user = new User();
  365.                 user.setId(Long.valueOf(rs.getInt("id")));
  366.                 user.setLogin(login);
  367.                 user.setPassword(rs.getString("password"));
  368.                 user.setLastUpdatePassword(rs.getTimestamp("data_password"));
  369.                 user.setCheckLastUpdatePassword(rs.getInt("check_data_password") == CostantiDB.TRUE);
  370.                 
  371.                 String gui =rs.getString("tipo_interfaccia");
  372.                 if(gui==null || "".equals(gui))
  373.                     user.setInterfaceType(InterfaceType.AVANZATA);
  374.                 else
  375.                     user.setInterfaceType(InterfaceType.valueOf(gui.toUpperCase()));

  377.                 int interfaceCompletePermit = rs.getInt("interfaccia_completa");
  378.                 if(CostantiDB.TRUE == interfaceCompletePermit) {
  379.                     user.setPermitInterfaceComplete(true);
  380.                 }
  381.                 else {
  382.                     user.setPermitInterfaceComplete(false);
  383.                 }
  384.                 
  385.                 String perm =rs.getString("permessi");
  386.                 user.setPermessi(PermessiUtente.toPermessiUtente(perm));
  387.                 
  388.                 String protocolli =rs.getString("protocolli");
  389.                 user.setProtocolliSupportatiFromString(protocolli);
  390.                 
  391.                 String protocollo_pddconsole =rs.getString("protocollo_pddconsole");
  392.                 user.setProtocolloSelezionatoPddConsole(protocollo_pddconsole);
  393.                 
  394.                 String protocollo_pddmonitor =rs.getString("protocollo_pddmonitor");
  395.                 user.setProtocolloSelezionatoPddMonitor(protocollo_pddmonitor);
  396.                 
  397.                 String soggetto_pddconsole =rs.getString("soggetto_pddconsole");
  398.                 user.setSoggettoSelezionatoPddConsole(soggetto_pddconsole);
  399.                 
  400.                 String soggetto_pddmonitor =rs.getString("soggetto_pddmonitor");
  401.                 user.setSoggettoSelezionatoPddMonitor(soggetto_pddmonitor);
  402.                 
  403.                 int permitAllSoggetti = rs.getInt("soggetti_all");
  404.                 if(CostantiDB.TRUE == permitAllSoggetti) {
  405.                     user.setPermitAllSoggetti(true);
  406.                 }
  407.                 else {
  408.                     user.setPermitAllSoggetti(false);
  409.                 }
  410.                 
  411.                 int permitAllServizi = rs.getInt("servizi_all");
  412.                 if(CostantiDB.TRUE == permitAllServizi) {
  413.                     user.setPermitAllServizi(true);
  414.                 }
  415.                 else {
  416.                     user.setPermitAllServizi(false);
  417.                 }
  418.                 
  419.                 // Fix: se completa, siamo per forza in modalità completa
  420.                 if(user.isPermitInterfaceComplete()) {
  421.                     user.setInterfaceType(InterfaceType.COMPLETA);
  422.                 }
  423.                 
  424.             }
  425.             rs.close();
  426.             stm.close();
  427.             
  428.             if (user == null)
  429.                 throw new DriverUsersDBException("[DriverUsersDB::getUser] User [" + login + "] non esistente.");
  430.             
  431.             JDBCServiceManagerProperties jdbcProperties = new JDBCServiceManagerProperties();
  432.             jdbcProperties.setDatabaseType(this.tipoDatabase);
  433.             jdbcProperties.setShowSql(true);
  434.             JDBCServiceManager search = new JDBCServiceManager(conParam, jdbcProperties, this.log);
  435.             IDBSoggettoServiceSearch soggettiSearch = (IDBSoggettoServiceSearch) search.getSoggettoServiceSearch();
  436.             IDBAccordoServizioParteSpecificaServiceSearch serviziSearch = (IDBAccordoServizioParteSpecificaServiceSearch) search.getAccordoServizioParteSpecificaServiceSearch();
  437.             
  438.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  439.             sqlQueryObject.addFromTable(CostantiDB.USERS_STATI);
  440.             sqlQueryObject.addSelectField("*");
  441.             sqlQueryObject.addWhereCondition("id_utente = ?");
  442.             sqlQueryObject.addOrderBy(CostantiDB.USERS_STATI+".oggetto");
  443.             sqlQueryObject.setSortType(true);
  444.             sqlQueryObject.setANDLogicOperator(true);
  445.             sqlQuery = sqlQueryObject.createSQLQuery();
  446.             stm = conParam.prepareStatement(sqlQuery);
  447.             stm.setLong(1, user.getId());
  448.             rs = stm.executeQuery();
  449.             while (rs.next()) {
  450.                 String oggetto = rs.getString("oggetto");
  451.                 String stato = rs.getString("stato");
  452.                 Stato statoObject = new Stato();
  453.                 statoObject.setOggetto(oggetto);
  454.                 statoObject.setStato(stato);
  455.                 user.getStati().add(statoObject);
  456.             }
  457.             rs.close();
  458.             stm.close();
  459.             
  460.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  461.             sqlQueryObject.addFromTable(CostantiDB.USERS_PASSWORD);
  462.             sqlQueryObject.addSelectField("*");
  463.             sqlQueryObject.addWhereCondition("id_utente = ?");
  464.             sqlQueryObject.addOrderBy(CostantiDB.USERS_PASSWORD+".data_password");
  465.             sqlQueryObject.setSortType(false);
  466.             sqlQueryObject.setANDLogicOperator(true);
  467.             sqlQuery = sqlQueryObject.createSQLQuery();
  468.             stm = conParam.prepareStatement(sqlQuery);
  469.             stm.setLong(1, user.getId());
  470.             rs = stm.executeQuery();
  471.             while (rs.next()) {
  472.                 UserPassword userPassword = new UserPassword();
  473.                 userPassword.setPassword(rs.getString("password"));
  474.                 userPassword.setDatePassword(rs.getTimestamp("data_password"));
  475.                 user.getPrecedentiPassword().add(userPassword);
  476.             }
  477.             rs.close();
  478.             stm.close();
  479.             
  480.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  481.             sqlQueryObject.addFromTable(CostantiDB.USERS_SOGGETTI);
  482.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  483.             sqlQueryObject.addSelectField(CostantiDB.USERS_SOGGETTI+".id_soggetto");
  484.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".nome_soggetto");
  485.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".tipo_soggetto");
  486.             sqlQueryObject.addWhereCondition("id_utente = ?");
  487.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SOGGETTI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  488.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".nome_soggetto");
  489.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".tipo_soggetto");
  490.             sqlQueryObject.setSortType(true);
  491.             sqlQueryObject.setANDLogicOperator(true);
  492.             sqlQuery = sqlQueryObject.createSQLQuery();
  493.             stm = conParam.prepareStatement(sqlQuery);
  494.             stm.setLong(1, user.getId());
  495.             rs = stm.executeQuery();
  496.             while (rs.next()) {
  497.                 long id = rs.getLong("id_soggetto");
  498.                 Soggetto soggetto = soggettiSearch.get(id);
  499.                 IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipoSoggetto(), soggetto.getNomeSoggetto(), soggetto.getIdentificativoPorta());
  500.                 user.getSoggetti().add(idSoggetto);
  501.             }
  502.             rs.close();
  503.             stm.close();
  504.             
  505.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  506.             sqlQueryObject.addFromTable(CostantiDB.USERS_SERVIZI);
  507.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  508.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  509.             sqlQueryObject.addSelectField(CostantiDB.USERS_SERVIZI+".id_servizio");
  510.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI+".tipo_servizio");
  511.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI+".nome_servizio");
  512.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI+".versione_servizio");
  513.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".tipo_soggetto");
  514.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".nome_soggetto");
  515.             sqlQueryObject.addWhereCondition("id_utente = ?");
  516.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SERVIZI+".id_servizio = "+CostantiDB.SERVIZI+".id");
  517.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  518.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI+".nome_servizio");
  519.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI+".versione_servizio");
  520.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".nome_soggetto");
  521.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI+".tipo_servizio");
  522.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".tipo_soggetto");
  523.             sqlQueryObject.setSortType(true);
  524.             sqlQueryObject.setANDLogicOperator(true);
  525.             sqlQuery = sqlQueryObject.createSQLQuery();
  526.             stm = conParam.prepareStatement(sqlQuery);
  527.             stm.setLong(1, user.getId());
  528.             rs = stm.executeQuery();
  529.             while (rs.next()) {
  530.                 long id = rs.getLong("id_servizio");
  531.                 AccordoServizioParteSpecifica servizio = serviziSearch.get(id);
  532.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(servizio.getTipo(), 
  533.                         servizio.getNome(), 
  534.                         servizio.getIdErogatore().getTipo(),
  535.                         servizio.getIdErogatore().getNome(), 
  536.                         servizio.getVersione());
  537.                 user.getServizi().add(idServizio);
  538.             }
  539.             rs.close();
  540.             stm.close();


  543.             return user;
  544.         } catch (SQLException se) {
  545.             throw new DriverUsersDBException("[DriverUsersDB::getUser] SqlException: " + se.getMessage(),se);
  546.         } catch (Exception ex) {
  547.             throw new DriverUsersDBException("[DriverUsersDB::getUser] Exception: " + ex.getMessage(),ex);
  548.         } finally {
  549.             try {
  550.                 rs.close();
  551.             } catch (Exception e) {
  552.                 // ignore exception
  553.             }
  554.             try {
  555.                 stm.close();
  556.             } catch (Exception e) {
  557.                 // ignore exception
  558.             }
  559.         }
  560.     }

  562.     public User getUser(Long id) throws DriverUsersDBException {
  563.         if (id == null || id<=0)
  564.             throw new DriverUsersDBException("[getUser] Parametri Non Validi");

  566.         Connection connectionDB = null;
  567.         User user = null;
  568.         PreparedStatement stm = null;
  569.         ResultSet rs = null;

  571.         try {
  572.             // Get Connection
  573.             connectionDB = getConnection();
  574.             
  575.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  576.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  577.             sqlQueryObject.addSelectField("login");
  578.             sqlQueryObject.addWhereCondition("id = ?");
  579.             String sqlQuery = sqlQueryObject.createSQLQuery();
  580.             stm = connectionDB.prepareStatement(sqlQuery);
  581.             stm.setLong(1, id);
  582.             rs = stm.executeQuery();
  583.             if (rs.next()) {
  584.                 user = this.getUser(connectionDB, rs.getString("login"));
  585.             }
  586.             rs.close();
  587.             stm.close();

  589.             if (user == null)
  590.                 throw new DriverUsersDBException("[DriverUsersDB::getUser] User [id:" + id + "] non esistente.");

  592.             return user;
  593.         } catch (SQLException se) {
  594.             throw new DriverUsersDBException("[DriverUsersDB::getUser] SqlException: " + se.getMessage(),se);
  595.         } catch (Exception ex) {
  596.             throw new DriverUsersDBException("[DriverUsersDB::getUser] Exception: " + ex.getMessage(),ex);
  597.         } finally {
  598.             try {
  599.                 if(rs!=null) {
  600.                     rs.close();
  601.                 }
  602.             } catch (Exception e) {
  603.                 // ignore exception
  604.             }
  605.             try {
  606.                 if(stm!=null) {
  607.                     stm.close();
  608.                 }
  609.             } catch (Exception e) {
  610.                 // ignore exception
  611.             }
  612.             releaseConnection(connectionDB);

  614.         }
  615.     }
  616.     
  617.     public List<User> userList(ISearch ricerca) throws DriverUsersDBException {
  618.         return userList(ricerca,Liste.SU);
  619.     }
  620.     public List<User> userList(ISearch ricerca, int IDLISTA) throws DriverUsersDBException {
  621.         
  622.         String nomeMetodo = "userList";
  623.         int idLista = IDLISTA;
  624.         int offset;
  625.         int limit;
  626.         String search;
  627.         String queryString;

  629.         limit = ricerca.getPageSize(idLista);
  630.         offset = ricerca.getIndexIniziale(idLista);
  631.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  633.         Connection connectionDB = null;
  634.         PreparedStatement stmt = null;
  635.         ResultSet risultato = null;
  636.         ArrayList<User> lista = new ArrayList<User>();

  638.         try {
  639.             // Get Connection
  640.             connectionDB = getConnection();
  641.             
  642.             if (!search.equals("")) {
  643.                 //query con search
  644.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  645.                 sqlQueryObject.addFromTable(CostantiDB.USERS);
  646.                 sqlQueryObject.addSelectCountField("*", "cont");
  647.                 sqlQueryObject.addWhereLikeCondition("login", search, true, true);
  648.                 queryString = sqlQueryObject.createSQLQuery();
  649.             } else {
  650.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  651.                 sqlQueryObject.addFromTable(CostantiDB.USERS);
  652.                 sqlQueryObject.addSelectCountField("*", "cont");
  653.                 queryString = sqlQueryObject.createSQLQuery();
  654.             }
  655.             stmt = connectionDB.prepareStatement(queryString);
  656.             risultato = stmt.executeQuery();
  657.             if (risultato.next())
  658.                 ricerca.setNumEntries(idLista, risultato.getInt(1));
  659.             risultato.close();
  660.             stmt.close();

  662.             // ricavo le entries
  663.             if (limit == 0) // con limit
  664.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  665.             if (!search.equals("")) { // con search
  666.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  667.                 sqlQueryObject.addFromTable(CostantiDB.USERS);
  668.                 sqlQueryObject.addSelectField("login");
  669.                 sqlQueryObject.addWhereLikeCondition("login", search, true, true);
  670.                 sqlQueryObject.addOrderBy("login");
  671.                 sqlQueryObject.setSortType(true);
  672.                 sqlQueryObject.setLimit(limit);
  673.                 sqlQueryObject.setOffset(offset);
  674.                 queryString = sqlQueryObject.createSQLQuery();
  675.             } else {
  676.                 // senza search
  677.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  678.                 sqlQueryObject.addFromTable(CostantiDB.USERS);
  679.                 sqlQueryObject.addSelectField("login");
  680.                 sqlQueryObject.addOrderBy("login");
  681.                 sqlQueryObject.setSortType(true);
  682.                 sqlQueryObject.setLimit(limit);
  683.                 sqlQueryObject.setOffset(offset);
  684.                 queryString = sqlQueryObject.createSQLQuery();
  685.             }
  686.             stmt = connectionDB.prepareStatement(queryString);
  687.             risultato = stmt.executeQuery();

  689.             User newU = null;
  690.             while (risultato.next()) {
  691.                 newU = this.getUser(connectionDB, risultato.getString("login"));
  692.                 lista.add(newU);
  693.             }
  694.             risultato.close();
  695.             return lista;

  697.         } catch (Exception qe) {
  698.             throw new DriverUsersDBException("[DriverUsersDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  699.         } finally {

  701.             //Chiudo statement and resultset
  702.             try {
  703.                 if(risultato!=null) {
  704.                     risultato.close();
  705.                 }
  706.             } catch (Exception e) {
  707.                 // ignore exception
  708.             }
  709.             try {
  710.                 if(stmt!=null) {
  711.                     stmt.close();
  712.                 }
  713.             } catch (Exception e) {
  714.                 // ignore exception
  715.             }
  716.             releaseConnection(connectionDB);

  718.         }
  719.     }

  721.     public boolean existsUser(String login) throws DriverUsersDBException {
  722.         
  723.         Connection connectionDB = null;
  724.         PreparedStatement stm = null;
  725.         ResultSet rs = null;
  726.         String sqlQuery = "";

  728.         try {
  729.             // Get Connection
  730.             connectionDB = getConnection();
  731.                         
  732.             boolean esiste = false;
  733.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  734.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  735.             sqlQueryObject.addSelectField("*");
  736.             sqlQueryObject.addWhereCondition("login = ?");
  737.             sqlQuery = sqlQueryObject.createSQLQuery();
  738.             stm = connectionDB.prepareStatement(sqlQuery);
  739.             stm.setString(1, login);
  740.             rs = stm.executeQuery();
  741.             if (rs.next())
  742.                 esiste = true;
  743.             rs.close();
  744.             stm.close();

  746.             return esiste;
  747.         } catch (Exception qe) {
  748.             throw new DriverUsersDBException(qe.getMessage(),qe);
  749.         } finally {

  751.             //Chiudo statement and resultset
  752.             try {
  753.                 if(rs!=null) {
  754.                     rs.close();
  755.                 }
  756.             } catch (Exception e) {
  757.                 // ignore exception
  758.             }
  759.             try {
  760.                 if(stm!=null) {
  761.                     stm.close();
  762.                 }
  763.             } catch (Exception e) {
  764.                 // ignore exception
  765.             }
  766.             
  767.             releaseConnection(connectionDB);

  769.         }
  770.     }

  772.     public List<String> getUsersByPermesso(String permesso) throws DriverUsersDBException {
  773.         
  774.         Connection connectionDB = null;
  775.         PreparedStatement stm = null;
  776.         ResultSet rs = null;
  777.         String sqlQuery = "";

  779.         try {
  780.             // Get Connection
  781.             connectionDB = getConnection();
  782.             
  783.             List<String> userWithType = new ArrayList<>();
  784.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  785.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  786.             sqlQueryObject.addSelectField("*");
  787.             sqlQueryObject.setANDLogicOperator(true);
  788.             sqlQueryObject.addWhereLikeCondition("permessi", permesso, true, true);
  789.             sqlQuery = sqlQueryObject.createSQLQuery();
  790.             stm = connectionDB.prepareStatement(sqlQuery);
  791.             rs = stm.executeQuery();
  792.             while (rs.next())
  793.                 userWithType.add(rs.getString("login"));
  794.             rs.close();
  795.             stm.close();

  797.             return userWithType;
  798.         } catch (Exception qe) {
  799.             throw new DriverUsersDBException(qe.getMessage(),qe);
  800.         } finally {

  802.             //Chiudo statement and resultset
  803.             try {
  804.                 if(rs!=null) {
  805.                     rs.close();
  806.                 }
  807.             } catch (Exception e) {
  808.                 // ignore exception
  809.             }
  810.             try {
  811.                 if(stm!=null) {
  812.                     stm.close();
  813.                 }
  814.             } catch (Exception e) {
  815.                 // ignore exception
  816.             }
  817.             
  818.             releaseConnection(connectionDB);

  820.         }
  821.     }
  822.     
  823.     public List<String> getUsersByProtocolloSupportato(String protocollo) throws DriverUsersDBException {
  824.         return getUsersByProtocolloSupportato(protocollo, false);
  825.     }
  826.     
  827.     public List<String> getUsersByProtocolloSupportato(String protocollo, boolean esclusiUtentiConSoloPermessoUtente) throws DriverUsersDBException {
  828.         
  829.         Connection connectionDB = null;
  830.         PreparedStatement stm = null;
  831.         ResultSet rs = null;
  832.         String sqlQuery = "";

  834.         try {
  835.             // Get Connection
  836.             connectionDB = getConnection();
  837.             
  838.             List<String> userWithType = new ArrayList<>();
  839.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  840.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  841.             sqlQueryObject.addSelectField("*");
  842.             sqlQueryObject.setANDLogicOperator(true);
  843.             
  844.             ISQLQueryObject sqlQueryObjectPermit = sqlQueryObject.newSQLQueryObject();
  845.             sqlQueryObjectPermit.addWhereIsNullCondition("protocolli"); // significa che li supporta tutti
  846.             sqlQueryObjectPermit.addWhereLikeCondition("protocolli", protocollo, true, true);
  847.             sqlQueryObjectPermit.setANDLogicOperator(false);
  848.             sqlQueryObject.addWhereCondition(sqlQueryObjectPermit.createSQLConditions());
  849.             if(esclusiUtentiConSoloPermessoUtente)
  850.                 sqlQueryObject.addWhereCondition("permessi <> ?");
  851.             
  852.             sqlQuery = sqlQueryObject.createSQLQuery();
  853.             stm = connectionDB.prepareStatement(sqlQuery);
  854.             
  855.             if(esclusiUtentiConSoloPermessoUtente)
  856.                 stm.setString(1, "U");
  857.             
  858.             rs = stm.executeQuery();
  859.             while (rs.next())
  860.                 userWithType.add(rs.getString("login"));
  861.             rs.close();
  862.             stm.close();

  864.             return userWithType;
  865.         } catch (Exception qe) {
  866.             throw new DriverUsersDBException(qe.getMessage(),qe);
  867.         } finally {

  869.             //Chiudo statement and resultset
  870.             try {
  871.                 if(rs!=null) {
  872.                     rs.close();
  873.                 }
  874.             } catch (Exception e) {
  875.                 // ignore exception
  876.             }
  877.             try {
  878.                 if(stm!=null) {
  879.                     stm.close();
  880.                 }
  881.             } catch (Exception e) {
  882.                 // ignore exception
  883.             }
  884.             
  885.             releaseConnection(connectionDB);

  887.         }
  888.     }

  890.     public void createUser(User user) throws DriverUsersDBException {
  891.         
  892.         Connection connectionDB = null;
  893.         PreparedStatement stm = null;
  894.         ResultSet rs = null;
  895.         String sqlQuery = "";

  897.         if (user == null)
  898.             throw new DriverUsersDBException("[DriverUsersDB::createUser] Parametro non valido.");

  900.         String login = user.getLogin();
  901.         if (login == null || login.equals(""))
  902.             throw new DriverUsersDBException("[DriverUsersDB::createUser] Parametro Login non valido.");

  904.         try {
  905.             // Get Connection
  906.             connectionDB = getConnection();
  907.             
  908.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  909.             sqlQueryObject.addInsertTable(CostantiDB.USERS);
  910.             sqlQueryObject.addInsertField("login", "?");
  911.             sqlQueryObject.addInsertField("password", "?");
  912.             sqlQueryObject.addInsertField("data_password", "?");
  913.             sqlQueryObject.addInsertField("check_data_password", "?");
  914.             sqlQueryObject.addInsertField("tipo_interfaccia", "?");
  915.             sqlQueryObject.addInsertField("interfaccia_completa", "?");
  916.             sqlQueryObject.addInsertField("permessi", "?");
  917.             sqlQueryObject.addInsertField("protocolli", "?");
  918.             sqlQueryObject.addInsertField("protocollo_pddconsole", "?");
  919.             sqlQueryObject.addInsertField("protocollo_pddmonitor", "?");
  920.             sqlQueryObject.addInsertField("soggetto_pddconsole", "?");
  921.             sqlQueryObject.addInsertField("soggetto_pddmonitor", "?");
  922.             sqlQueryObject.addInsertField("soggetti_all", "?");
  923.             sqlQueryObject.addInsertField("servizi_all", "?");
  924.             sqlQuery = sqlQueryObject.createSQLInsert();
  925.             stm = connectionDB.prepareStatement(sqlQuery);
  926.             int index = 1;
  927.             stm.setString(index++, login);
  928.             stm.setString(index++, user.getPassword());
  929.             Timestamp dataPassword = DateManager.getTimestamp();
  930.             if(user.getLastUpdatePassword()!=null) {
  931.                 dataPassword = new Timestamp(user.getLastUpdatePassword().getTime());
  932.             }
  933.             stm.setTimestamp(index++, dataPassword);
  934.             stm.setInt(index++, user.isCheckLastUpdatePassword()? CostantiDB.TRUE : CostantiDB.FALSE);
  935.             stm.setString(index++, user.getInterfaceType().toString());
  936.             stm.setInt(index++, user.isPermitInterfaceComplete()? CostantiDB.TRUE : CostantiDB.FALSE);
  937.             stm.setString(index++, user.getPermessi().toString());
  938.             stm.setString(index++, user.getProtocolliSupportatiAsString());
  939.             stm.setString(index++, user.getProtocolloSelezionatoPddConsole());
  940.             stm.setString(index++, user.getProtocolloSelezionatoPddMonitor());
  941.             stm.setString(index++, user.getSoggettoSelezionatoPddConsole());
  942.             stm.setString(index++, user.getSoggettoSelezionatoPddMonitor());
  943.             stm.setInt(index++, user.isPermitAllSoggetti()? CostantiDB.TRUE : CostantiDB.FALSE);
  944.             stm.setInt(index++, user.isPermitAllServizi()? CostantiDB.TRUE : CostantiDB.FALSE);
  945.             stm.executeUpdate();
  946.             stm.close();
  947.                         
  948.             if(user.getStati().size()>0 || user.getPrecedentiPassword().size()>0 || user.getSoggetti().size()>0 || user.getServizi().size()>0) {
  949.             
  950.                 // recupero id
  951.                 long idUser = this._getIdUser(connectionDB, login);
  952.                 
  953.                 _addListeUtente(connectionDB, user, idUser);
  954.                 
  955.             }
  956.             
  957.         } catch (Exception qe) {
  958.             throw new DriverUsersDBException(qe.getMessage(),qe);
  959.         } finally {

  961.             //Chiudo statement and resultset
  962.             try {
  963.                 if (rs != null)
  964.                     rs.close();
  965.             } catch (Exception e) {
  966.                 //ignore
  967.             }
  968.             try {
  969.                 if (stm != null)
  970.                     stm.close();
  971.             } catch (Exception e) {
  972.                 //ignore
  973.             }
  974.             
  975.             try{
  976.                 if(this.connection==null) {
  977.                     connectionDB.close();
  978.                 }
  979.             }catch(Exception eClose){
  980.                 // close
  981.             }
  982.         }
  983.     }

  985.     public void updateUser(User user) throws DriverUsersDBException {
  986.         
  987.         Connection connectionDB = null;
  988.         PreparedStatement stm = null;
  989.         ResultSet rs = null;
  990.         String sqlQuery = "";

  992.         if (user == null)
  993.             throw new DriverUsersDBException("[DriverUsersDB::updateUser] Parametro non valido.");

  995.         String login = user.getLogin();
  996.         if (login == null || login.equals(""))
  997.             throw new DriverUsersDBException("[DriverUsersDB::updateUser] Parametro Login non valido.");

  999.         try {
  1000.             // Get Connection
  1001.             connectionDB = getConnection();
  1002.             
  1003.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1004.             sqlQueryObject.addUpdateTable(CostantiDB.USERS);
  1005.             sqlQueryObject.addUpdateField("password", "?");
  1006.             if(user.getLastUpdatePassword()!=null) {
  1007.                 sqlQueryObject.addUpdateField("data_password", "?");
  1008.             }
  1009.             sqlQueryObject.addUpdateField("check_data_password", "?");
  1010.             sqlQueryObject.addUpdateField("tipo_interfaccia", "?");
  1011.             sqlQueryObject.addUpdateField("interfaccia_completa", "?");
  1012.             sqlQueryObject.addUpdateField("permessi", "?");
  1013.             sqlQueryObject.addUpdateField("protocolli", "?");
  1014.             sqlQueryObject.addUpdateField("protocollo_pddconsole", "?");
  1015.             sqlQueryObject.addUpdateField("protocollo_pddmonitor", "?");
  1016.             sqlQueryObject.addUpdateField("soggetto_pddconsole", "?");
  1017.             sqlQueryObject.addUpdateField("soggetto_pddmonitor", "?");
  1018.             sqlQueryObject.addUpdateField("soggetti_all", "?");
  1019.             sqlQueryObject.addUpdateField("servizi_all", "?");
  1020.             sqlQueryObject.addWhereCondition("login=?");
  1021.             sqlQuery = sqlQueryObject.createSQLUpdate();
  1022.             stm = connectionDB.prepareStatement(sqlQuery);
  1023.             int index = 1;
  1024.             stm.setString(index++, user.getPassword());
  1025.             if(user.getLastUpdatePassword()!=null) {
  1026.                 stm.setTimestamp(index++, new Timestamp(user.getLastUpdatePassword().getTime()));
  1027.             }
  1028.             stm.setInt(index++, user.isCheckLastUpdatePassword()? CostantiDB.TRUE : CostantiDB.FALSE);
  1029.             stm.setString(index++,user.getInterfaceType().toString());
  1030.             stm.setInt(index++, user.isPermitInterfaceComplete()? CostantiDB.TRUE : CostantiDB.FALSE);
  1031.             stm.setString(index++,user.getPermessi().toString());
  1032.             stm.setString(index++, user.getProtocolliSupportatiAsString());
  1033.             stm.setString(index++, user.getProtocolloSelezionatoPddConsole());
  1034.             stm.setString(index++, user.getProtocolloSelezionatoPddMonitor());
  1035.             stm.setString(index++, user.getSoggettoSelezionatoPddConsole());
  1036.             stm.setString(index++, user.getSoggettoSelezionatoPddMonitor());
  1037.             stm.setInt(index++, user.isPermitAllSoggetti()? CostantiDB.TRUE : CostantiDB.FALSE);
  1038.             stm.setInt(index++, user.isPermitAllServizi()? CostantiDB.TRUE : CostantiDB.FALSE);
  1039.             stm.setString(index++, user.getLogin());
  1040.             stm.executeUpdate();
  1041.             stm.close();
  1042.             
  1043.             long idUser = this._getIdUser(connectionDB, user);
  1044.                 
  1045.             _deleteListeUtente(connectionDB, idUser);
  1046.             
  1047.             if(user.getStati().size()>0 || user.getPrecedentiPassword().size()>0 || user.getSoggetti().size()>0 || user.getServizi().size()>0) {
  1048.                 _addListeUtente(connectionDB, user, idUser);
  1049.             }
  1050.             
  1051.         } catch (Exception qe) {
  1052.             throw new DriverUsersDBException(qe.getMessage(),qe);
  1053.         } finally {

  1055.             //Chiudo statement and resultset
  1056.             try {
  1057.                 if (rs != null)
  1058.                     rs.close();
  1059.             } catch (Exception e) {
  1060.                 //ignore
  1061.             }
  1062.             try {
  1063.                 if (stm != null)
  1064.                     stm.close();
  1065.             } catch (Exception e) {
  1066.                 //ignore
  1067.             }
  1068.             
  1069.             releaseConnection(connectionDB);

  1071.         }
  1072.     }
  1073.     
  1074.     public void deleteUser(User user) throws DriverUsersDBException {
  1075.         
  1076.         Connection connectionDB = null;
  1077.         PreparedStatement stm = null;
  1078.         String sqlQuery = "";

  1080.         if (user == null)
  1081.             throw new DriverUsersDBException("[DriverUsersDB::deleteUser] Parametro non valido.");

  1083.         String login = user.getLogin();
  1084.         if (login == null || login.equals(""))
  1085.             throw new DriverUsersDBException("[DriverUsersDB::deleteUser] Parametro Login non valido.");

  1087.         try {
  1088.             // Get Connection
  1089.             connectionDB = getConnection();
  1090.             
  1091.             long idUser = this._getIdUser(connectionDB, user);
  1092.             
  1093.             _deleteListeUtente(connectionDB, idUser);
  1094.             
  1095.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1096.             sqlQueryObject.addDeleteTable(CostantiDB.USERS);
  1097.             sqlQueryObject.addWhereCondition("login = ?");
  1098.             sqlQuery = sqlQueryObject.createSQLDelete();
  1099.             stm = connectionDB.prepareStatement(sqlQuery);
  1100.             stm.setString(1, login);
  1101.             stm.executeUpdate();
  1102.             stm.close();
  1103.         } catch (Exception qe) {
  1104.             throw new DriverUsersDBException(qe.getMessage(),qe);
  1105.         } finally {

  1107.             //Chiudo statement and resultset
  1108.             try {
  1109.                 if (stm != null)
  1110.                     stm.close();
  1111.             } catch (Exception e) {
  1112.                 //ignore
  1113.             }
  1114.             
  1115.             releaseConnection(connectionDB);

  1117.         }
  1118.     }

  1120.     
  1121.     
  1122.     private void _addListeUtente(Connection connectionDB, User user, long idUser) throws Exception {
  1123.         
  1124.         PreparedStatement stm = null;
  1125.         ResultSet rs = null;
  1126.         try {
  1127.             if(user.getStati().size()>0) {
  1128.                 for (Stato stato : user.getStati()) {
  1129.                     
  1130.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1131.                     sqlQueryObject.addInsertTable(CostantiDB.USERS_STATI);
  1132.                     sqlQueryObject.addInsertField("id_utente", "?");
  1133.                     sqlQueryObject.addInsertField("oggetto", "?");
  1134.                     sqlQueryObject.addInsertField("stato", "?");
  1135.                     String sqlQuery = sqlQueryObject.createSQLInsert();
  1136.                     stm = connectionDB.prepareStatement(sqlQuery);
  1137.                     int index = 1;
  1138.                     stm.setLong(index++, idUser);
  1139.                     stm.setString(index++, stato.getOggetto());
  1140.                     stm.setString(index++, stato.getStato());
  1141.                     stm.executeUpdate();
  1142.                     stm.close();
  1143.                 }
  1144.             }
  1145.             
  1146.             if(user.getPrecedentiPassword().size()>0) {
  1147.                 for (UserPassword userPassword : user.getPrecedentiPassword()) {
  1148.                     
  1149.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1150.                     sqlQueryObject.addInsertTable(CostantiDB.USERS_PASSWORD);
  1151.                     sqlQueryObject.addInsertField("id_utente", "?");
  1152.                     sqlQueryObject.addInsertField("password", "?");
  1153.                     sqlQueryObject.addInsertField("data_password", "?");
  1154.                     String sqlQuery = sqlQueryObject.createSQLInsert();
  1155.                     stm = connectionDB.prepareStatement(sqlQuery);
  1156.                     int index = 1;
  1157.                     stm.setLong(index++, idUser);
  1158.                     stm.setString(index++, userPassword.getPassword());
  1159.                     stm.setTimestamp(index++, new Timestamp(userPassword.getDatePassword().getTime()));
  1160.                     stm.executeUpdate();
  1161.                     stm.close();
  1162.                 }
  1163.             }
  1164.             
  1165.             if(user.getSoggetti().size()>0) {
  1166.                 for (IDSoggetto idSoggetto : user.getSoggetti()) {
  1167.                     
  1168.                     long idSoggettoLong = DBUtils.getIdSoggetto(idSoggetto.getNome(), idSoggetto.getTipo(), connectionDB, this.tipoDatabase);
  1169.                     if(idSoggettoLong<=0) {
  1170.                         throw new Exception("Impossibile recuperare id soggetto ["+idSoggetto+"]");
  1171.                     }
  1172.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1173.                     sqlQueryObject.addInsertTable(CostantiDB.USERS_SOGGETTI);
  1174.                     sqlQueryObject.addInsertField("id_utente", "?");
  1175.                     sqlQueryObject.addInsertField("id_soggetto", "?");
  1176.                     String sqlQuery = sqlQueryObject.createSQLInsert();
  1177.                     stm = connectionDB.prepareStatement(sqlQuery);
  1178.                     int index = 1;
  1179.                     stm.setLong(index++, idUser);
  1180.                     stm.setLong(index++, idSoggettoLong);
  1181.                     stm.executeUpdate();
  1182.                     stm.close();
  1183.                 }
  1184.             }
  1185.             
  1186.             if(user.getServizi().size()>0) {
  1187.                 for (IDServizio idServizio : user.getServizi()) {
  1188.                     
  1189.                     long idServizioLong = DBUtils.getIdServizio(idServizio.getNome(), idServizio.getTipo(), idServizio.getVersione(),
  1190.                             idServizio.getSoggettoErogatore().getNome(), idServizio.getSoggettoErogatore().getTipo(), 
  1191.                             connectionDB, this.tipoDatabase);
  1192.                     if(idServizioLong<=0) {
  1193.                         throw new Exception("Impossibile recuperare id soggetto ["+idServizio+"]");
  1194.                     }
  1195.                     ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1196.                     sqlQueryObject.addInsertTable(CostantiDB.USERS_SERVIZI);
  1197.                     sqlQueryObject.addInsertField("id_utente", "?");
  1198.                     sqlQueryObject.addInsertField("id_servizio", "?");
  1199.                     String sqlQuery = sqlQueryObject.createSQLInsert();
  1200.                     stm = connectionDB.prepareStatement(sqlQuery);
  1201.                     int index = 1;
  1202.                     stm.setLong(index++, idUser);
  1203.                     stm.setLong(index++, idServizioLong);
  1204.                     stm.executeUpdate();
  1205.                     stm.close();
  1206.                 }
  1207.             }
  1208.         } finally {

  1210.             //Chiudo statement and resultset
  1211.             try {
  1212.                 if (rs != null)
  1213.                     rs.close();
  1214.             } catch (Exception e) {
  1215.                 //ignore
  1216.             }
  1217.             try {
  1218.                 if (stm != null)
  1219.                     stm.close();
  1220.             } catch (Exception e) {
  1221.                 //ignore
  1222.             }
  1223.             
  1224.         }
  1225.     }
  1226.     
  1227.     private void _deleteListeUtente(Connection connectionDB, long idUser) throws Exception {
  1228.         
  1229.         PreparedStatement stm = null;
  1230.         try {
  1231.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1232.             sqlQueryObject.addDeleteTable(CostantiDB.USERS_STATI);
  1233.             sqlQueryObject.addWhereCondition("id_utente = ?");
  1234.             String sqlQuery = sqlQueryObject.createSQLDelete();
  1235.             stm = connectionDB.prepareStatement(sqlQuery);
  1236.             stm.setLong(1, idUser);
  1237.             stm.executeUpdate();
  1238.             stm.close();
  1239.             
  1240.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1241.             sqlQueryObject.addDeleteTable(CostantiDB.USERS_PASSWORD);
  1242.             sqlQueryObject.addWhereCondition("id_utente = ?");
  1243.             sqlQuery = sqlQueryObject.createSQLDelete();
  1244.             stm = connectionDB.prepareStatement(sqlQuery);
  1245.             stm.setLong(1, idUser);
  1246.             stm.executeUpdate();
  1247.             stm.close();
  1248.             
  1249.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1250.             sqlQueryObject.addDeleteTable(CostantiDB.USERS_SOGGETTI);
  1251.             sqlQueryObject.addWhereCondition("id_utente = ?");
  1252.             sqlQuery = sqlQueryObject.createSQLDelete();
  1253.             stm = connectionDB.prepareStatement(sqlQuery);
  1254.             stm.setLong(1, idUser);
  1255.             stm.executeUpdate();
  1256.             stm.close();
  1257.             
  1258.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1259.             sqlQueryObject.addDeleteTable(CostantiDB.USERS_SERVIZI);
  1260.             sqlQueryObject.addWhereCondition("id_utente = ?");
  1261.             sqlQuery = sqlQueryObject.createSQLDelete();
  1262.             stm = connectionDB.prepareStatement(sqlQuery);
  1263.             stm.setLong(1, idUser);
  1264.             stm.executeUpdate();
  1265.             stm.close();
  1266.         } finally {

  1268.             //Chiudo statement and resultset
  1269.             try {
  1270.                 if (stm != null)
  1271.                     stm.close();
  1272.             } catch (Exception e) {
  1273.                 //ignore
  1274.             }
  1275.         }
  1276.     }
  1277.     
  1278.     private long _getIdUser(Connection connectionDB, User user) throws Exception {
  1279.         
  1280.         if (user == null)
  1281.             throw new DriverUsersDBException("[DriverUsersDB::_getIdUser] Parametro non valido.");

  1283.         String login = user.getLogin();
  1284.         if (login == null || login.equals(""))
  1285.             throw new DriverUsersDBException("[DriverUsersDB::_getIdUser] Parametro Login non valido.");

  1287.         long idUser = -1;
  1288.         if(user.getId()==null || user.getId().longValue()<=0) {
  1289.             idUser = this._getIdUser(connectionDB, login);
  1290.         }
  1291.         else {
  1292.             idUser = user.getId().longValue();
  1293.         }
  1294.         
  1295.         return idUser;
  1296.             
  1297.     }
  1298.     private long _getIdUser(Connection connectionDB, String login) throws Exception {
  1299.         
  1300.         PreparedStatement stm = null;
  1301.         ResultSet rs = null;
  1302.         String sqlQuery = "";

  1304.         if (login == null || login.equals(""))
  1305.             throw new DriverUsersDBException("[DriverUsersDB::_getIdUser] Parametro Login non valido.");

  1307.         try {
  1308.             
  1309.             long idUser = -1;
  1310.             // recupero id
  1311.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1312.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  1313.             sqlQueryObject.addWhereCondition("login = ?");
  1314.             sqlQuery = sqlQueryObject.createSQLQuery();
  1315.             stm = connectionDB.prepareStatement(sqlQuery);
  1316.             stm.setString(1, login);
  1317.             rs = stm.executeQuery();
  1318.             if(rs.next()) {
  1319.                 idUser = rs.getLong("id");
  1320.             }
  1321.             if(idUser<=0) {
  1322.                 throw new Exception("Impossibile recuperare id utente con login ["+login+"]");
  1323.             }
  1324.             rs.close();
  1325.             stm.close();
  1326.             
  1327.             return idUser;
  1328.             
  1329.         } finally {

  1331.             //Chiudo statement and resultset
  1332.             try {
  1333.                 if (rs != null)
  1334.                     rs.close();
  1335.             } catch (Exception e) {
  1336.                 //ignore
  1337.             }
  1338.             try {
  1339.                 if (stm != null)
  1340.                     stm.close();
  1341.             } catch (Exception e) {
  1342.                 //ignore
  1343.             }
  1344.         }
  1345.     }
  1346.     
  1347.     public List<IDServizio> utentiServiziList(String login, ISearch ricerca) throws DriverUsersDBException {
  1348.         String nomeMetodo = "utentiServiziList";
  1349.         int idLista = Liste.UTENTI_SERVIZI;
  1350.         int offset;
  1351.         int limit;
  1352.         String search;
  1353.         String queryString;

  1355.         limit = ricerca.getPageSize(idLista);
  1356.         offset = ricerca.getIndexIniziale(idLista);
  1357.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  1359.         String filterProtocollo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROTOCOLLO);
  1360.         String filterProtocolli = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROTOCOLLI);
  1361.         List<String> tipoServiziProtocollo = null;
  1362.         try {
  1363.             tipoServiziProtocollo = Filtri.convertToTipiServizi(filterProtocollo, filterProtocolli);
  1364.         }catch(Exception e) {
  1365.             throw new DriverUsersDBException(e.getMessage(),e);
  1366.         }

  1368.         String filterDominio = SearchUtils.getFilter(ricerca, idLista,  Filtri.FILTRO_DOMINIO);
  1369.         PddTipologia pddTipologia = null;
  1370.         if(filterDominio!=null && !"".equals(filterDominio)) {
  1371.             pddTipologia = PddTipologia.toPddTipologia(filterDominio);
  1372.         }
  1373.         
  1374.         this.log.debug("search : " + search);
  1375.         this.log.debug("filterProtocollo : " + filterProtocollo);
  1376.         this.log.debug("filterProtocolli : " + filterProtocolli);
  1377.         this.log.debug("filterDominio : " + filterDominio);
  1378.         
  1379.         Connection connectionDB = null;
  1380.         PreparedStatement stmt = null;
  1381.         ResultSet risultato = null;
  1382.         ArrayList<IDServizio> lista = new ArrayList<IDServizio>();

  1384.         try {
  1385.             // Get Connection
  1386.             connectionDB = getConnection();
  1387.             
  1388.             ISQLQueryObject sqlQueryObjectSoggetti = null;
  1389.             if (!search.equals("")) {
  1390.                 sqlQueryObjectSoggetti = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1391.                 sqlQueryObjectSoggetti.addFromTable(CostantiDB.SOGGETTI);
  1392.                 sqlQueryObjectSoggetti.addSelectField(CostantiDB.SOGGETTI, "tipo_soggetto");
  1393.                 sqlQueryObjectSoggetti.addSelectField(CostantiDB.SOGGETTI, "nome_soggetto");
  1394.                 sqlQueryObjectSoggetti.setANDLogicOperator(true);
  1395.                 sqlQueryObjectSoggetti.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto="+CostantiDB.SOGGETTI+".id");
  1396.                 sqlQueryObjectSoggetti.addWhereCondition(false,
  1397.                         //sqlQueryObjectSoggetti.getWhereLikeCondition("tipo_soggetto", search, true, true),
  1398.                         sqlQueryObjectSoggetti.getWhereLikeCondition("nome_soggetto", search, true, true));
  1399.             }

  1401.             ISQLQueryObject sqlQueryObjectPdd = null;
  1402.             if(pddTipologia!=null && PddTipologia.ESTERNO.equals(pddTipologia)) {
  1403.                 ISQLQueryObject sqlQueryObjectExistsPdd = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1404.                 sqlQueryObjectExistsPdd.addSelectField(CostantiDB.PDD+".nome");
  1405.                 sqlQueryObjectExistsPdd.addFromTable(CostantiDB.PDD);
  1406.                 sqlQueryObjectExistsPdd.setANDLogicOperator(true);
  1407.                 sqlQueryObjectExistsPdd.addWhereCondition(CostantiDB.PDD+".nome="+CostantiDB.SOGGETTI+".server");
  1408.                 sqlQueryObjectExistsPdd.addWhereCondition(CostantiDB.PDD+".tipo=?");
  1409.                 
  1410.                 sqlQueryObjectPdd = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1411.                 sqlQueryObjectPdd.setANDLogicOperator(false);
  1412.                 sqlQueryObjectPdd.addWhereIsNullCondition(CostantiDB.SOGGETTI+".server");
  1413.                 sqlQueryObjectPdd.addWhereExistsCondition(false, sqlQueryObjectExistsPdd);
  1414.             }
  1415.             
  1416.             
  1417.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1418.             sqlQueryObject.addSelectCountField("*", "cont");
  1419.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  1420.             sqlQueryObject.addFromTable(CostantiDB.USERS_SERVIZI);
  1421.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1422.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1423.             sqlQueryObject.addWhereCondition(CostantiDB.USERS+".login = ?");
  1424.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SERVIZI+".id_utente = "+CostantiDB.USERS+".id");
  1425.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SERVIZI+".id_servizio = "+CostantiDB.SERVIZI+".id");
  1426.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1427.             
  1428.             if (!search.equals("")) {
  1429.                 //query con search
  1430.                 sqlQueryObject.addWhereCondition(false, 
  1431.                         // - ricerca su tipo/nome servizio
  1432.                         //sqlQueryObject.getWhereLikeCondition("tipo_servizio", search, true, true), 
  1433.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.SERVIZI+".nome_servizio", search, true, true),
  1434.                         //sqlQueryObject.getWhereLikeCondition("versione_servizio", search, true, true),
  1435.                         sqlQueryObject.getWhereExistsCondition(false, sqlQueryObjectSoggetti));
  1436.             }
  1437.             
  1438.             if(tipoServiziProtocollo!=null && tipoServiziProtocollo.size()>0) {
  1439.                 sqlQueryObject.addWhereINCondition(CostantiDB.SERVIZI+".tipo_servizio", true, tipoServiziProtocollo.toArray(new String[1]));
  1440.             }
  1441.             if(pddTipologia!=null) {
  1442.                 if(PddTipologia.ESTERNO.equals(pddTipologia)) {
  1443.                     sqlQueryObject.addWhereCondition(sqlQueryObjectPdd.createSQLConditions());                          
  1444.                 }
  1445.                 else {
  1446.                     sqlQueryObject.addFromTable(CostantiDB.PDD);
  1447.                     sqlQueryObject.addWhereCondition(true,CostantiDB.PDD+".nome="+CostantiDB.SOGGETTI+".server",CostantiDB.PDD+".tipo=?");
  1448.                 }
  1449.             }
  1450.             
  1451.             sqlQueryObject.setANDLogicOperator(true);
  1452.             queryString = sqlQueryObject.createSQLQuery();
  1453.             stmt = connectionDB.prepareStatement(queryString);
  1454.             int index = 1;
  1455.             stmt.setString(index++, login);
  1456.             if(pddTipologia!=null) {
  1457.                 stmt.setString(index++, pddTipologia.toString());
  1458.             }
  1459.             risultato = stmt.executeQuery();
  1460.             if (risultato.next())
  1461.                 ricerca.setNumEntries(idLista, risultato.getInt(1));
  1462.             risultato.close();
  1463.             stmt.close();

  1465.             // ricavo le entries
  1466.             if (limit == 0) // con limit
  1467.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  1468.             
  1469.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1470.             sqlQueryObject.addSelectField(CostantiDB.USERS_SERVIZI+".id_servizio");
  1471.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI+".tipo_servizio");
  1472.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI+".nome_servizio");
  1473.             sqlQueryObject.addSelectField(CostantiDB.SERVIZI+".versione_servizio");
  1474.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".tipo_soggetto");
  1475.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".nome_soggetto");
  1476.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  1477.             sqlQueryObject.addFromTable(CostantiDB.USERS_SERVIZI);
  1478.             sqlQueryObject.addFromTable(CostantiDB.SERVIZI);
  1479.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1480.             sqlQueryObject.addWhereCondition(CostantiDB.USERS+".login = ?");
  1481.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SERVIZI+".id_utente = "+CostantiDB.USERS+".id");
  1482.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SERVIZI+".id_servizio = "+CostantiDB.SERVIZI+".id");
  1483.             sqlQueryObject.addWhereCondition(CostantiDB.SERVIZI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1484.             
  1485.             if (!search.equals("")) {
  1486.                 //query con search
  1487.                 sqlQueryObject.addWhereCondition(false, 
  1488.                         // - ricerca su tipo/nome servizio
  1489.                         //sqlQueryObject.getWhereLikeCondition("tipo_servizio", search, true, true), 
  1490.                         sqlQueryObject.getWhereLikeCondition(CostantiDB.SERVIZI+".nome_servizio", search, true, true),
  1491.                         //sqlQueryObject.getWhereLikeCondition("versione_servizio", search, true, true),
  1492.                         sqlQueryObject.getWhereExistsCondition(false, sqlQueryObjectSoggetti));
  1493.             } 
  1494.             
  1495.             if(tipoServiziProtocollo!=null && tipoServiziProtocollo.size()>0) {
  1496.                 sqlQueryObject.addWhereINCondition(CostantiDB.SERVIZI+".tipo_servizio", true, tipoServiziProtocollo.toArray(new String[1]));
  1497.             }
  1498.             if(pddTipologia!=null) {
  1499.                 if(PddTipologia.ESTERNO.equals(pddTipologia)) {
  1500.                     sqlQueryObject.addWhereCondition(sqlQueryObjectPdd.createSQLConditions());                          
  1501.                 }
  1502.                 else {
  1503.                     sqlQueryObject.addFromTable(CostantiDB.PDD);
  1504.                     sqlQueryObject.addWhereCondition(true,CostantiDB.PDD+".nome="+CostantiDB.SOGGETTI+".server",CostantiDB.PDD+".tipo=?");
  1505.                 }
  1506.             }
  1507.             
  1508.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI+".nome_servizio");
  1509.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI+".versione_servizio");
  1510.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".nome_soggetto");
  1511.             sqlQueryObject.addOrderBy(CostantiDB.SERVIZI+".tipo_servizio");
  1512.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".tipo_soggetto");
  1513.             sqlQueryObject.setSortType(true);
  1514.             sqlQueryObject.setLimit(limit);
  1515.             sqlQueryObject.setOffset(offset);
  1516.             sqlQueryObject.setANDLogicOperator(true);
  1517.             queryString = sqlQueryObject.createSQLQuery();
  1518.             stmt = connectionDB.prepareStatement(queryString);
  1519.             index = 1;
  1520.             stmt.setString(index++, login);
  1521.             if(pddTipologia!=null) {
  1522.                 stmt.setString(index++, pddTipologia.toString());
  1523.             }
  1524.             risultato = stmt.executeQuery();
  1525.             
  1526.             JDBCServiceManagerProperties jdbcProperties = new JDBCServiceManagerProperties();
  1527.             jdbcProperties.setDatabaseType(this.tipoDatabase);
  1528.             jdbcProperties.setShowSql(true);
  1529.             JDBCServiceManager manager = new JDBCServiceManager(connectionDB, jdbcProperties, this.log);
  1530. //          IDBSoggettoServiceSearch soggettiSearch = (IDBSoggettoServiceSearch) manager.getSoggettoServiceSearch();
  1531.             IDBAccordoServizioParteSpecificaServiceSearch serviziSearch = (IDBAccordoServizioParteSpecificaServiceSearch) manager.getAccordoServizioParteSpecificaServiceSearch();
  1532.             
  1533.             while (risultato.next()) {
  1534.                 long id = risultato.getLong("id_servizio");
  1535.                 AccordoServizioParteSpecifica servizio = serviziSearch.get(id);
  1536.                 IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(servizio.getTipo(), 
  1537.                         servizio.getNome(), 
  1538.                         servizio.getIdErogatore().getTipo(),
  1539.                         servizio.getIdErogatore().getNome(), 
  1540.                         servizio.getVersione());
  1541.                 lista.add(idServizio);
  1542.             }
  1543.             risultato.close();
  1544.             return lista;

  1546.         } catch (Exception qe) {
  1547.             throw new DriverUsersDBException("[DriverUsersDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1548.         } finally {

  1550.             //Chiudo statement and resultset
  1551.             try {
  1552.                 if(risultato!=null) {
  1553.                     risultato.close();
  1554.                 }
  1555.             } catch (Exception e) {
  1556.                 // ignore exception
  1557.             }
  1558.             try {
  1559.                 if(stmt!=null) {
  1560.                     stmt.close();
  1561.                 }
  1562.             } catch (Exception e) {
  1563.                 // ignore exception
  1564.             }
  1565.             
  1566.             releaseConnection(connectionDB);

  1568.         }
  1569.     }
  1570.     
  1571.     
  1572.     public List<IDSoggetto> utentiSoggettiList(String login, ISearch ricerca) throws DriverUsersDBException {
  1573.         String nomeMetodo = "utentiSoggettiList";
  1574.         int idLista = Liste.UTENTI_SOGGETTI;
  1575.         int offset;
  1576.         int limit;
  1577.         String search;
  1578.         String queryString;

  1580.         limit = ricerca.getPageSize(idLista);
  1581.         offset = ricerca.getIndexIniziale(idLista);
  1582.         search = (org.openspcoop2.core.constants.Costanti.SESSION_ATTRIBUTE_VALUE_RICERCA_UNDEFINED.equals(ricerca.getSearchString(idLista)) ? "" : ricerca.getSearchString(idLista));

  1584.         String filterProtocollo = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROTOCOLLO);
  1585.         String filterProtocolli = SearchUtils.getFilter(ricerca, idLista, Filtri.FILTRO_PROTOCOLLI);
  1586.         List<String> tipoSoggettiProtocollo = null;
  1587.         try {
  1588.             tipoSoggettiProtocollo = Filtri.convertToTipiSoggetti(filterProtocollo, filterProtocolli);
  1589.         }catch(Exception e) {
  1590.             throw new DriverUsersDBException(e.getMessage(),e);
  1591.         }
  1592.         
  1593.         String filterDominio = SearchUtils.getFilter(ricerca, idLista,  Filtri.FILTRO_DOMINIO);
  1594.         PddTipologia pddTipologia = null;
  1595.         if(filterDominio!=null && !"".equals(filterDominio)) {
  1596.             pddTipologia = PddTipologia.toPddTipologia(filterDominio);
  1597.         }
  1598.         
  1599.         this.log.debug("search : " + search);
  1600.         this.log.debug("filterProtocollo : " + filterProtocollo);
  1601.         this.log.debug("filterProtocolli : " + filterProtocolli);
  1602.         this.log.debug("filterDominio : " + filterDominio);
  1603.         
  1604.         Connection connectionDB = null;
  1605.         PreparedStatement stmt = null;
  1606.         ResultSet risultato = null;
  1607.         ArrayList<IDSoggetto> lista = new ArrayList<IDSoggetto>();

  1609.         try {
  1610.             
  1611.             // Get Connection
  1612.             connectionDB = getConnection();
  1613.             
  1614.             ISQLQueryObject sqlQueryObjectPdd = null;
  1615.             if(pddTipologia!=null && PddTipologia.ESTERNO.equals(pddTipologia)) {
  1616.                 ISQLQueryObject sqlQueryObjectExistsPdd = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1617.                 sqlQueryObjectExistsPdd.addSelectField(CostantiDB.PDD+".nome");
  1618.                 sqlQueryObjectExistsPdd.addFromTable(CostantiDB.PDD);
  1619.                 sqlQueryObjectExistsPdd.setANDLogicOperator(true);
  1620.                 sqlQueryObjectExistsPdd.addWhereCondition(CostantiDB.PDD+".nome="+CostantiDB.SOGGETTI+".server");
  1621.                 sqlQueryObjectExistsPdd.addWhereCondition(CostantiDB.PDD+".tipo=?");
  1622.                 
  1623.                 sqlQueryObjectPdd = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1624.                 sqlQueryObjectPdd.setANDLogicOperator(false);
  1625.                 sqlQueryObjectPdd.addWhereIsNullCondition(CostantiDB.SOGGETTI+".server");
  1626.                 sqlQueryObjectPdd.addWhereExistsCondition(false, sqlQueryObjectExistsPdd);
  1627.             }
  1628.             
  1629.             
  1630.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1631.             sqlQueryObject.addSelectCountField("*", "cont");
  1632.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  1633.             sqlQueryObject.addFromTable(CostantiDB.USERS_SOGGETTI);
  1634.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1635.             sqlQueryObject.addWhereCondition(CostantiDB.USERS+".login = ?");
  1636.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SOGGETTI+".id_utente = "+CostantiDB.USERS+".id");
  1637.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SOGGETTI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1638.             
  1639.             if (!search.equals("")) {
  1640.                 //query con search
  1641.                 sqlQueryObject.addWhereLikeCondition(CostantiDB.SOGGETTI+".nome_soggetto", search, true, true);
  1642.             }
  1643.             
  1644.             if(tipoSoggettiProtocollo!=null && tipoSoggettiProtocollo.size()>0) {
  1645.                 sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipoSoggettiProtocollo.toArray(new String[1]));
  1646.             }
  1647.             if(pddTipologia!=null) {
  1648.                 if(PddTipologia.ESTERNO.equals(pddTipologia)) {
  1649.                     sqlQueryObject.addWhereCondition(sqlQueryObjectPdd.createSQLConditions());                          
  1650.                 }
  1651.                 else {
  1652.                     sqlQueryObject.addFromTable(CostantiDB.PDD);
  1653.                     sqlQueryObject.addWhereCondition(true,CostantiDB.PDD+".nome="+CostantiDB.SOGGETTI+".server",CostantiDB.PDD+".tipo=?");
  1654.                 }
  1655.             }
  1656.             
  1657.             sqlQueryObject.setANDLogicOperator(true);
  1658.             queryString = sqlQueryObject.createSQLQuery();
  1659.             stmt = connectionDB.prepareStatement(queryString);
  1660.             int index = 1;
  1661.             stmt.setString(index++, login);
  1662.             if(pddTipologia!=null) {
  1663.                 stmt.setString(index++, pddTipologia.toString());
  1664.             }
  1665.             risultato = stmt.executeQuery();
  1666.             if (risultato.next())
  1667.                 ricerca.setNumEntries(idLista, risultato.getInt(1));
  1668.             risultato.close();
  1669.             stmt.close();

  1671.             // ricavo le entries
  1672.             if (limit == 0) // con limit
  1673.                 limit = ISQLQueryObject.LIMIT_DEFAULT_VALUE;
  1674.             
  1675.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1676.             sqlQueryObject.addSelectField(CostantiDB.USERS_SOGGETTI+".id_soggetto");
  1677.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".nome_soggetto");
  1678.             sqlQueryObject.addSelectField(CostantiDB.SOGGETTI+".tipo_soggetto");
  1679.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  1680.             sqlQueryObject.addFromTable(CostantiDB.USERS_SOGGETTI);
  1681.             sqlQueryObject.addFromTable(CostantiDB.SOGGETTI);
  1682.             sqlQueryObject.addWhereCondition(CostantiDB.USERS+".login = ?");
  1683.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SOGGETTI+".id_utente = "+CostantiDB.USERS+".id");
  1684.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_SOGGETTI+".id_soggetto = "+CostantiDB.SOGGETTI+".id");
  1685.             
  1686.             if (!search.equals("")) { // con search
  1687.                 sqlQueryObject.addWhereLikeCondition(CostantiDB.SOGGETTI+".nome_soggetto", search, true, true);
  1688.             }  
  1689.             
  1690.             if(tipoSoggettiProtocollo!=null && tipoSoggettiProtocollo.size()>0) {
  1691.                 sqlQueryObject.addWhereINCondition(CostantiDB.SOGGETTI+".tipo_soggetto", true, tipoSoggettiProtocollo.toArray(new String[1]));
  1692.             }
  1693.             if(pddTipologia!=null) {
  1694.                 if(PddTipologia.ESTERNO.equals(pddTipologia)) {
  1695.                     sqlQueryObject.addWhereCondition(sqlQueryObjectPdd.createSQLConditions());                                  
  1696.                 }
  1697.                 else {
  1698.                     sqlQueryObject.addFromTable(CostantiDB.PDD);
  1699.                     sqlQueryObject.addWhereCondition(true,CostantiDB.PDD+".nome="+CostantiDB.SOGGETTI+".server",CostantiDB.PDD+".tipo=?");
  1700.                 }
  1701.             }
  1702.             
  1703.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".nome_soggetto");
  1704.             sqlQueryObject.addOrderBy(CostantiDB.SOGGETTI+".tipo_soggetto");
  1705.             sqlQueryObject.setSortType(true);
  1706.             sqlQueryObject.setLimit(limit);
  1707.             sqlQueryObject.setOffset(offset);
  1708.             sqlQueryObject.setANDLogicOperator(true);
  1709.             queryString = sqlQueryObject.createSQLQuery();
  1710.             stmt = connectionDB.prepareStatement(queryString);
  1711.             index = 1;
  1712.             stmt.setString(index++, login);
  1713.             if(pddTipologia!=null) {
  1714.                 stmt.setString(index++, pddTipologia.toString());
  1715.             }
  1716.             risultato = stmt.executeQuery();
  1717.             
  1718.             JDBCServiceManagerProperties jdbcProperties = new JDBCServiceManagerProperties();
  1719.             jdbcProperties.setDatabaseType(this.tipoDatabase);
  1720.             jdbcProperties.setShowSql(true);
  1721.             JDBCServiceManager manager = new JDBCServiceManager(connectionDB, jdbcProperties, this.log);
  1722.             IDBSoggettoServiceSearch soggettiSearch = (IDBSoggettoServiceSearch) manager.getSoggettoServiceSearch();
  1723.             
  1724.             while (risultato.next()) {
  1725.                 long id = risultato.getLong("id_soggetto");
  1726.                 Soggetto soggetto = soggettiSearch.get(id);
  1727.                 IDSoggetto idSoggetto = new IDSoggetto(soggetto.getTipoSoggetto(), soggetto.getNomeSoggetto(), soggetto.getIdentificativoPorta());
  1728.                 lista.add(idSoggetto);
  1729.             }
  1730.             risultato.close();
  1731.             return lista;

  1733.         } catch (Exception qe) {
  1734.             throw new DriverUsersDBException("[DriverUsersDB::" + nomeMetodo + "] Errore : " + qe.getMessage(),qe);
  1735.         } finally {

  1737.             //Chiudo statement and resultset
  1738.             try {
  1739.                 if(risultato!=null) {
  1740.                     risultato.close();
  1741.                 }
  1742.             } catch (Exception e) {
  1743.                 // ignore exception
  1744.             }
  1745.             try {
  1746.                 if(stmt!=null) {
  1747.                     stmt.close();
  1748.                 }
  1749.             } catch (Exception e) {
  1750.                 // ignore exception
  1751.             }
  1752.             
  1753.             releaseConnection(connectionDB);

  1755.         }
  1756.     }
  1757.     
  1758.     /**
  1759.      * Restituisce lo stato identificato da <var>login</var> e da <var>nomeOggetto</var>
  1760.      * 
  1761.      * @param login Identificatore di un utente
  1762.      * @param nomeOggetto Oggetto da ricercare
  1763.      *               
  1764.      * @return Lo stato individuato
  1765.      */
  1766.     public Stato getStato(String login, String nomeOggetto) throws DriverUsersDBException {
  1767.         if (login == null || nomeOggetto == null)
  1768.             throw new DriverUsersDBException("[getStato] Parametri Non Validi");

  1770.         Connection connectionDB = null;
  1771.         PreparedStatement stm = null;
  1772.         ResultSet rs = null;
  1773.         Stato statoObject = null;
  1774.         try {
  1775.             // Get Connection
  1776.             connectionDB = getConnection();
  1777.             
  1778.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1779.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  1780.             sqlQueryObject.addFromTable(CostantiDB.USERS_STATI);
  1781.             sqlQueryObject.addSelectField(CostantiDB.USERS_STATI+".stato");
  1782.             sqlQueryObject.addSelectField(CostantiDB.USERS_STATI+".oggetto");
  1783.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_STATI+".id_utente = "+CostantiDB.USERS+".id");
  1784.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  1785.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_STATI +".oggetto = ?");
  1786.             sqlQueryObject.setANDLogicOperator(true);
  1787.             String sqlQuery = sqlQueryObject.createSQLQuery();
  1788.             stm = connectionDB.prepareStatement(sqlQuery);
  1789.             stm.setString(1, login);
  1790.             stm.setString(2, nomeOggetto);
  1791.             rs = stm.executeQuery();
  1792.             while (rs.next()) {
  1793.                 String oggetto = rs.getString("oggetto");
  1794.                 String stato = rs.getString("stato");
  1795.                 statoObject = new Stato();
  1796.                 statoObject.setOggetto(oggetto);
  1797.                 statoObject.setStato(stato);
  1798.             }
  1799.             rs.close();
  1800.             stm.close();

  1802.             return statoObject;
  1803.         } catch (SQLException se) {
  1804.             throw new DriverUsersDBException("[DriverUsersDB::getStato] SqlException: " + se.getMessage(),se);
  1805.         } catch (Exception ex) {
  1806.             throw new DriverUsersDBException("[DriverUsersDB::getStato] Exception: " + ex.getMessage(),ex);
  1807.         } finally {
  1808.             try {
  1809.                 if(rs!=null) {
  1810.                     rs.close();
  1811.                 }
  1812.             } catch (Exception e) {
  1813.                 // ignore exception
  1814.             }
  1815.             try {
  1816.                 if(stm!=null) {
  1817.                     stm.close();
  1818.                 }
  1819.             } catch (Exception e) {
  1820.                 // ignore exception
  1821.             }
  1822.             releaseConnection(connectionDB);

  1824.         }
  1825.     }
  1826.     
  1827.     /**
  1828.      * Aggiorna il protocollo utilizzato dall'utente <var>login</var>
  1829.      * 
  1830.      * @param login Identificatore di un utente
  1831.      * @param protocollo Protocollo
  1832.      *               
  1833.      */
  1834.     public void saveProtocolloUtilizzatoPddConsole(String login, String protocollo) throws DriverUsersDBException {
  1835.         if (login == null)
  1836.             throw new DriverUsersDBException("[saveProtocolloUtilizzatoPddConsole] Parametri Non Validi");

  1838.         Connection connectionDB = null;
  1839.         PreparedStatement stm = null;
  1840.         try {
  1841.             // Get Connection
  1842.             connectionDB = getConnection();
  1843.             
  1844.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1845.             sqlQueryObject.addUpdateTable(CostantiDB.USERS);
  1846.             sqlQueryObject.addUpdateField("protocollo_pddconsole", "?");
  1847.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  1848.             sqlQueryObject.setANDLogicOperator(true);
  1849.             String sqlQuery = sqlQueryObject.createSQLUpdate();
  1850.             stm = connectionDB.prepareStatement(sqlQuery);
  1851.             stm.setString(1, protocollo);
  1852.             stm.setString(2, login);
  1853.             stm.executeUpdate();
  1854.             stm.close();

  1856.         } catch (SQLException se) {
  1857.             throw new DriverUsersDBException("[DriverUsersDB::saveProtocolloUtilizzatoPddConsole] SqlException: " + se.getMessage(),se);
  1858.         } catch (Exception ex) {
  1859.             throw new DriverUsersDBException("[DriverUsersDB::saveProtocolloUtilizzatoPddConsole] Exception: " + ex.getMessage(),ex);
  1860.         } finally {
  1861.             try {
  1862.                 if(stm!=null) {
  1863.                     stm.close();
  1864.                 }
  1865.             } catch (Exception e) {
  1866.                 // ignore exception
  1867.             }
  1868.             releaseConnection(connectionDB);

  1870.         }
  1871.     }
  1872.     
  1873.     /**
  1874.      * Aggiorna il protocollo utilizzato dall'utente <var>login</var>
  1875.      * 
  1876.      * @param login Identificatore di un utente
  1877.      * @param protocollo Protocollo
  1878.      *               
  1879.      */
  1880.     public void saveProtocolloUtilizzatoPddMonitor(String login, String protocollo) throws DriverUsersDBException {
  1881.         if (login == null)
  1882.             throw new DriverUsersDBException("[saveProtocolloUtilizzatoPddMonitor] Parametri Non Validi");

  1884.         Connection connectionDB = null;
  1885.         PreparedStatement stm = null;
  1886.         try {
  1887.             // Get Connection
  1888.             connectionDB = getConnection();
  1889.             
  1890.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1891.             sqlQueryObject.addUpdateTable(CostantiDB.USERS);
  1892.             sqlQueryObject.addUpdateField("protocollo_pddmonitor", "?");
  1893.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  1894.             sqlQueryObject.setANDLogicOperator(true);
  1895.             String sqlQuery = sqlQueryObject.createSQLUpdate();
  1896.             stm = connectionDB.prepareStatement(sqlQuery);
  1897.             stm.setString(1, protocollo);
  1898.             stm.setString(2, login);
  1899.             stm.executeUpdate();
  1900.             stm.close();

  1902.         } catch (SQLException se) {
  1903.             throw new DriverUsersDBException("[DriverUsersDB::saveProtocolloUtilizzatoPddMonitor] SqlException: " + se.getMessage(),se);
  1904.         } catch (Exception ex) {
  1905.             throw new DriverUsersDBException("[DriverUsersDB::saveProtocolloUtilizzatoPddMonitor] Exception: " + ex.getMessage(),ex);
  1906.         } finally {
  1907.             try {
  1908.                 if(stm!=null) {
  1909.                     stm.close();
  1910.                 }
  1911.             } catch (Exception e) {
  1912.                 // ignore exception
  1913.             }
  1914.             releaseConnection(connectionDB);

  1916.         }
  1917.     }
  1918.     
  1919.     /**
  1920.      * Aggiorna il soggetto utilizzato dall'utente <var>login</var>
  1921.      * 
  1922.      * @param login Identificatore di un utente
  1923.      * @param soggetto Soggetto
  1924.      *               
  1925.      */
  1926.     public void saveSoggettoUtilizzatoPddConsole(String login, String soggetto) throws DriverUsersDBException {
  1927.         if (login == null)
  1928.             throw new DriverUsersDBException("[saveSoggettoUtilizzatoPddConsole] Parametri Non Validi");

  1930.         Connection connectionDB = null;
  1931.         try {
  1932.             // Get Connection
  1933.             connectionDB = getConnection();
  1934.             
  1935.             saveSoggettoUtilizzatoPddConsole(connectionDB, login, soggetto);

  1937.         } catch (SQLException se) {
  1938.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddConsole] SqlException: " + se.getMessage(),se);
  1939.         } catch (Exception ex) {
  1940.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddConsole] Exception: " + ex.getMessage(),ex);
  1941.         } finally {
  1942.             releaseConnection(connectionDB);

  1944.         }
  1945.     }
  1946.     
  1947.     public void saveSoggettoUtilizzatoPddConsole(Connection conParam, String login, String soggetto) throws DriverUsersDBException {
  1948.         if (login == null)
  1949.             throw new DriverUsersDBException("[saveSoggettoUtilizzatoPddConsole] Parametri Non Validi");

  1951.         PreparedStatement stm = null;
  1952.         try {           
  1953.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  1954.             sqlQueryObject.addUpdateTable(CostantiDB.USERS);
  1955.             sqlQueryObject.addUpdateField("soggetto_pddconsole", "?");
  1956.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  1957.             sqlQueryObject.setANDLogicOperator(true);
  1958.             String sqlQuery = sqlQueryObject.createSQLUpdate();
  1959.             stm = conParam.prepareStatement(sqlQuery);
  1960.             stm.setString(1, soggetto);
  1961.             stm.setString(2, login);
  1962.             stm.executeUpdate();
  1963.             stm.close();

  1965.         } catch (SQLException se) {
  1966.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddConsole] SqlException: " + se.getMessage(),se);
  1967.         } catch (Exception ex) {
  1968.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddConsole] Exception: " + ex.getMessage(),ex);
  1969.         } finally {
  1970.             try {
  1971.                 if(stm!=null) {
  1972.                     stm.close();
  1973.                 }
  1974.             } catch (Exception e) {
  1975.                 // ignore exception
  1976.             }
  1977.         }
  1978.     }
  1979.     
  1980.     /**
  1981.      * Aggiorna il soggetto utilizzato dall'utente <var>login</var>
  1982.      * 
  1983.      * @param login Identificatore di un utente
  1984.      * @param soggetto Soggetto
  1985.      *               
  1986.      */
  1987.     public void saveSoggettoUtilizzatoPddMonitor(String login, String soggetto) throws DriverUsersDBException {
  1988.         if (login == null)
  1989.             throw new DriverUsersDBException("[saveSoggettoUtilizzatoPddMonitor] Parametri Non Validi");

  1991.         Connection connectionDB = null;
  1992.         try {
  1993.             // Get Connection
  1994.             connectionDB = getConnection();
  1995.             
  1996.             saveSoggettoUtilizzatoPddMonitor(connectionDB, login, soggetto);

  1998.         } catch (SQLException se) {
  1999.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddMonitor] SqlException: " + se.getMessage(),se);
  2000.         } catch (Exception ex) {
  2001.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddMonitor] Exception: " + ex.getMessage(),ex);
  2002.         } finally {
  2003.             releaseConnection(connectionDB);

  2005.         }
  2006.     }
  2007.     
  2008.     public void saveSoggettoUtilizzatoPddMonitor(Connection conParam, String login, String soggetto) throws DriverUsersDBException {
  2009.         if (login == null)
  2010.             throw new DriverUsersDBException("[saveSoggettoUtilizzatoPddMonitor] Parametri Non Validi");

  2012.         PreparedStatement stm = null;
  2013.         try {           
  2014.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2015.             sqlQueryObject.addUpdateTable(CostantiDB.USERS);
  2016.             sqlQueryObject.addUpdateField("soggetto_pddmonitor", "?");
  2017.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  2018.             sqlQueryObject.setANDLogicOperator(true);
  2019.             String sqlQuery = sqlQueryObject.createSQLUpdate();
  2020.             stm = conParam.prepareStatement(sqlQuery);
  2021.             stm.setString(1, soggetto);
  2022.             stm.setString(2, login);
  2023.             stm.executeUpdate();
  2024.             stm.close();

  2026.         } catch (SQLException se) {
  2027.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddMonitor] SqlException: " + se.getMessage(),se);
  2028.         } catch (Exception ex) {
  2029.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddMonitor] Exception: " + ex.getMessage(),ex);
  2030.         } finally {
  2031.             try {
  2032.                 if(stm!=null) {
  2033.                     stm.close();
  2034.                 }
  2035.             } catch (Exception e) {
  2036.                 // ignore exception
  2037.             }
  2038.         }
  2039.     }
  2040.     
  2041.     /**
  2042.      * Aggiorna il soggetto utilizzato dall'utente <var>login</var>
  2043.      * 
  2044.      * @param oldSoggetto Identita precedentemente associata
  2045.      * @param newSoggetto Nuova identita associata
  2046.      *               
  2047.      */
  2048.     public void modificaSoggettoUtilizzatoConsole(String oldSoggetto, String newSoggetto) throws DriverUsersDBException {
  2049.         if (oldSoggetto == null) // || newSoggetto==null)
  2050.             throw new DriverUsersDBException("[modificaSoggettoUtilizzatoConsole] Parametri Non Validi");

  2052.         Connection connectionDB = null;
  2053.         PreparedStatement stm = null;
  2054.         ResultSet rs = null;
  2055.         try {
  2056.             // Get Connection
  2057.             connectionDB = getConnection();
  2058.             
  2059.             List<String> users = new ArrayList<>();
  2060.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2061.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  2062.             sqlQueryObject.addWhereCondition("soggetto_pddconsole=?");
  2063.             sqlQueryObject.setANDLogicOperator(true);
  2064.             String sqlQuery = sqlQueryObject.createSQLQuery();
  2065.             stm = connectionDB.prepareStatement(sqlQuery);
  2066.             stm.setString(1, oldSoggetto);
  2067.             rs = stm.executeQuery();
  2068.             while(rs.next()) {
  2069.                 String login = rs.getString("login");
  2070.                 users.add(login);
  2071.             }
  2072.             rs.close();
  2073.             stm.close();
  2074.             if(!users.isEmpty()) {
  2075.                 for (String user : users) {
  2076.                     this.saveSoggettoUtilizzatoPddConsole(connectionDB, user, newSoggetto);
  2077.                 }
  2078.             }
  2079.             
  2080.             users = new ArrayList<>();
  2081.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2082.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  2083.             sqlQueryObject.addWhereCondition("soggetto_pddmonitor=?");
  2084.             sqlQueryObject.setANDLogicOperator(true);
  2085.             sqlQuery = sqlQueryObject.createSQLQuery();
  2086.             stm = connectionDB.prepareStatement(sqlQuery);
  2087.             stm.setString(1, oldSoggetto);
  2088.             rs = stm.executeQuery();
  2089.             while(rs.next()) {
  2090.                 String login = rs.getString("login");
  2091.                 users.add(login);
  2092.             }
  2093.             rs.close();
  2094.             stm.close();
  2095.             if(!users.isEmpty()) {
  2096.                 for (String user : users) {
  2097.                     this.saveSoggettoUtilizzatoPddMonitor(connectionDB, user, newSoggetto);
  2098.                 }
  2099.             }


  2102.         } catch (SQLException se) {
  2103.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddMonitor] SqlException: " + se.getMessage(),se);
  2104.         } catch (Exception ex) {
  2105.             throw new DriverUsersDBException("[DriverUsersDB::saveSoggettoUtilizzatoPddMonitor] Exception: " + ex.getMessage(),ex);
  2106.         } finally {
  2107.             try {
  2108.                 if(rs!=null) {
  2109.                     rs.close();
  2110.                 }
  2111.             } catch (Exception e) {
  2112.                 // ignore exception
  2113.             }
  2114.             try {
  2115.                 if(stm!=null) {
  2116.                     stm.close();
  2117.                 }
  2118.             } catch (Exception e) {
  2119.                 // ignore exception
  2120.             }
  2121.             releaseConnection(connectionDB);

  2123.         }
  2124.     }
  2125.     
  2126.     /**
  2127.      * Aggiorna lo stato identificato da <var>login</var> e da <var>nomeOggetto</var> 
  2128.      * 
  2129.      * @param login Identificatore di un utente
  2130.      * @param nomeOggetto Oggetto da ricercare
  2131.      * @param statoOggetto Stato da salvare
  2132.      *               
  2133.      */
  2134.     public void saveStato(String login, String nomeOggetto, String statoOggetto) throws DriverUsersDBException {
  2135.         if (login == null || nomeOggetto == null)
  2136.             throw new DriverUsersDBException("[saveStato] Parametri Non Validi");

  2138.         Connection connectionDB = null;
  2139.         PreparedStatement stm = null;
  2140.         ResultSet rs = null;
  2141.         try {
  2142.             // Get Connection
  2143.             connectionDB = getConnection();
  2144.             
  2145.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2146.             sqlQueryObject.addSelectField("id");
  2147.             sqlQueryObject.addFromTable(CostantiDB.USERS);
  2148.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  2149.             String sqlQuery = sqlQueryObject.createSQLQuery();
  2150.             stm = connectionDB.prepareStatement(sqlQuery);
  2151.             stm.setString(1, login);
  2152.             rs = stm.executeQuery();
  2153.             
  2154.             Long idUtente = null; 
  2155.             while (rs.next()) {
  2156.                 idUtente = rs.getLong("id");
  2157.             }
  2158.             rs.close();
  2159.             stm.close();
  2160.             
  2161.             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2162.             sqlQueryObject.addUpdateTable(CostantiDB.USERS_STATI);
  2163.             sqlQueryObject.addUpdateField("stato","?");
  2164.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_STATI+".id_utente = ?");
  2165.             sqlQueryObject.addWhereCondition(CostantiDB.USERS_STATI +".oggetto = ?");
  2166.             sqlQueryObject.setANDLogicOperator(true);
  2167.             sqlQuery = sqlQueryObject.createSQLUpdate();
  2168.             stm = connectionDB.prepareStatement(sqlQuery);
  2169.             stm.setString(1, statoOggetto);
  2170.             stm.setLong(2, idUtente);
  2171.             stm.setString(3, nomeOggetto);
  2172.             int update = stm.executeUpdate();
  2173.             stm.close();
  2174.             
  2175.             // nuovo stato
  2176.             if(update == 0) {
  2177.                 sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2178.                 sqlQueryObject.addInsertTable(CostantiDB.USERS_STATI);
  2179.                 sqlQueryObject.addInsertField("stato","?");
  2180.                 sqlQueryObject.addInsertField("id_utente","?");
  2181.                 sqlQueryObject.addInsertField("oggetto","?");
  2182.                 sqlQuery = sqlQueryObject.createSQLInsert();
  2183.                 stm = connectionDB.prepareStatement(sqlQuery);
  2184.                 stm.setString(1, statoOggetto);
  2185.                 stm.setLong(2, idUtente);
  2186.                 stm.setString(3, nomeOggetto);
  2187.                 update = stm.executeUpdate();
  2188.                 stm.close();
  2189.             }

  2191.         } catch (SQLException se) {
  2192.             throw new DriverUsersDBException("[DriverUsersDB::saveStato] SqlException: " + se.getMessage(),se);
  2193.         } catch (Exception ex) {
  2194.             throw new DriverUsersDBException("[DriverUsersDB::saveStato] Exception: " + ex.getMessage(),ex);
  2195.         } finally {
  2196.             try {
  2197.                 if(rs!=null) {
  2198.                     rs.close();
  2199.                 }
  2200.             } catch (Exception e) {
  2201.                 // ignore exception
  2202.             }
  2203.             try {
  2204.                 if(stm!=null) {
  2205.                     stm.close();
  2206.                 }
  2207.             } catch (Exception e) {
  2208.                 // ignore exception
  2209.             }
  2210.             releaseConnection(connectionDB);

  2212.         }
  2213.     }
  2214.     
  2215.     
  2216.     public void savePassword(Long idUser, String login, String newPassword, Date dataAggiornamentoPassword) throws DriverUsersDBException {
  2217.         this.savePassword(idUser, login, newPassword, dataAggiornamentoPassword, null);
  2218.     }
  2219.     
  2220.     public void savePassword(Long idUser, String login, String password, Date dataAggiornamentoPassword, List<UserPassword> storicoPassword) throws DriverUsersDBException {
  2221.         if (login == null || password==null)
  2222.             throw new DriverUsersDBException("[savePassword] Parametri Non Validi");

  2224.         Connection connectionDB = null;
  2225.         PreparedStatement stm = null;
  2226.         try {
  2227.             // Get Connection
  2228.             connectionDB = getConnection();
  2229.             
  2230.             ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2231.             sqlQueryObject.addUpdateTable(CostantiDB.USERS);
  2232.             sqlQueryObject.addUpdateField("password", "?");
  2233.             if(dataAggiornamentoPassword!=null) {
  2234.                 sqlQueryObject.addUpdateField("data_password", "?");
  2235.             }
  2236.             sqlQueryObject.addWhereCondition(CostantiDB.USERS +".login = ?");
  2237.             sqlQueryObject.setANDLogicOperator(true);
  2238.             String sqlQuery = sqlQueryObject.createSQLUpdate();
  2239.             stm = connectionDB.prepareStatement(sqlQuery);
  2240.             int index = 1;
  2241.             stm.setString(index++, password);
  2242.             if(dataAggiornamentoPassword!=null) {
  2243.                 stm.setTimestamp(index++, new Timestamp(dataAggiornamentoPassword.getTime()));
  2244.             }
  2245.             stm.setString(index++, login);
  2246.             stm.executeUpdate();
  2247.             stm.close();
  2248.             
  2249.             // salvataggio dello storico password
  2250.             if(storicoPassword != null) {
  2251.                 try {
  2252.                     sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2253.                     sqlQueryObject.addDeleteTable(CostantiDB.USERS_PASSWORD);
  2254.                     sqlQueryObject.addWhereCondition("id_utente = ?");
  2255.                     sqlQuery = sqlQueryObject.createSQLDelete();
  2256.                     stm = connectionDB.prepareStatement(sqlQuery);
  2257.                     stm.setLong(1, idUser);
  2258.                     stm.executeUpdate();
  2259.                     stm.close();
  2260.                 } finally {

  2262.                     //Chiudo statement and resultset
  2263.                     try {
  2264.                         if (stm != null)
  2265.                             stm.close();
  2266.                     } catch (Exception e) {
  2267.                         //ignore
  2268.                     }
  2269.                 }
  2270.                 
  2271.                 if(storicoPassword.size()>0) {
  2272.                     stm = null;
  2273.                     ResultSet rs = null;
  2274.                     try {
  2275.                         for (UserPassword userPassword : storicoPassword) {
  2276.                             
  2277.                             sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2278.                             sqlQueryObject.addInsertTable(CostantiDB.USERS_PASSWORD);
  2279.                             sqlQueryObject.addInsertField("id_utente", "?");
  2280.                             sqlQueryObject.addInsertField("password", "?");
  2281.                             sqlQueryObject.addInsertField("data_password", "?");
  2282.                             sqlQuery = sqlQueryObject.createSQLInsert();
  2283.                             stm = connectionDB.prepareStatement(sqlQuery);
  2284.                             index = 1;
  2285.                             stm.setLong(index++, idUser);
  2286.                             stm.setString(index++, userPassword.getPassword());
  2287.                             stm.setTimestamp(index++, new Timestamp(userPassword.getDatePassword().getTime()));
  2288.                             stm.executeUpdate();
  2289.                             stm.close();
  2290.                         }
  2291.                     } finally {

  2293.                         //Chiudo statement and resultset
  2294.                         try {
  2295.                             if (rs != null)
  2296.                                 rs.close();
  2297.                         } catch (Exception e) {
  2298.                             //ignore
  2299.                         }
  2300.                         try {
  2301.                             if (stm != null)
  2302.                                 stm.close();
  2303.                         } catch (Exception e) {
  2304.                             //ignore
  2305.                         }
  2306.                         
  2307.                     }
  2308.                 }
  2309.             }

  2311.         } catch (SQLException se) {
  2312.             throw new DriverUsersDBException("[DriverUsersDB::savePassword] SqlException: " + se.getMessage(),se);
  2313.         } catch (Exception ex) {
  2314.             throw new DriverUsersDBException("[DriverUsersDB::savePassword] Exception: " + ex.getMessage(),ex);
  2315.         } finally {
  2316.             try {
  2317.                 if(stm!=null) {
  2318.                     stm.close();
  2319.                 }
  2320.             } catch (Exception e) {
  2321.                 // ignore exception
  2322.             }
  2323.             releaseConnection(connectionDB);

  2325.         }
  2326.     }
  2327.     
  2328.     public UserObjects countUserServizi(String user) throws DriverUsersDBException {
  2329.         return countUser(user, false);
  2330.     }
  2331.     public UserObjects countUserCooperazione(String user) throws DriverUsersDBException {
  2332.         return countUser(user, true);
  2333.     }
  2334.     public UserObjects countUser(String user, boolean cooperazione) throws DriverUsersDBException {
  2335.         if (user==null)
  2336.             throw new DriverUsersDBException("[countUser] Parametri Non Validi");

  2338.         Connection connectionDB = null;
  2339.         PreparedStatement stm = null;
  2340.         ResultSet rs = null;
  2341.         try {
  2342.             // Get Connection
  2343.             connectionDB = getConnection();
  2344.             
  2345.             List<String> tables = new ArrayList<>();
  2346.             if(cooperazione) {
  2347.                 tables.add(CostantiDB.ACCORDI_COOPERAZIONE);
  2348.                 tables.add(CostantiDB.ACCORDI);
  2349.             }
  2350.             else {
  2351.                 tables.add(CostantiDB.PDD);
  2352.                 tables.add(CostantiDB.GRUPPI);
  2353.                 tables.add(CostantiDB.RUOLI);
  2354.                 tables.add(CostantiDB.SCOPE);
  2355.                 tables.add(CostantiDB.SOGGETTI);
  2356.                 tables.add(CostantiDB.ACCORDI);
  2357.                 tables.add(CostantiDB.SERVIZI);
  2358.             }
  2359.         
  2360.             UserObjects results = new UserObjects();
  2361.             
  2362.             for (String table : tables) {
  2363.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2364.                 sqlQueryObject.addFromTable(table);
  2365.                 sqlQueryObject.addSelectCountField("id", "somma");
  2366.                 sqlQueryObject.addWhereCondition("superuser = ?");
  2367.                 if(CostantiDB.ACCORDI.equals(table)) {
  2368.                     
  2369.                     ISQLQueryObject sqlQueryObjectExclude = null;
  2370.                     sqlQueryObjectExclude = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2371.                     sqlQueryObjectExclude.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  2372.                     sqlQueryObjectExclude.addSelectField(CostantiDB.ACCORDI_SERVIZI_COMPOSTO, "id_accordo");
  2373.                     sqlQueryObjectExclude.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo="+CostantiDB.ACCORDI+".id");
  2374.                     if(cooperazione){
  2375.                         sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectExclude);
  2376.                     }
  2377.                     else{
  2378.                         sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectExclude);
  2379.                     }
  2380.                     
  2381.                 }
  2382.                 sqlQueryObject.setANDLogicOperator(true);
  2383.                 String sqlQuery = sqlQueryObject.createSQLQuery();
  2384.                 stm = connectionDB.prepareStatement(sqlQuery);
  2385.                 int index = 1;
  2386.                 stm.setString(index++, user);
  2387.                 rs = stm.executeQuery();
  2388.                 int result = rs.getInt("somma");
  2389.                 rs.close();
  2390.                 stm.close();
  2391.                 
  2392.                 if(CostantiDB.PDD.equals(table)) {
  2393.                     results.pdd = result;
  2394.                 }
  2395.                 else if(CostantiDB.GRUPPI.equals(table)) {
  2396.                     results.gruppi = result;
  2397.                 }
  2398.                 else if(CostantiDB.RUOLI.equals(table)) {
  2399.                     results.ruoli = result;
  2400.                 }
  2401.                 else if(CostantiDB.SCOPE.equals(table)) {
  2402.                     results.scope = result;
  2403.                 }
  2404.                 else if(CostantiDB.SOGGETTI.equals(table)) {
  2405.                     results.soggetti = result;
  2406.                 }
  2407.                 else if(CostantiDB.ACCORDI.equals(table)) {
  2408.                     results.accordi_parte_comune = result;
  2409.                 }
  2410.                 else if(CostantiDB.ACCORDI_COOPERAZIONE.equals(table)) {
  2411.                     results.accordi_accoperazione = result;
  2412.                 }
  2413.                 else if(CostantiDB.SERVIZI.equals(table)) {
  2414.                     results.accordi_parte_specifica = result;
  2415.                 }
  2416.             }
  2417.             
  2418.             return results;
  2419.             
  2420.         } catch (SQLException se) {
  2421.             throw new DriverUsersDBException("[DriverUsersDB::countUser] SqlException: " + se.getMessage(),se);
  2422.         } catch (Exception ex) {
  2423.             throw new DriverUsersDBException("[DriverUsersDB::countUser] Exception: " + ex.getMessage(),ex);
  2424.         } finally {
  2425.             try {
  2426.                 if(rs!=null) {
  2427.                     rs.close();
  2428.                 }
  2429.             } catch (Exception e) {
  2430.                 // ignore exception
  2431.             }
  2432.             try {
  2433.                 if(stm!=null) {
  2434.                     stm.close();
  2435.                 }
  2436.             } catch (Exception e) {
  2437.                 // ignore exception
  2438.             }
  2439.             releaseConnection(connectionDB);

  2441.         }
  2442.     }
  2443.     
  2444.     public UserObjects updateUserServizi(String oldUser, String newUser) throws DriverUsersDBException {
  2445.         return updateUser(oldUser, newUser, false);
  2446.     }
  2447.     public UserObjects updateUserCooperazione(String oldUser, String newUser) throws DriverUsersDBException {
  2448.         return updateUser(oldUser, newUser, true);
  2449.     }
  2450.     public UserObjects updateUser(String oldUser, String newUser, boolean cooperazione) throws DriverUsersDBException {
  2451.         if (oldUser == null || newUser==null)
  2452.             throw new DriverUsersDBException("[updateUser] Parametri Non Validi");

  2454.         Connection connectionDB = null;
  2455.         PreparedStatement stm = null;
  2456.         try {
  2457.             // Get Connection
  2458.             connectionDB = getConnection();
  2459.             
  2460.             List<String> tables = new ArrayList<>();
  2461.             if(cooperazione) {
  2462.                 tables.add(CostantiDB.ACCORDI_COOPERAZIONE);
  2463.                 tables.add(CostantiDB.ACCORDI);
  2464.             }
  2465.             else {
  2466.                 tables.add(CostantiDB.PDD);
  2467.                 tables.add(CostantiDB.GRUPPI);
  2468.                 tables.add(CostantiDB.RUOLI);
  2469.                 tables.add(CostantiDB.SCOPE);
  2470.                 tables.add(CostantiDB.SOGGETTI);
  2471.                 tables.add(CostantiDB.ACCORDI);
  2472.                 tables.add(CostantiDB.SERVIZI);
  2473.             }
  2474.         
  2475.             UserObjects results = new UserObjects();
  2476.             
  2477.             for (String table : tables) {
  2478.                 ISQLQueryObject sqlQueryObject = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2479.                 sqlQueryObject.addUpdateTable(table);
  2480.                 sqlQueryObject.addUpdateField("superuser", "?");
  2481.                 sqlQueryObject.addWhereCondition("superuser = ?");
  2482.                 if(CostantiDB.ACCORDI.equals(table)) {
  2483.                     
  2484.                     ISQLQueryObject sqlQueryObjectExclude = null;
  2485.                     sqlQueryObjectExclude = SQLObjectFactory.createSQLQueryObject(this.tipoDatabase);
  2486.                     sqlQueryObjectExclude.addFromTable(CostantiDB.ACCORDI_SERVIZI_COMPOSTO);
  2487.                     sqlQueryObjectExclude.addSelectField(CostantiDB.ACCORDI_SERVIZI_COMPOSTO, "id_accordo");
  2488.                     sqlQueryObjectExclude.addWhereCondition(CostantiDB.ACCORDI_SERVIZI_COMPOSTO+".id_accordo="+CostantiDB.ACCORDI+".id");
  2489.                     if(cooperazione){
  2490.                         sqlQueryObject.addWhereExistsCondition(false, sqlQueryObjectExclude);
  2491.                     }
  2492.                     else{
  2493.                         sqlQueryObject.addWhereExistsCondition(true, sqlQueryObjectExclude);
  2494.                     }
  2495.                     
  2496.                 }
  2497.                 sqlQueryObject.setANDLogicOperator(true);
  2498.                 String sqlQuery = sqlQueryObject.createSQLUpdate();
  2499.                 stm = connectionDB.prepareStatement(sqlQuery);
  2500.                 int index = 1;
  2501.                 stm.setString(index++, newUser);
  2502.                 stm.setString(index++, oldUser);
  2503.                 int result = stm.executeUpdate();
  2504.                 stm.close();
  2505.                 
  2506.                 if(CostantiDB.PDD.equals(table)) {
  2507.                     results.pdd = result;
  2508.                 }
  2509.                 else if(CostantiDB.GRUPPI.equals(table)) {
  2510.                     results.gruppi = result;
  2511.                 }
  2512.                 else if(CostantiDB.RUOLI.equals(table)) {
  2513.                     results.ruoli = result;
  2514.                 }
  2515.                 else if(CostantiDB.SCOPE.equals(table)) {
  2516.                     results.scope = result;
  2517.                 }
  2518.                 else if(CostantiDB.SOGGETTI.equals(table)) {
  2519.                     results.soggetti = result;
  2520.                 }
  2521.                 else if(CostantiDB.ACCORDI.equals(table)) {
  2522.                     results.accordi_parte_comune = result;
  2523.                 }
  2524.                 else if(CostantiDB.ACCORDI_COOPERAZIONE.equals(table)) {
  2525.                     results.accordi_accoperazione = result;
  2526.                 }
  2527.                 else if(CostantiDB.SERVIZI.equals(table)) {
  2528.                     results.accordi_parte_specifica = result;
  2529.                 }
  2530.             }
  2531.             
  2532.             return results;
  2533.             
  2534.         } catch (SQLException se) {
  2535.             throw new DriverUsersDBException("[DriverUsersDB::updateUser] SqlException: " + se.getMessage(),se);
  2536.         } catch (Exception ex) {
  2537.             throw new DriverUsersDBException("[DriverUsersDB::updateUser] Exception: " + ex.getMessage(),ex);
  2538.         } finally {
  2539.             try {
  2540.                 if(stm!=null) {
  2541.                     stm.close();
  2542.                 }
  2543.             } catch (Exception e) {
  2544.                 // ignore exception
  2545.             }
  2546.             releaseConnection(connectionDB);
  2547.         }
  2548.     }
  2549. }
Created with JaCoCo 0.8.8.202204050719